private void GetValue(Dictionary <string, TmpTestNodeMethod> resultDictionary, XElement test)
{
try
{
var result = new TmpTestNodeMethod(test.Attribute("name").Value);
result.State = Switch.Into <TestNodeState>()
.From(test.Attribute("result").Value)
.Case("Pass", TestNodeState.Success)
.Case("Skip", TestNodeState.Inactive)
.Case("Fail", TestNodeState.Failure)
.Default(TestNodeState.Inconclusive);
if (result.State != TestNodeState.Success)
{
result.Message = test.Descendants(XName.Get("message", ""))
.Select(d => d.Value).MaySingle().Else("");
result.StackTrace =
test.Descendants(XName.Get("stack-trace", "")).Select(d => d.Value).MaySingle().Else("");
result.Message = result.Message + "\n" + result.StackTrace;
}
resultDictionary.Add(result.Name, result);
}
catch (Exception e)
{
_log.Error("Log file parsing error", e);
}
}
private void GetValue(Dictionary<string, TmpTestNodeMethod> resultDictionary, XElement test)
{
try
{
var result = new TmpTestNodeMethod(test.Attribute("name").Value);
result.State = Switch.Into<TestNodeState>()
.From(test.Attribute("result").Value)
.Case("Pass", TestNodeState.Success)
.Case("Skip", TestNodeState.Inactive)
.Case("Fail", TestNodeState.Failure)
.Default(TestNodeState.Inconclusive);
if (result.State != TestNodeState.Success)
{
result.Message = test.Descendants(XName.Get("message", ""))
.Select(d => d.Value).MaySingle().Else("");
result.StackTrace =
test.Descendants(XName.Get("stack-trace", "")).Select(d => d.Value).MaySingle().Else("");
result.Message = result.Message + "\n" + result.StackTrace;
}
resultDictionary.Add(result.Name, result);
}
catch (Exception e)
{
_log.Error("Log file parsing error", e);
}
}
public async Task <MutantTestResults> RunTests(
string inputFile, string outputFile)
{
_log.Debug("Running tests on: " + inputFile);
try
{
ProcessResults results = await RunNUnitConsole(_nUnitConsolePath, inputFile, outputFile);
_log.Debug("Process finished.");
if (!_svc.FileSystem.File.Exists(outputFile))
{
string output = results.StandardOutput
.Concat(results.StandardError)
.Aggregate((a, b) => a + "\n" + b);
if (output.Contains("Process is terminated due to StackOverflowException."))
{
TmpTestNodeMethod node = new TmpTestNodeMethod("One of the tests.");
node.State = TestNodeState.Failure;
node.Message = "One of the tests threw StackOverflowException.";
_log.Info("XUnit: One of the tests threw StackOverflowException.");
return(new MutantTestResults(new List <TmpTestNodeMethod> {
node
}));
}
else
{
throw new Exception("Test results in file: " + outputFile + " not found. Output: " + output);
}
}
else
{
Dictionary <string, TmpTestNodeMethod> tresults = _parser.ProcessResultFile(outputFile);
List <TmpTestNodeMethod> testResults = tresults.Values.ToList();
var count = testResults
.Select(t => t.State).GroupBy(t => t)
.ToDictionary(t => t.Key, t => t.Count());
_log.Info(string.Format("XUnit test results: Passed: {0}, Failed: {1}, Inconc: {2}",
count.GetOrDefault(TestNodeState.Success),
count.GetOrDefault(TestNodeState.Failure),
count.GetOrDefault(TestNodeState.Inconclusive)));
return(new MutantTestResults(testResults));
}
}
catch (OperationCanceledException)
{
_log.Error("Test run cancelled.");
return(new MutantTestResults(cancelled: true));
}
}
public async Task <MutantTestResults> RunTests(
string inputFile, string outputFile)
{
_log.Debug("Running tests on: " + inputFile);
try
{
ProcessResults results = await RunNUnitConsole(_nUnitConsolePath, inputFile, outputFile);
if (!_svc.FileSystem.File.Exists(outputFile))
{
throw new Exception("Test results in file: " + outputFile + " not found. Output: " +
results.StandardOutput.Aggregate((a, b) => a + "\n" + b));
}
else
{
if (results.StandardError.Length > 0 || results.StandardOutput.Any(p => p.Contains("NUnitEngineException:")))
{
var stb = new StringBuilder();
stb.Append(results.StandardOutput);
stb.Append(results.StandardError);
throw new Exception(stb.ToString());
}
//it fails when we mutate exe file instead of dll
Dictionary <string, MyTestResult> tresults = _parser.ProcessResultFile(outputFile);
IList <MyTestResult> testResults = tresults.Values.ToList();
var list = new List <TmpTestNodeMethod>();
foreach (var myTestResult in testResults)
{
TmpTestNodeMethod node = new TmpTestNodeMethod(myTestResult.Name);
node.State = myTestResult.Success ? TestNodeState.Success : TestNodeState.Failure;
node.Message = myTestResult.Message + "\n" + myTestResult.StackTrace;
list.Add(node);
}
return(new MutantTestResults(list));
}
}
catch (OperationCanceledException)
{
_log.Error("Test run cancelled.");
return(new MutantTestResults(cancelled: true));
}
}
public Dictionary <string, TmpTestNodeMethod> ProcessResultFile(string fileName)
{
_log.Debug("Processing result file: " + fileName);
var s = new XmlReaderSettings {
CheckCharacters = false
};
var resultDictionary = new Dictionary <string, TmpTestNodeMethod>();
using (XmlReader reader = XmlReader.Create(fileName, s))
{
var doc = XDocument.Load(reader);
foreach (XElement testResult in doc.Root.DescendantsAnyNs("UnitTestResult"))
{
string value = testResult.Attribute("testId").Value;
var unitTest = doc.Root.DescendantsAnyNs("UnitTest")
.Single(n => n.Attribute("id").Value == value);
var testMethod = unitTest.ElementAnyNs("TestMethod");
string methodName = testMethod.Attribute("name").Value;
string longClassName = testMethod.Attribute("className").Value;
string fullClassName = longClassName.Substring(0, longClassName.IndexOf(","));
var node = new TmpTestNodeMethod(fullClassName + "." + methodName);
node.State = TranslateTestResultStatus(testResult.Attribute("outcome").Value);
if (node.State == TestNodeState.Failure)
{
var errorInfo = testResult.DescendantsAnyNs("ErrorInfo").Single();
node.Message = errorInfo.ElementAnyNs("Message").Value;
}
resultDictionary.Add(node.Name, node);
}
}
return(resultDictionary);
}
public Dictionary<string, TmpTestNodeMethod> ProcessResultFile(string fileName)
{
_log.Debug("Processing result file: " + fileName);
var s = new XmlReaderSettings {CheckCharacters = false};
var resultDictionary = new Dictionary<string, TmpTestNodeMethod>();
using(XmlReader reader = XmlReader.Create(fileName, s))
{
var doc = XDocument.Load(reader);
foreach (XElement testResult in doc.Root.DescendantsAnyNs("UnitTestResult"))
{
string value = testResult.Attribute("testId").Value;
var unitTest = doc.Root.DescendantsAnyNs("UnitTest")
.Single(n => n.Attribute("id").Value == value);
var testMethod = unitTest.ElementAnyNs("TestMethod");
string methodName = testMethod.Attribute("name").Value;
string longClassName = testMethod.Attribute("className").Value;
string fullClassName = longClassName.Substring(0, longClassName.IndexOf(","));
var node = new TmpTestNodeMethod(fullClassName + "." + methodName);
node.State = TranslateTestResultStatus(testResult.Attribute("outcome").Value);
if (node.State == TestNodeState.Failure)
{
var errorInfo = testResult.DescendantsAnyNs("ErrorInfo").Single();
node.Message = errorInfo.ElementAnyNs("Message").Value;
}
resultDictionary.Add(node.Name, node);
}
}
return resultDictionary;
}
public async Task<MutantTestResults> RunTests(
string inputFile, string outputFile)
{
_log.Debug("Running tests on: " + inputFile);
try
{
ProcessResults results = await RunNUnitConsole(_nUnitConsolePath, inputFile, outputFile);
_log.Debug("Process finished.");
if (!_svc.FileSystem.File.Exists(outputFile))
{
string output = results.StandardOutput
.Concat(results.StandardError)
.Aggregate((a, b) => a + "\n" + b);
if (output.Contains("Process is terminated due to StackOverflowException."))
{
TmpTestNodeMethod node = new TmpTestNodeMethod("One of the tests.");
node.State = TestNodeState.Failure;
node.Message = "One of the tests threw StackOverflowException.";
_log.Info("XUnit: One of the tests threw StackOverflowException.");
return new MutantTestResults(new List<TmpTestNodeMethod> { node });
}
else
{
throw new Exception("Test results in file: " + outputFile + " not found. Output: " + output);
}
}
else
{
Dictionary<string, TmpTestNodeMethod> tresults = _parser.ProcessResultFile(outputFile);
List<TmpTestNodeMethod> testResults = tresults.Values.ToList();
var count = testResults
.Select(t => t.State).GroupBy(t => t)
.ToDictionary(t => t.Key, t => t.Count());
_log.Info(string.Format("XUnit test results: Passed: {0}, Failed: {1}, Inconc: {2}",
count.GetOrDefault(TestNodeState.Success),
count.GetOrDefault(TestNodeState.Failure),
count.GetOrDefault(TestNodeState.Inconclusive)));
return new MutantTestResults(testResults);
}
}
catch (OperationCanceledException)
{
_log.Error("Test run cancelled.");
return new MutantTestResults(cancelled: true);
}
}
public async Task<MutantTestResults> RunTests(
string inputFile, string outputFile)
{
_log.Debug("Running tests on: " + inputFile);
try
{
ProcessResults results = await RunNUnitConsole(_nUnitConsolePath, inputFile, outputFile);
if (!_svc.FileSystem.File.Exists(outputFile))
{
throw new Exception("Test results in file: " + outputFile + " not found. Output: " +
results.StandardOutput.Aggregate((a, b) => a + "\n" + b));
}
else
{
Dictionary<string, MyTestResult> tresults = _parser.ProcessResultFile(outputFile);
IList<MyTestResult> testResults = tresults.Values.ToList();
var list = new List<TmpTestNodeMethod>();
foreach (var myTestResult in testResults)
{
TmpTestNodeMethod node = new TmpTestNodeMethod(myTestResult.Name);
node.State = myTestResult.Success ? TestNodeState.Success : TestNodeState.Failure;
node.Message = myTestResult.Message + "\n" + myTestResult.StackTrace;
list.Add(node);
}
return new MutantTestResults(list);
}
}
catch (OperationCanceledException)
{
_log.Error("Test run cancelled.");
return new MutantTestResults(cancelled: true);
}
}
