public void SuiteFinished(XmlNode resultNode)
{
var result = resultNode.GetAttribute("result");
var label = resultNode.GetAttribute("label");
var site = resultNode.GetAttribute("site");
if (result == "Failed")
{
if (site == "SetUp" || site == "TearDown")
{
testLog.SendMessage(
TestMessageLevel.Error,
string.Format("{0} failed for test fixture {1}", site, resultNode.GetAttribute("fullname")));
var messageNode = resultNode.SelectSingleNode("failure/message");
if (messageNode != null)
{
testLog.SendMessage(TestMessageLevel.Error, messageNode.InnerText);
}
var stackNode = resultNode.SelectSingleNode("failure/stack-trace");
if (stackNode != null)
{
testLog.SendMessage(TestMessageLevel.Error, stackNode.InnerText);
}
}
}
}
/// <summary>
/// Log the parameter warnings on the parameter logger
/// </summary>
/// <param name="testExecutionRecorder">Handle to record test start/end/results/messages.</param>
/// <param name="result">Result of the run operation.</param>
private void LogCleanupResult(ITestExecutionRecorder testExecutionRecorder, RunCleanupResult result)
{
Debug.Assert(testExecutionRecorder != null, "Logger should not be null");
if (!string.IsNullOrEmpty(result.StandardOut))
{
testExecutionRecorder.SendMessage(TestMessageLevel.Informational, result.StandardOut);
}
if (!string.IsNullOrEmpty(result.DebugTrace))
{
testExecutionRecorder.SendMessage(TestMessageLevel.Informational, result.DebugTrace);
}
if (!string.IsNullOrEmpty(result.StandardError))
{
testExecutionRecorder.SendMessage(
MSTestSettings.CurrentSettings.TreatClassAndAssemblyCleanupWarningsAsErrors ? TestMessageLevel.Error : TestMessageLevel.Warning,
result.StandardError);
}
if (result.Warnings != null)
{
foreach (string warning in result.Warnings)
{
testExecutionRecorder.SendMessage(
MSTestSettings.CurrentSettings.TreatClassAndAssemblyCleanupWarningsAsErrors ? TestMessageLevel.Error : TestMessageLevel.Warning,
warning);
}
}
}
public void OnTestEvent(string report)
{
var node = XmlHelper.CreateXmlNode(report);
try
{
switch (node.Name)
{
case "start-test":
TestStarted(node);
break;
case "test-case":
TestFinished(node);
break;
case "test-suite":
SuiteFinished(node);
break;
}
}
catch (Exception ex)
{
_recorder.SendMessage(TestMessageLevel.Error,
string.Format("Error processing {0} event for {1}", node.Name, node.GetAttribute("fullname")));
_recorder.SendMessage(TestMessageLevel.Error, ex.ToString());
}
}
public void OnTestEvent(string report)
{
var node = new NUnitTestEventHeader(report);
dumpXml?.AddTestEvent(node.AsString());
try
{
switch (node.Type)
{
case NUnitTestEventHeader.EventType.StartTest:
TestStarted(new NUnitTestEventStartTest(node));
break;
case NUnitTestEventHeader.EventType.TestCase:
TestFinished(new NUnitTestEventTestCase(node));
break;
case NUnitTestEventHeader.EventType.TestSuite:
SuiteFinished(new NUnitTestEventSuiteFinished(node));
break;
case NUnitTestEventHeader.EventType.TestOutput:
TestOutput(new NUnitTestEventTestOutput(node));
break;
}
}
catch (Exception ex)
{
_recorder.SendMessage(TestMessageLevel.Warning, $"Error processing {node.Name} event for {node.FullName}");
_recorder.SendMessage(TestMessageLevel.Warning, ex.ToString());
}
}
TestCase FindTestCase(ITestCase testCase)
{
TestCase result;
if (testCases.TryGetValue(testCase, out result))
{
return(result);
}
result = testCases.Where(tc => tc.Key.UniqueID == testCase.UniqueID).Select(kvp => kvp.Value).FirstOrDefault();
if (result != null)
{
return(result);
}
recorder.SendMessage(TestMessageLevel.Error, String.Format("Result reported for unknown test case: {0}", testCase.DisplayName));
return(null);
}
public void OnTestEvent(string report)
{
var node = XmlHelper.CreateXmlNode(report);
#if !NETCOREAPP1_0
dumpXml?.AddTestEvent(node.AsString());
#endif
try
{
switch (node.Name)
{
case "start-test":
TestStarted(node);
break;
case "test-case":
TestFinished(node);
break;
case "test-suite":
SuiteFinished(node);
break;
case "test-output":
TestOutput(node);
break;
}
}
catch (Exception ex)
{
_recorder.SendMessage(TestMessageLevel.Warning, $"Error processing {node.Name} event for {node.GetAttribute("fullname")}");
_recorder.SendMessage(TestMessageLevel.Warning, ex.ToString());
}
}
/// <summary>
/// Log the parameter warnings on the parameter logger
/// </summary>
/// <param name="testExecutionRecorder">Execution recorder.</param>
/// <param name="warnings">Warnings.</param>
private static void LogWarnings(ITestExecutionRecorder testExecutionRecorder, IEnumerable <string> warnings)
{
if (warnings == null)
{
return;
}
Debug.Assert(testExecutionRecorder != null, "Logger should not be null");
// log the warnings
foreach (string warning in warnings)
{
testExecutionRecorder.SendMessage(TestMessageLevel.Warning, warning);
}
}
private void CacheSessionParameters(IRunContext runContext, ITestExecutionRecorder testExecutionRecorder)
{
if (!string.IsNullOrEmpty(runContext?.RunSettings?.SettingsXml))
{
try
{
var testRunParameters = RunSettingsUtilities.GetTestRunParameters(runContext.RunSettings.SettingsXml);
if (testRunParameters != null)
{
foreach (var kvp in testRunParameters)
{
this.sessionParameters.Add(kvp);
}
}
}
catch (Exception ex)
{
testExecutionRecorder.SendMessage(TestMessageLevel.Error, ex.Message);
}
}
}
private void CacheSessionParameters(IRunContext runContext, ITestExecutionRecorder testExecutionRecorder)
{
if (!string.IsNullOrEmpty(runContext?.RunSettings?.SettingsXml))
{
try
{
var testRunParameters = RunSettingsUtilities.GetTestRunParameters(runContext.RunSettings.SettingsXml);
if (testRunParameters != null)
{
// Clear sessionParameters to prevent key collisions of test run parameters in case
// "Keep Test Execution Engine Alive" is selected in VS.
this.sessionParameters.Clear();
foreach (var kvp in testRunParameters)
{
this.sessionParameters.Add(kvp);
}
}
}
catch (Exception ex)
{
testExecutionRecorder.SendMessage(TestMessageLevel.Error, ex.Message);
}
}
}
protected override bool Visit(IErrorMessage error)
{
recorder.SendMessage(TestMessageLevel.Error, String.Format("Catastrophic failure: {0}", ExceptionUtility.CombineMessages(error)));
return(!cancelledThunk());
}
protected override bool Visit(IErrorMessage error)
{
recorder.SendMessage(TestMessageLevel.Error, String.Format("Catastrophic failure: {0}", error.Message));
return(!cancelledThunk());
}
public void RunStarted(string name, int testCount)
{
testLog.SendMessage(TestMessageLevel.Informational, "Run started: " + name);
}
void IMessageLogger.SendMessage(TestMessageLevel testMessageLevel, string message) => recorder?.SendMessage(testMessageLevel, message);
public bool ClassFailed(string className, string exceptionType, string message, string stackTrace)
{
recorder.SendMessage(TestMessageLevel.Error, String.Format("Fixture {0} failed: {1}: {2}\r\n{3}", className, exceptionType, message, stackTrace));
return(!cancelledThunk());
}
private static void ExecuteStandardTest(ITestExecutionRecorder recorder, TestCase test, MethodInfo method,
TestContext context, object instance)
{
try
{
recorder.SendMessage(TestMessageLevel.Informational, "Running standard test");
var accessor = CallAccessor.Create(method);
var occurrences = 0;
recorder.RecordResult(DutyCycle(accessor, ++occurrences));
while (!context.Skipped && context.RepeatCount > 0)
{
recorder.RecordResult(DutyCycle(accessor, ++occurrences));
context.RepeatCount--;
}
}
finally
{
context.Dispose();
}
TestResult DutyCycle(IMethodCallAccessor accessor, int occurrence)
{
if (occurrence > 1)
{
var clone = new TestCase
{
DisplayName = $"{test.DisplayName ?? "<No Name>"} #{occurrence}",
ExecutorUri = test.ExecutorUri,
FullyQualifiedName = test.FullyQualifiedName,
Id = test.Id,
LineNumber = test.LineNumber,
LocalExtensionData = test.LocalExtensionData,
CodeFilePath = test.CodeFilePath,
Source = test.Source
};
clone.Traits.AddRange(test.Traits);
test = clone;
}
TestResult testResult = null;
try
{
recorder.SendMessage(TestMessageLevel.Informational, "Starting test");
recorder.RecordStart(test);
context.BeginTest();
var result = ExecuteTestMethod(accessor, instance, context);
context.EndTest();
var outcome = context.Skipped ? TestOutcome.Skipped :
result ? TestOutcome.Passed : TestOutcome.Failed;
recorder.SendMessage(TestMessageLevel.Informational,
$"{test.DisplayName} => {outcome.ToString().ToLowerInvariant()}");
recorder.SendMessage(TestMessageLevel.Informational, "Ending test");
recorder.RecordEnd(test, outcome);
testResult = new TestResult(test)
{
Outcome = outcome
};
if (context.Skipped)
{
testResult.Messages.Add(new TestResultMessage(Constants.Categories.Skipped,
context.SkipReason));
}
var listener = Trace.Listeners.OfType <TestResultTraceListener>().SingleOrDefault();
if (listener != null)
{
testResult.Messages.Add(listener.ToMessage());
}
return(testResult);
}
catch (Exception ex)
{
recorder.SendMessage(TestMessageLevel.Error, ex.Message);
testResult ??= new TestResult(test);
testResult.Messages.Add(new TestResultMessage(Constants.Categories.Failed,
"Test failed because an exception prevented execution."));
testResult.Outcome = TestOutcome.Failed;
testResult.ErrorMessage = ex.Message;
testResult.ErrorStackTrace = ex.StackTrace;
return(testResult);
}
}
}
