protected override bool Visit(IErrorMessage error)
{
Log.LogError("{0}", Escape(ExceptionUtility.CombineMessages(error)));
Log.LogError("{0}", ExceptionUtility.CombineStackTraces(error));
return(base.Visit(error));
}
protected override bool Visit(IErrorMessage error)
{
Console.Error.WriteLine("{0}: {1}", error.ExceptionTypes[0], Escape(ExceptionUtility.CombineMessages(error)));
Console.Error.WriteLine(ExceptionUtility.CombineStackTraces(error));
return(base.Visit(error));
}
/// <summary>
/// Called when <see cref="_TestFailed"/> is raised.
/// </summary>
/// <param name="args">An object that contains the event data.</param>
protected virtual void HandleTestFailed(MessageHandlerArgs <_TestFailed> args)
{
Guard.ArgumentNotNull(nameof(args), args);
var testFailed = args.Message;
var frameInfo = StackFrameInfo.FromErrorMetadata(testFailed);
var metadata = MetadataCache.TryGetTestMetadata(testFailed);
lock (Logger.LockObject)
{
if (metadata != null)
{
Logger.LogError(frameInfo, $" {Escape(metadata.TestDisplayName)} [FAIL]");
}
else
{
Logger.LogError(frameInfo, " <unknown test> [FAIL]");
}
foreach (var messageLine in ExceptionUtility.CombineMessages(testFailed).Split(new[] { Environment.NewLine }, StringSplitOptions.None))
{
Logger.LogImportantMessage(frameInfo, $" {messageLine}");
}
LogStackTrace(frameInfo, ExceptionUtility.CombineStackTraces(testFailed));
LogOutput(frameInfo, testFailed.Output);
}
}
protected void WriteError(string failureName, IFailureInformation failureInfo)
{
_log.WriteLine($" [{failureName}] {XmlEscape(failureInfo.ExceptionTypes[0])}");
_log.WriteLine($" {XmlEscape(ExceptionUtility.CombineMessages(failureInfo))}");
WriteStackTrace(ExceptionUtility.CombineStackTraces(failureInfo));
}
// Helpers
void LogError(string messageType, _IErrorMetadata errorMetadata)
{
var message = $"[{messageType}] {errorMetadata.ExceptionTypes[0]}: {ExceptionUtility.CombineMessages(errorMetadata)}";
var stack = ExceptionUtility.CombineStackTraces(errorMetadata);
logger.LogImportantMessage($"##teamcity[message text='{Escape(message)}' errorDetails='{Escape(stack)}' status='ERROR']");
}
// Helpers
void LogError(string messageType, IFailureInformation failureInfo)
{
var message = $"[{messageType}] {failureInfo.ExceptionTypes[0]}: {ExceptionUtility.CombineMessages(failureInfo)}";
var stack = ExceptionUtility.CombineStackTraces(failureInfo);
logger.LogImportantMessage($"##teamcity[message text='{Escape(message)}' errorDetails='{Escape(stack)}' status='ERROR']");
}
void WriteError(string messageType, IFailureInformation failureInfo)
{
var message = $"[{messageType}] {failureInfo.ExceptionTypes[0]}: {ExceptionUtility.CombineMessages(failureInfo)}";
var stack = ExceptionUtility.CombineStackTraces(failureInfo);
Log.LogMessage(MessageImportance.High, "##teamcity[message text='{0}' errorDetails='{1}' status='ERROR']", TeamCityEscape(message), TeamCityEscape(stack));
}
protected override bool Visit(IErrorMessage error)
{
ExecutionSummary.Errors++;
logger.LogError("Catastrophic failure: {0}", ExceptionUtility.CombineMessages(error));
return(!cancelledThunk());
}
void HandleErrorMessage(MessageHandlerArgs <IErrorMessage> args)
{
ExecutionSummary.Errors++;
logger.LogError("Catastrophic failure: {0}", ExceptionUtility.CombineMessages(args.Message));
HandleCancellation(args);
}
protected override bool Visit(ITestFailed testFailed)
{
AppVeyorUpdateTest(GetFinishedTestName(testFailed.Test.DisplayName), "xUnit", assemblyFileName, "Failed",
Convert.ToInt64(testFailed.ExecutionTime * 1000), ExceptionUtility.CombineMessages(testFailed),
ExceptionUtility.CombineStackTraces(testFailed), testFailed.Output, null);
return(base.Visit(testFailed));
}
protected override bool Visit(ITestFailed testFailed)
{
_log.WriteLine($" {XmlEscape(testFailed.Test.DisplayName)} [FAIL]");
_log.WriteLine($" {ExceptionUtility.CombineMessages(testFailed).Replace(Environment.NewLine, Environment.NewLine + " ")}");
WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));
return(base.Visit(testFailed));
}
protected override void HandleTestFailed(MessageHandlerArgs <ITestFailed> args)
{
var testFailed = args.Message;
AppVeyorUpdateTest(GetFinishedTestName(testFailed.Test.DisplayName), "xUnit", assemblyFileName, "Failed",
Convert.ToInt64(testFailed.ExecutionTime * 1000), ExceptionUtility.CombineMessages(testFailed),
ExceptionUtility.CombineStackTraces(testFailed), testFailed.Output);
base.HandleTestFailed(args);
}
public void NonXunitException()
{
var failureInfo = new FailureInformation {
new Exception("This is the message")
};
var result = ExceptionUtility.CombineMessages(failureInfo);
Assert.Equal("System.Exception : This is the message", result);
}
protected override void HandleTestFailed(MessageHandlerArgs <ITestFailed> args)
{
var testFailed = args.Message;
VstsUpdateTest(args.Message.Test, "Failed",
Convert.ToInt64(testFailed.ExecutionTime * 1000), ExceptionUtility.CombineMessages(testFailed),
ExceptionUtility.CombineStackTraces(testFailed), testFailed.Output);
base.HandleTestFailed(args);
}
public void NonXunitException()
{
var errorMetadata = new ErrorMetadata {
new Exception("This is the message")
};
var result = ExceptionUtility.CombineMessages(errorMetadata);
Assert.Equal("System.Exception : This is the message", result);
}
protected override bool Visit(ITestFailed testFailed)
{
Console.WriteLine("##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
TeamCityEscape(testFailed.TestDisplayName),
TeamCityEscape(ExceptionUtility.CombineMessages(testFailed)),
TeamCityEscape(ExceptionUtility.CombineStackTraces(testFailed)),
ToFlowId(testFailed.TestCollection.DisplayName));
LogFinish(testFailed);
return(base.Visit(testFailed));
}
protected override bool Visit(ITestFailed testFailed)
{
Log.LogMessage(MessageImportance.High, "##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
TeamCityEscape(displayNameFormatter.DisplayName(testFailed.Test)),
TeamCityEscape(ExceptionUtility.CombineMessages(testFailed)),
TeamCityEscape(ExceptionUtility.CombineStackTraces(testFailed)),
ToFlowId(testFailed.TestCollection.DisplayName));
LogFinish(testFailed);
return(base.Visit(testFailed));
}
protected void WriteError(string failureName, IFailureInformation failureInfo)
{
lock (consoleLock)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine(" [{0}] {1}", failureName, XmlEscape(failureInfo.ExceptionTypes[0]));
Console.ForegroundColor = ConsoleColor.Gray;
Console.Error.WriteLine(" {0}", XmlEscape(ExceptionUtility.CombineMessages(failureInfo)));
WriteStackTrace(ExceptionUtility.CombineStackTraces(failureInfo));
}
}
protected override bool Visit(ITestFailed testFailed)
{
var result = MakeVsTestResult(TestOutcome.Failed, testFailed);
result.ErrorMessage = ExceptionUtility.CombineMessages(testFailed);
result.ErrorStackTrace = ExceptionUtility.CombineStackTraces(testFailed);
recorder.RecordEnd(result.TestCase, result.Outcome);
recorder.RecordResult(result);
return(!cancelledThunk());
}
protected override bool Visit(IErrorMessage error)
{
lock (consoleLock)
{
Console.WriteLine(" {0} [FATAL]", Escape(error.ExceptionTypes[0]));
Console.WriteLine(" {0}", Escape(ExceptionUtility.CombineMessages(error)));
WriteStackTrace(ExceptionUtility.CombineStackTraces(error));
}
return(base.Visit(error));
}
/// <summary>
/// Handles instances of <see cref="_TestFailed" />.
/// </summary>
protected virtual void HandleTestFailed(MessageHandlerArgs <_TestFailed> args)
{
Guard.ArgumentNotNull(nameof(args), args);
var testFailed = args.Message;
var testMetadata = metadataCache.TryGetTestMetadata(testFailed);
var formattedName = Escape(testMetadata != null ? testMetadata.TestDisplayName : "<unknown test>");
var details = $"{Escape(ExceptionUtility.CombineMessages(testFailed))}|r|n{Escape(ExceptionUtility.CombineStackTraces(testFailed))}";
logger.LogImportantMessage($"##teamcity[testFailed name='{formattedName}' details='{details}' flowId='{testFailed.TestCollectionUniqueID}']");
LogFinish(testFailed);
}
void HandleTestFailed(MessageHandlerArgs <ITestFailed> args)
{
TestRunState = TestRunState.Failure;
var testFailed = args.Message;
var testResult = testFailed.ToTdNetTestResult(TestState.Failed, totalTests);
testResult.Message = ExceptionUtility.CombineMessages(testFailed);
testResult.StackTrace = ExceptionUtility.CombineStackTraces(testFailed);
TestListener.TestFinished(testResult);
WriteOutput(testFailed.Test.DisplayName, testFailed.Output);
}
protected override bool Visit(ITestFailed testFailed)
{
var displayName = TeamCityEscape(GetDisplayName(testFailed.Test));
LogMessage(displayName, false, "##teamcity[testFailed name='{0}' details='{1}|r|n{2}' flowId='{3}']",
displayName,
TeamCityEscape(ExceptionUtility.CombineMessages(testFailed)),
TeamCityEscape(ExceptionUtility.CombineStackTraces(testFailed)),
ToFlowId(testFailed.TestCollection.DisplayName));
LogFinish(testFailed);
return(base.Visit(testFailed));
}
protected bool WriteError(string failureName, IFailureInformation failureInfo, IEnumerable <ITestCase> testCases)
{
foreach (var testCase in testCases)
{
var result = MakeVsTestResult(TestOutcome.Failed, testCase, testCase.DisplayName);
result.ErrorMessage = String.Format("[{0}]: {1}", failureName, ExceptionUtility.CombineMessages(failureInfo));
result.ErrorStackTrace = ExceptionUtility.CombineStackTraces(failureInfo);
recorder.RecordEnd(result.TestCase, result.Outcome);
recorder.RecordResult(result);
}
return(!cancelledThunk());
}
public void NonXunitExceptionWithInnerExceptions()
{
var failureInfo = new FailureInformation {
{ new Exception("outer exception"), -1 },
{ new DivideByZeroException("inner exception"), 0 },
{ new XunitException("inner inner exception"), 1 }
};
var result = ExceptionUtility.CombineMessages(failureInfo);
Assert.Equal("System.Exception : outer exception" + Environment.NewLine +
"---- System.DivideByZeroException : inner exception" + Environment.NewLine +
"-------- inner inner exception", result);
}
protected override bool Visit(ITestFailed testFailed)
{
lock (consoleLock)
{
// TODO: Thread-safe way to figure out the default foreground color
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine(" {0} [FAIL]", Escape(testFailed.Test.DisplayName));
Console.ForegroundColor = ConsoleColor.Gray;
Console.Error.WriteLine(" {0}", ExceptionUtility.CombineMessages(testFailed).Replace(Environment.NewLine, Environment.NewLine + " "));
WriteStackTrace(ExceptionUtility.CombineStackTraces(testFailed));
}
return(base.Visit(testFailed));
}
protected override bool Visit(ITestFailed failed)
{
TestRunState = TestRunState.Failure;
var testResult = failed.ToTdNetTestResult(TestState.Failed);
testResult.Message = ExceptionUtility.CombineMessages(failed);
testResult.StackTrace = ExceptionUtility.CombineStackTraces(failed);
TestListener.TestFinished(testResult);
WriteOutput(failed.TestDisplayName, failed.Output);
return(true);
}
void LogFailureInformation(IFailureInformation info, Action <string> log = null, StringBuilder sb = null)
{
if (info == null)
{
return;
}
string message = ExceptionUtility.CombineMessages(info);
do_log($" Exception messages: {message}", log, sb);
string traces = ExceptionUtility.CombineStackTraces(info);
do_log($" Exception stack traces: {traces}", log, sb);
}
void ReportError(string messageType, IFailureInformation failureInfo)
{
TestRunState = TestRunState.Failure;
var testResult = new TestResult
{
Name = String.Format("*** {0} ***", messageType),
State = TestState.Failed,
TimeSpan = TimeSpan.Zero,
TotalTests = 1,
Message = ExceptionUtility.CombineMessages(failureInfo),
StackTrace = ExceptionUtility.CombineStackTraces(failureInfo)
};
TestListener.TestFinished(testResult);
}
public void AggregateException()
{
var failureInfo = new FailureInformation {
{ new AggregateException(), -1 },
{ new DivideByZeroException("inner #1"), 0 },
{ new NotImplementedException("inner #2"), 0 },
{ new XunitException("this is crazy"), 0 },
};
var result = ExceptionUtility.CombineMessages(failureInfo);
Assert.Equal("System.AggregateException : One or more errors occurred." + Environment.NewLine
+ "---- System.DivideByZeroException : inner #1" + Environment.NewLine
+ "---- System.NotImplementedException : inner #2" + Environment.NewLine
+ "---- this is crazy", result);
}
