private void TestResultHandler(object sender, TestResultEventArgs e)
{
string testName = e.Result.TestCase.DisplayName;
if (e.Result.Outcome == TestOutcome.Skipped)
{
WriteServiceMessage($"testIgnored name='{testName}'");
return;
}
WriteServiceMessage($"testStarted name='{testName}'");
foreach (var message in e.Result.Messages)
{
if (message.Category == TestResultMessage.StandardOutCategory)
{
WriteServiceMessage($"testStdOut name='{testName}'] out='{message.Text}'");
}
else if (message.Category == TestResultMessage.StandardErrorCategory)
{
WriteServiceMessage($"testStdErr name='{testName}'] out='{message.Text}'");
}
}
if (e.Result.Outcome == TestOutcome.Failed)
{
WriteServiceMessage($"testFailed name='{testName}' message='{e.Result.ErrorMessage}' details='{e.Result.ErrorStackTrace}'");
}
WriteServiceMessage($"testFinished name='{testName}' duration='{e.Result.Duration.TotalMilliseconds}'");
}
/// <summary>
/// Takes an exception and extracts relevant stack information for
/// reporting a test result.
/// </summary>
/// <param name="e">An exception that was thrown.</param>
/// <param name="trea">The TestResultEventArgs.</param>
internal static void ExtractLocation(Exception e, TestResultEventArgs trea)
{
if ((e as TargetInvocationException) != null &&
e.InnerException != null)
{
ExtractLocation(e.InnerException, trea);
}
else
{
trea.StackInfo = new List <StackFrameInfo>();
if (e.StackTrace != null)
{
// ReSharper disable PossibleNullReferenceException
foreach (var sf in (new StackTrace(e, true)).GetFrames())
{
// ReSharper restore PossibleNullReferenceException
// Search for first non-csUnit location [26mar07, ml]
var fullName = sf.GetMethod().DeclaringType.FullName;
if (fullName.StartsWith("csUnit") &&
!fullName.Contains(".Tests."))
{
continue;
}
trea.StackInfo.Add(new StackFrameInfo(sf));
}
}
}
}
/// <summary>
/// Reports an exception.
/// </summary>
/// <param name="ex">The exception</param>
/// <param name="fixtureName">Name of the fixture.</param>
/// <param name="testMethodName">Name of the test method.</param>
private void ReportException(Exception ex, String fixtureName, String testMethodName)
{
var realException = ex;
if (realException is TargetInvocationException)
{
realException = realException.InnerException;
}
var trea = new TestResultEventArgs(AssemblyName, fixtureName, testMethodName,
realException.ToString(), 0)
{
AssertCount = _framework.AssertionCount
};
Util.ExtractLocation(realException, trea);
if (realException.GetType() == typeof(TestFailed))
{
_testListener.OnTestFailed(new TestFixtureInfo(this), trea);
}
else if (realException is ThreadAbortException)
{
throw realException;
}
else
{
_testListener.OnTestError(new TestFixtureInfo(this), trea);
}
}
private static void IncludeMessages(TestResultEventArgs e, TestCase testCase)
{
foreach (TestResultMessage msg in e.Result.Messages)
{
if (msg.Category == "StdOutMsgs")
{
if (testCase.SystemOut == null)
{
testCase.SystemOut = string.Empty;
}
testCase.SystemOut += msg.Text + Environment.NewLine;
}
else if (msg.Category == "StdErrMsgs")
{
if (testCase.SystemErr == null)
{
testCase.SystemErr = string.Empty;
}
testCase.SystemErr += msg.Text + Environment.NewLine;
}
else
{
testCase.SystemOut += msg.Category + ": " + msg.Text + Environment.NewLine;
}
}
}
/// <inheritdoc />
public void RaiseTestResult(TestResultEventArgs e)
{
var allowTestResultFlush = true;
var testCaseId = e.TestResult.TestCase.Id;
lock (this.testCaseEndStatusSyncObject)
{
if (this.testCaseEndStatusMap.Contains(testCaseId))
{
this.TestResult.SafeInvoke(this, e, "DataCollectionTestCaseEventManager.RaiseTestCaseEnd");
}
else
{
// No TestCaseEnd received yet
// We need to wait for testcaseend before flushing
allowTestResultFlush = false;
List <TestResult> testResults;
// Cache results so we can flush later with in proc data
if (this.testResultDictionary.TryGetValue(testCaseId, out testResults))
{
testResults.Add(e.TestResult);
}
else
{
this.testResultDictionary.Add(testCaseId, new List <TestResult>()
{
e.TestResult
});
}
}
}
this.SetAllowTestResultFlushInTestResult(e.TestResult, allowTestResultFlush);
}
private void OnRunFinished(TestResultEventArgs ea)
{
_view.OnRunFinished(ea.Result.Duration);
var summary = ResultSummaryCreator.FromResultNode(ea.Result);
_view.OnTestRunSummaryCompiled(ResultSummaryReporter.WriteSummaryReport(summary));
}
public void RaiseTestResultShouldInvokeRegisteredEventHandlerIfTestResultEventArgsIsPassed()
{
EventWaitHandle waitHandle = new AutoResetEvent(false);
bool testResultReceived = false;
TestResultEventArgs eventArgs = null;
var result = new TestResult(new TestCase("This is a string.", new Uri("some://uri"), "DummySourceFileName"));
// Register for the test result event.
loggerEvents.TestResult += (sender, e) =>
{
testResultReceived = true;
eventArgs = e;
waitHandle.Set();
};
loggerEvents.EnableEvents();
// Send the test result event.
loggerEvents.RaiseTestResult(new TestResultEventArgs(result));
var waitSuccess = waitHandle.WaitOne(500);
Assert.IsTrue(waitSuccess, "Event must be raised within timeout.");
Assert.IsTrue(testResultReceived);
Assert.IsNotNull(eventArgs);
Assert.AreEqual(result, eventArgs.Result);
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
ValidateArg.NotNull <object>(sender, "sender");
ValidateArg.NotNull <TestResultEventArgs>(e, "e");
// Update the test count statistics based on the result of the test.
this.testsTotal++;
string name = null;
name = !string.IsNullOrEmpty(e.Result.DisplayName) ? e.Result.DisplayName : e.Result.TestCase.FullyQualifiedName;
if (e.Result.Outcome == TestOutcome.Skipped)
{
this.testsSkipped++;
string output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.SkippedTestIndicator, name);
Output.WriteLine(output, OutputLevel.Information);
DisplayFullInformation(e.Result);
}
else if (e.Result.Outcome == TestOutcome.Failed)
{
this.testOutcome = TestOutcome.Failed;
this.testsFailed++;
string output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.FailedTestIndicator, name);
Output.WriteLine(output, OutputLevel.Information);
DisplayFullInformation(e.Result);
}
else if (e.Result.Outcome == TestOutcome.Passed)
{
string output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.PassedTestIndicator, name);
Output.WriteLine(output, OutputLevel.Information);
this.testsPassed++;
}
}
private void OnTestFailedAsync(object sender, TestResultEventArgs args)
{
lock (this) {
var assemblyNode = FindAssemblyNode(sender as ITestAssembly);
var node = FindTestMethodNode(assemblyNode.Nodes,
args.ClassName + "." + args.MethodName)
??
FindTestFixtureNode(assemblyNode.Nodes, args.ClassName);
if (args.StackInfo != null)
{
AddCallStack(node, args.StackInfo);
}
if (args.Failure != null)
{
if (args.Failure.HasTip)
{
AddCommentNode(node, "Tip: " + args.Failure.Tip);
}
AddCommentNode(node, "Actual: " + args.Failure.Actual);
AddCommentNode(node, "Expected: " + args.Failure.Expected);
AddCommentNode(node, args.Failure.Message);
}
else
{
AddCommentNode(node, "Failure: " + args.Reason);
}
SetNodeStatus(node, 15);
_failureNodes.Add(node);
node.Expand();
}
}
private void TestResultHandler(
Object sender,
TestResultEventArgs e)
{
String assembly = Path.GetFileName(e.Result.TestCase.Source);
if (assembly != currentAssembly)
{
if (currentAssembly != null)
{
Console.WriteLine("[TestAssemblyCompleted] name=\"{0}\"", currentAssembly);
}
currentAssembly = assembly;
Console.WriteLine("[TestAssemblyStarted] name=\"{0}\"", currentAssembly);
}
Console.WriteLine("[TestCaseStarted] name=\"{0}\" startTime=\"{1:O}\"",
e.Result.TestCase.FullyQualifiedName, e.Result.StartTime.DateTime.ToUniversalTime());
String result = "Succeeded";
if (e.Result.Outcome == TestOutcome.Failed)
{
result = "Failed";
}
else if (e.Result.Outcome == TestOutcome.Skipped)
{
result = "Skipped";
}
Console.WriteLine("[TestCaseCompleted] name=\"{0}\" endTime=\"{1:O}\" result=\"{2}\"",
e.Result.TestCase.FullyQualifiedName, e.Result.EndTime.DateTime.ToUniversalTime(), result);
}
private static void IncludeErrorsAndFailures(TestResultEventArgs e, TestCase testCase)
{
var errorMessage = e.Result.ErrorMessage ?? string.Empty;
var errorStackTrace = e.Result.ErrorStackTrace ?? string.Empty;
if (string.IsNullOrWhiteSpace(errorMessage) && string.IsNullOrWhiteSpace(errorStackTrace))
{
return;
}
var err = new List <ErrorOrFailure>
{
new ErrorOrFailure
{
Message = new string(errorMessage.Select(ch => XmlConvert.IsXmlChar(ch) ? ch : '?').ToArray()),
Text = new string(errorStackTrace.Select(ch => XmlConvert.IsXmlChar(ch) ? ch : '?').ToArray())
}
};
if (e.Result.Outcome == TestOutcome.Failed)
{
testCase.Failures = err;
}
else
{
testCase.Errors = err;
}
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
if (e.Result.Outcome == TestOutcome.NotFound)
{
return;
}
DataType.TestCaseDetail caseDetail = ConvertToTestCase(e.Result);
results.TryAdd(caseDetail.Name, caseDetail);
// Generate txt log file
string txtFileName = Path.Combine(
txtResultFolderPath,
string.Format("{0}_{1}_{2}.txt",
caseDetail.StartTime.ToLocalTime().ToString("yyyy-MM-dd-HH-mm-ss"),
caseDetail.Result,
caseDetail.Name)
);
File.WriteAllText(txtFileName, ConstructCaseTxtReport(caseDetail));
// Generate html log file
string htmlFileName = Path.Combine(htmlResultFolderPath, $"{caseDetail.Name}.html");
File.WriteAllText(htmlFileName, ConstructCaseHtml(caseDetail));
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
machineName = e.Result.ComputerName;
var testCase = new TestCase
{
Name = e.Result.TestCase.DisplayName,
Classname = GetClassName(e.Result.TestCase.FullyQualifiedName),
Status = e.Result.Outcome.ToString(),
Time = e.Result.Duration.TotalSeconds,
};
if (e.Result.Outcome == TestOutcome.Skipped)
{
var methodInfo = this.GetTestMethodInfo(e.Result);
var description = this.GetDescription(methodInfo);
testCase.Skipped = new Skipped
{
Text = "Yes",
Message = description ?? "---EMPTY---"
};
}
IncludeErrorsAndFailures(e, testCase);
this.PrintSourceCodeInformation(e, testCase);
IncludeMessages(e, testCase);
testCases.Enqueue(testCase);
}
private void OnTestErrorAsync(object sender, TestResultEventArgs args)
{
lock (this) {
SmartTreeNode assemblyNode = FindAssemblyNode(sender as ITestAssembly);
SmartTreeNode node = FindTestMethodNode(assemblyNode.Nodes, args.ClassName + "." + args.MethodName);
if (node == null)
{
node = FindTestFixtureNode(assemblyNode.Nodes, args.ClassName);
}
AddCommentNode(ref node, string.Format("File {0}, Line {1}",
args.FileName.Substring(args.FileName.LastIndexOf("\\") + 1),
args.LineNumber));
SmartTreeNode commentNode = AddCommentNode(ref node, "Error: " + args.Reason);
SetNodeError(ref node, Constants.ColorError);
if (_config.ExpandCommentNodes)
{
commentNode.ExpandAll();
commentNode.LastNode.EnsureVisible();
}
else
{
node.EnsureVisible();
}
}
}
private void OnTestPassedAsync(object sender, TestResultEventArgs args)
{
lock (this) {
SmartTreeNode assemblyNode = FindAssemblyNode(sender as ITestAssembly);
SmartTreeNode node = FindTestMethodNode(assemblyNode.Nodes, args.ClassName + "." + args.MethodName);
SetNodeSuccess(ref node);
if (node.IsVisible)
{
node.EnsureVisible();
}
else
{
SmartTreeNode parent = node.Parent;
while (parent != null)
{
if (parent.IsVisible)
{
parent.EnsureVisible();
break;
}
else
{
parent = parent.Parent;
}
}
}
}
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
try
{
var currentAssembly = Path.GetFileName(e.Result.TestCase.Source);
if (_currentAssembly != currentAssembly)
{
if (!string.IsNullOrEmpty(_currentAssembly))
_currentAssemblySuite.Dispose();
_currentAssembly = currentAssembly;
_currentAssemblySuite = _vsTestSuite.OpenTestSuite(_currentAssembly);
}
using (var currentTest = _currentAssemblySuite.OpenTest(e.Result.TestCase.FullyQualifiedName))
{
if (e.Result.Outcome == TestOutcome.Skipped)
{
currentTest.WriteIgnored(e.Result.ErrorMessage);
}
else if (e.Result.Outcome == TestOutcome.Failed)
{
currentTest.WriteFailed(e.Result.ErrorMessage, e.Result.ErrorStackTrace);
}
currentTest.WriteDuration(e.Result.Duration);
}
}
catch (Exception ex)
{
_teamCityWriter.WriteError("TeamCity Logger Error", ex.ToString());
}
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
try
{
var currentAssembly = Path.GetFileName(e.Result.TestCase.Source);
if (_currentAssembly != currentAssembly)
{
if (!string.IsNullOrEmpty(_currentAssembly))
{
_currentAssemblySuite.Dispose();
}
_currentAssembly = currentAssembly;
_currentAssemblySuite = _vsTestSuite.OpenTestSuite(_currentAssembly);
}
using (var currentTest = _currentAssemblySuite.OpenTest(e.Result.TestCase.FullyQualifiedName))
{
if (e.Result.Outcome == TestOutcome.Skipped)
{
currentTest.WriteIgnored(e.Result.ErrorMessage);
}
else if (e.Result.Outcome == TestOutcome.Failed)
{
currentTest.WriteFailed(e.Result.ErrorMessage, e.Result.ErrorStackTrace);
}
currentTest.WriteDuration(e.Result.Duration);
}
}
catch (Exception ex)
{
_teamCityWriter.WriteError("TeamCity Logger Error", ex.ToString());
}
}
private void ReportError(ITestListener listener, string errorReason)
{
var trea = new TestResultEventArgs(AssemblyName,
Fixture.FullName, Name, errorReason, 0);
listener.OnTestError(new TestMethodInfo(this), trea);
}
public void TestResultHandler(object sender, TestResultEventArgs e)
{
var testCase = e.Result.TestCase;
var skipSkips = _disableSkipNamespaces.Any(n => testCase.FullyQualifiedName.StartsWith(n));
var takingTooLong = e.Result.Duration > TimeSpan.FromSeconds(2);
switch (e.Result.Outcome)
{
//case TestOutcome.Passed when !takingTooLong && !(isExamples || isReproduce): break;
case TestOutcome.Skipped when skipSkips: break;
case TestOutcome.Passed when !takingTooLong:
Console.BackgroundColor = DefaultBg;
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(".");
Console.ResetColor();
_writtenPassed++;
if (_writtenPassed > Console.WindowWidth / 2)
{
Console.WriteLine();
_writtenPassed = 0;
}
break;
default:
WriteTestResult(e.Result);
break;
}
}
private void FireAndForget(Delegate handler, TestResultEventArgs args)
{
foreach (TestEventHandler teh in handler.GetInvocationList())
{
teh.BeginInvoke(_loader, args, TestEventHandlerAsyncCallback, teh);
}
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
content += "\n" + e.Result.StartTime + " " + e.Result.Outcome;
string name = !string.IsNullOrEmpty(e.Result.DisplayName) ? e.Result.DisplayName : e.Result.TestCase.FullyQualifiedName;
if (e.Result.Outcome == TestOutcome.Skipped)
{
Console.WriteLine(name + " Skipped");
}
else if (e.Result.Outcome == TestOutcome.Failed)
{
Console.WriteLine(name + " Failed");
if (!String.IsNullOrEmpty(e.Result.ErrorStackTrace))
{
Console.WriteLine(e.Result.ErrorStackTrace);
}
}
else if (e.Result.Outcome == TestOutcome.Passed)
{
Console.WriteLine(name + " Passed");
}
SendMessage(0, name + " " + e.Result.ComputerName + " - " + e.Result.ToString());
File.AppendAllText("test.test", e.Result.ToString());
testResults.Add(e.Result);
}
/// <summary>
/// Called when a test result is received.
/// </summary>
internal void TestResultHandler(object sender, TestResultEventArgs e)
{
TestResult result = e.Result;
var displayName = string.IsNullOrEmpty(result.DisplayName) ? result.TestCase.DisplayName : result.DisplayName;
if (TryParseName(result.TestCase.FullyQualifiedName, out var typeName, out var methodName, out _))
{
lock (resultsGuard)
{
results.Add(new TestResultInfo(
result.TestCase,
result.Outcome,
result.TestCase.Source,
typeName,
methodName,
displayName,
result.Duration,
result.ErrorMessage,
result.ErrorStackTrace,
result.Messages,
result.TestCase.Traits));
}
}
}
public void OnTestSkipped(object sender, TestResultEventArgs args)
{
_ignoredItems.Add(string.Format("{0}#{1}#{2}#{3}#",
args.AssemblyName,
args.ClassName,
args.MethodName,
args.Reason));
}
private void TestResultHandler(object sender, TestResultEventArgs e)
{
if (e.Result.Outcome == TestOutcome.Passed ||
e.Result.Outcome == TestOutcome.Failed)
{
_testResults.Add(new ExercismTestResult(e.Result.DisplayName, e.Result.ErrorMessage));
}
}
public void OnTestFailed(object sender, TestResultEventArgs args)
{
_messages += " TF:" + args.MethodName + " " + args.Reason;
_failureItems.Add(string.Format("{0}#{1}#{2}#",
args.AssemblyName,
args.ClassName,
args.MethodName));
}
public void SendTestResult(TestResultEventArgs ev)
{
if (ev == null)
{
throw new ArgumentNullException(nameof(ev));
}
TestResult?.Invoke(this, ev);
}
public void OnTestPassed(object sender, TestResultEventArgs args)
{
_messages += " TP:" + args.MethodName;
_passedItems.Add(string.Format("{0}#{1}#{2}#",
args.AssemblyName,
args.ClassName,
args.MethodName));
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
ValidateArg.NotNull <object>(sender, "sender");
ValidateArg.NotNull <TestResultEventArgs>(e, "e");
// Update the test count statistics based on the result of the test.
this.testsTotal++;
string name = null;
name = !string.IsNullOrEmpty(e.Result.DisplayName) ? e.Result.DisplayName : e.Result.TestCase.DisplayName;
if (e.Result.Outcome == TestOutcome.Skipped)
{
this.testsSkipped++;
if (!this.verbosityLevel.Equals(Verbosity.Quiet))
{
var output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.SkippedTestIndicator,
name);
Output.Warning(false, output);
DisplayFullInformation(e.Result);
}
}
else if (e.Result.Outcome == TestOutcome.Failed)
{
this.testOutcome = TestOutcome.Failed;
this.testsFailed++;
if (!this.verbosityLevel.Equals(Verbosity.Quiet))
{
var output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.FailedTestIndicator,
name);
Output.Information(false, ConsoleColor.Red, output);
DisplayFullInformation(e.Result);
}
}
else if (e.Result.Outcome == TestOutcome.Passed)
{
if (this.verbosityLevel.Equals(Verbosity.Normal))
{
var output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.PassedTestIndicator, name);
Output.Information(false, output);
DisplayFullInformation(e.Result);
}
this.testsPassed++;
}
else
{
if (!this.verbosityLevel.Equals(Verbosity.Quiet))
{
var output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.NotRunTestIndicator,
name);
Output.Information(false, output);
DisplayFullInformation(e.Result);
}
}
}
public void OnTestFailed(object sender, TestResultEventArgs args)
{
lock (this) {
if (_loader.TestFailed != null)
{
FireAndForget(_loader.TestFailed, args);
}
CheckAbortThread();
}
}
private static ulong?GetTestCaseId(TestResultEventArgs args)
{
var trait = args.Result.TestCase.Traits.FirstOrDefault(t => t.Name == TestCaseId);
if (trait == null)
{
return(null);
}
return(ulong.Parse(trait.Value));
}
private void StopTimer(TestResultEventArgs trea)
{
_timer.Stop();
trea.Duration = ((ulong)_timer.ElapsedTicks) * _nanosecsPerTick;
trea.AssertCount = _framework.AssertionCount;
if (_bExpectedExceptionThrown)
{
trea.AssertCount++;
}
}
private void OnTestFinished(TestResultEventArgs ea)
{
var result = ea.Result.Outcome;
switch (result.Status)
{
case TestStatus.Passed:
_view.OnTestPassed();
break;
case TestStatus.Failed:
_view.OnTestFailed();
break;
case TestStatus.Warning:
_view.OnTestWarning();
break;
case TestStatus.Inconclusive:
_view.OnTestInconclusive();
break;
}
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
string name = !string.IsNullOrEmpty(e.Result.DisplayName) ? e.Result.DisplayName : e.Result.TestCase.FullyQualifiedName;
Console.WriteLine("##teamcity[testStarted name='{0}']", name);
if (e.Result.Outcome == TestOutcome.Skipped)
{
Console.WriteLine("##teamcity[testIgnored name='{0}' message='Skipped: {1}']", name, e.Result.ErrorMessage.Replace("\r\n", " "));
}
else if (e.Result.Outcome == TestOutcome.Failed)
{
Console.WriteLine("##teamcity[testFailed name='{0}' message='{1}']", name, e.Result.ErrorMessage.Replace("\r\n", " "));
}
else if (e.Result.Outcome == TestOutcome.Passed)
{
//// do nothing
}
Console.WriteLine("##teamcity[testFinished name='{0}' duration='{1}']", name, ((long)e.Result.Duration.TotalMilliseconds).ToString(CultureInfo.InvariantCulture));
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
try
{
var currentAssembly = Path.GetFileName(e.Result.TestCase.Source);
if (_currentAssembly != currentAssembly)
{
if (!string.IsNullOrEmpty(_currentAssembly))
Console.WriteLine("##teamcity[testSuiteFinished name='{0}']", _currentAssembly);
_currentAssembly = currentAssembly;
Console.WriteLine("##teamcity[testSuiteStarted name='{0}']", currentAssembly);
}
string name = e.Result.TestCase.FullyQualifiedName;
Console.WriteLine("##teamcity[testStarted name='{0}' captureStandardOutput='true']", name);
if (e.Result.Outcome == TestOutcome.Skipped)
{
Console.WriteLine("##teamcity[testIgnored name='{0}' message='{1}']", name, FormatForTeamCity(e.Result.ErrorMessage));
}
else if (e.Result.Outcome == TestOutcome.Failed)
{
var errorStackTrace = FormatForTeamCity(e.Result.ErrorStackTrace);
Console.WriteLine("##teamcity[testFailed name='{0}' message='{1}' details='{2}']", name, FormatForTeamCity(e.Result.ErrorMessage), errorStackTrace);
}
else if (e.Result.Outcome == TestOutcome.Passed)
{
}
Console.WriteLine("##teamcity[testFinished name='{0}' duration='{1}']", name, e.Result.Duration.TotalMilliseconds);
}
catch (Exception ex)
{
Console.WriteLine("##teamcity[message text='TeamCity Logger Error' errorDetails='{0}' status='ERROR']", FormatForTeamCity(ex.ToString()));
}
}
private static void IncludeErrorsAndFailures(TestResultEventArgs e, TestCase testCase)
{
if (!string.IsNullOrWhiteSpace(e.Result.ErrorMessage) ||
!string.IsNullOrWhiteSpace(e.Result.ErrorStackTrace))
{
var err = new List<ErrorOrFailure>
{
new ErrorOrFailure
{
Message = new string(e.Result.ErrorMessage.Select(ch => XmlConvert.IsXmlChar(ch) ? ch : '?').ToArray()),
Text = new string(e.Result.ErrorStackTrace.Select(ch => XmlConvert.IsXmlChar(ch) ? ch : '?').ToArray())
}
};
if (e.Result.Outcome == TestOutcome.Failed)
{
testCase.Failures = err;
}
else
{
testCase.Errors = err;
}
}
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
if (e.Result.Outcome.ToString() == "NotFound")
{
return;
}
string caseName = !string.IsNullOrEmpty(e.Result.DisplayName) ? e.Result.DisplayName : e.Result.TestCase.FullyQualifiedName;
int dot = caseName.LastIndexOf('.');
if (-1 != dot)
caseName = caseName.Substring(dot + 1);
string txtFileName = Path.Combine(txtResultFolderPath, e.Result.StartTime.ToLocalTime().ToString("yyyy-MM-dd-HH-mm-ss") + "_"
+ (e.Result.Outcome == TestOutcome.Skipped ? "Inconclusive" : e.Result.Outcome.ToString()) + "_" + caseName + ".txt");
StringBuilder sb = new StringBuilder();
if (DateTimeOffset.Compare(testRunStartTime, e.Result.StartTime.ToLocalTime()) > 0)
testRunStartTime = e.Result.StartTime.ToLocalTime();
if (DateTimeOffset.Compare(testRunEndTime, e.Result.EndTime.ToLocalTime()) < 0)
testRunEndTime = e.Result.EndTime.ToLocalTime();
try
{
sb.AppendLine(caseName);
sb.AppendLine("Start Time: " + e.Result.StartTime.ToLocalTime().ToString("MM/dd/yyyy HH:mm:ss"));
sb.AppendLine("End Time: " + e.Result.EndTime.ToLocalTime().ToString("MM/dd/yyyy HH:mm:ss"));
sb.AppendLine("Result: " + (e.Result.Outcome == TestOutcome.Skipped ? "Inconclusive" : e.Result.Outcome.ToString()));
sb.AppendLine(e.Result.TestCase.Source);
if (!String.IsNullOrEmpty(e.Result.ErrorStackTrace))
{
sb.AppendLine("===========ErrorStackTrace===========");
sb.AppendLine(e.Result.ErrorStackTrace);
}
if (!String.IsNullOrEmpty(e.Result.ErrorMessage))
{
sb.AppendLine("===========ErrorMessage==============");
sb.AppendLine(e.Result.ErrorMessage);
}
foreach (TestResultMessage m in e.Result.Messages)
{
if (m.Category == TestResultMessage.StandardOutCategory && !String.IsNullOrEmpty(m.Text))
{
sb.AppendLine("===========StandardOut===============");
sb.AppendLine(m.Text);
}
}
}
catch (Exception ex)
{
sb.AppendLine("Exception: " + ex.Message);
}
finally
{
// Generate txt log file
File.WriteAllText(txtFileName, sb.ToString());
// Generate html log file
string htmlFileName = Path.Combine(htmlResultFolderPath, caseName + ".html");
File.WriteAllText(htmlFileName, ConstructCaseHtml(txtFileName, caseName));
}
}
private static void IncludeMessages(TestResultEventArgs e, TestCase testCase)
{
foreach (TestResultMessage msg in e.Result.Messages)
{
if (msg.Category == "StdOutMsgs")
{
if (testCase.SystemOut == null) testCase.SystemOut = string.Empty;
testCase.SystemOut += msg.Text + Environment.NewLine;
}
else if (msg.Category == "StdErrMsgs")
{
if (testCase.SystemErr == null) testCase.SystemErr = string.Empty;
testCase.SystemErr += msg.Text + Environment.NewLine;
}
else
{
testCase.SystemOut += msg.Category + ": " + msg.Text + Environment.NewLine;
}
}
}
private void OnRunFinished(TestResultEventArgs ea)
{
_view.OnRunFinished(ea.Result.Duration);
}
public override void OnTestFailed(object sender, TestResultEventArgs args) {
_failureMessage = args.Reason;
}
private void PrintSourceCodeInformation(TestResultEventArgs e, TestCase testCase)
{
if (startupParameters.ContainsKey("IncludeSourceFileInfo") &&
Convert.ToBoolean(startupParameters["IncludeSourceFileInfo"]))
{
var systemOut = new StringBuilder();
systemOut.AppendLine("------------- Source code information -------------");
systemOut.AppendLine("Source: " + e.Result.TestCase.GetPropertyValue(TestCaseProperties.Source, "N/A"));
systemOut.AppendLine("Code file path: " +
e.Result.TestCase.GetPropertyValue(TestCaseProperties.CodeFilePath, "N/A"));
systemOut.AppendLine("Line number: " +
e.Result.TestCase.GetPropertyValue(TestCaseProperties.LineNumber, "N/A"));
systemOut.AppendLine("Started: " + e.Result.GetPropertyValue(TestResultProperties.StartTime, "N/A"));
systemOut.AppendLine("Finished: " + e.Result.GetPropertyValue(TestResultProperties.EndTime, "N/A"));
testCase.SystemOut = systemOut.ToString();
if (e.Result.Messages.Any(m => m.Category == "StdOutMsgs"))
{
systemOut.AppendLine("------------- Stdout -------------");
}
}
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
machineName = e.Result.ComputerName;
var testCase = new TestCase
{
Name = e.Result.TestCase.DisplayName,
Classname = GetClassName(e.Result.TestCase.FullyQualifiedName),
Status = e.Result.Outcome.ToString(),
Time = e.Result.Duration.TotalSeconds,
Skipped = (e.Result.Outcome == TestOutcome.Skipped).ToString()
};
IncludeErrorsAndFailures(e, testCase);
PrintSourceCodeInformation(e, testCase);
IncludeMessages(e, testCase);
testCases.Enqueue(testCase);
}
private void OnTestFinished(TestResultEventArgs ea)
{
var result = ea.Result.Outcome;
if (result.Status == TestStatus.Passed)
_view.RecordSuccess();
else if (result == ResultState.Failure)
_view.RecordFailure();
else if (result.Status == TestStatus.Failed)
_view.RecordError();
}
public void FireTestResult(TestResultEventArgs e)
{
Debug.Assert(TestResult != null, "TestResult != null");
Debug.Assert(e != null, "e != null");
TestResult(this, e);
}
