// 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']");
}
static string?GetStackTrace(
_IErrorMetadata errorMetadata,
int index)
{
Guard.ArgumentNotNull(nameof(errorMetadata), errorMetadata);
var result = FilterStackTrace(GetAt(errorMetadata.StackTraces, index));
var children = new List <int>();
for (var subIndex = index + 1; subIndex < errorMetadata.ExceptionParentIndices.Length; ++subIndex)
{
if (GetAt(errorMetadata.ExceptionParentIndices, subIndex) == index)
{
children.Add(subIndex);
}
}
if (children.Count > 1)
{
for (var idx = 0; idx < children.Count; ++idx)
{
result += $"{Environment.NewLine}----- Inner Stack Trace #{idx + 1} ({GetAt(errorMetadata.ExceptionTypes, children[idx])}) -----{Environment.NewLine}{GetStackTrace(errorMetadata, children[idx])}";
}
}
else if (children.Count == 1)
{
result += $"{Environment.NewLine}----- Inner Stack Trace -----{Environment.NewLine}{GetStackTrace(errorMetadata, children[0])}";
}
return(result);
}
static void AssertErrorMetadata(
_IErrorMetadata metadata,
Exception ex)
{
var(exceptionTypes, messages, _, exceptionParentIndices, _) = ExceptionUtility.ExtractMetadata(ex);
Assert.Equal(exceptionParentIndices, metadata.ExceptionParentIndices);
Assert.Equal(exceptionTypes, metadata.ExceptionTypes, StringComparer.Ordinal);
Assert.Equal(messages, metadata.Messages, StringComparer.Ordinal);
}
static void AssertErrorMetadata(
_IErrorMetadata metadata,
Exception ex)
{
var convertedMetadata = ExceptionUtility.ExtractMetadata(ex);
Assert.Equal(convertedMetadata.ExceptionParentIndices, metadata.ExceptionParentIndices);
Assert.Equal(convertedMetadata.ExceptionTypes, metadata.ExceptionTypes, StringComparer.Ordinal);
Assert.Equal(convertedMetadata.Messages, metadata.Messages, StringComparer.Ordinal);
Assert.Equal(convertedMetadata.StackTraces, metadata.StackTraces, StringComparer.Ordinal);
}
void AddError(
string type,
string?name,
_IErrorMetadata errorMetadata)
{
var errorElement = new XElement("error", new XAttribute("type", type), CreateFailureElement(errorMetadata));
if (name != null)
{
errorElement.Add(new XAttribute("name", name));
}
errorsElement.Add(errorElement);
}
void ReportError(
string messageType,
_IErrorMetadata errorMetadata)
{
TestRunState = TestRunState.Failure;
var testResult = new TestResult
{
Name = $"*** {messageType} ***",
State = TestState.Failed,
TimeSpan = TimeSpan.Zero,
TotalTests = 1,
Message = ExceptionUtility.CombineMessages(errorMetadata),
StackTrace = ExceptionUtility.CombineStackTraces(errorMetadata)
};
TestListener.TestFinished(testResult);
}
/// <summary>
/// Logs an error message to the logger.
/// </summary>
/// <param name="failureType">The type of the failure</param>
/// <param name="errorMetadata">The failure information</param>
protected void LogError(
string failureType,
_IErrorMetadata errorMetadata)
{
Guard.ArgumentNotNull(nameof(failureType), failureType);
Guard.ArgumentNotNull(nameof(errorMetadata), errorMetadata);
var frameInfo = StackFrameInfo.FromErrorMetadata(errorMetadata);
lock (Logger.LockObject)
{
Logger.LogError(frameInfo, $" [{failureType}] {Escape(errorMetadata.ExceptionTypes.FirstOrDefault() ?? "(Unknown Exception Type)")}");
foreach (var messageLine in ExceptionUtility.CombineMessages(errorMetadata).Split(new[] { Environment.NewLine }, StringSplitOptions.None))
{
Logger.LogImportantMessage(frameInfo, $" {messageLine}");
}
LogStackTrace(frameInfo, ExceptionUtility.CombineStackTraces(errorMetadata));
}
}
static string GetMessage(
_IErrorMetadata errorMetadata,
int index,
int level)
{
Guard.ArgumentNotNull(nameof(errorMetadata), errorMetadata);
var result = "";
if (level > 0)
{
for (var idx = 0; idx < level; idx++)
{
result += "----";
}
result += " ";
}
var exceptionType = GetAt(errorMetadata.ExceptionTypes, index);
if (GetNamespace(exceptionType) != "Xunit.Sdk")
{
result += exceptionType + " : ";
}
result += GetAt(errorMetadata.Messages, index);
for (var subIndex = index + 1; subIndex < errorMetadata.ExceptionParentIndices.Length; ++subIndex)
{
if (GetAt(errorMetadata.ExceptionParentIndices, subIndex) == index)
{
result += Environment.NewLine + GetMessage(errorMetadata, subIndex, level + 1);
}
}
return(result);
}
static XElement CreateFailureElement(_IErrorMetadata errorMetadata) =>
new XElement("failure",
new XAttribute("exception-type", errorMetadata.ExceptionTypes[0] ?? "<unknown type>"),
new XElement("message", new XCData(XmlEscape(ExceptionUtility.CombineMessages(errorMetadata)))),
new XElement("stack-trace", new XCData(ExceptionUtility.CombineStackTraces(errorMetadata) ?? string.Empty))
);
/// <summary> /// Combines multiple levels of stack traces into a single stack trace. /// </summary> /// <param name="errorMetadata">The error metadata from which to get the stack traces.</param> /// <returns>The combined string.</returns> public static string?CombineStackTraces(_IErrorMetadata errorMetadata) => GetStackTrace(errorMetadata, 0);
/// <summary> /// Combines multiple levels of messages into a single message. /// </summary> /// <param name="errorMetadata">The error metadata from which to get the messages.</param> /// <returns>The combined string.</returns> public static string CombineMessages(_IErrorMetadata errorMetadata) => GetMessage(errorMetadata, 0, 0);
