TestResult
The TestResult class represents the result of a test.
using NUnit.Framework.Interfaces;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;
namespace NUnit.Framework.Internal
{
public abstract class TestResult : ITestResult, IXmlNodeBuilder
{
internal static readonly string CHILD_ERRORS_MESSAGE = "One or more child tests had errors";
internal static readonly string CHILD_IGNORE_MESSAGE = "One or more child tests were ignored";
internal const double MIN_DURATION = 1E-06;
private List<ITestResult> _children;
private StringWriter _outWriter;
private double _duration;
public ITest Test { get; set; }
public ResultState ResultState { get; set; }
public virtual string Name => Test.Name;
public virtual string FullName => Test.FullName;
public double Duration {
get {
return _duration;
}
set {
_duration = ((value >= 1E-06) ? value : 1E-06);
}
}
public DateTime StartTime { get; set; }
public DateTime EndTime { get; set; }
public string Message { get; set; }
public string EscapedMessage => EscapeInvalidXmlCharacters(Message);
public virtual string StackTrace { get; set; }
public int AssertCount { get; set; }
public abstract int FailCount { get; }
public abstract int PassCount { get; }
public abstract int SkipCount { get; }
public abstract int InconclusiveCount { get; }
public bool HasChildren {
get {
if (_children != null)
return _children.Count > 0;
return false;
}
}
public IList<ITestResult> Children {
get {
if (_children == null)
_children = new List<ITestResult>();
return _children;
}
}
public StringWriter OutWriter {
get {
if (_outWriter == null)
_outWriter = new StringWriter();
return _outWriter;
}
}
public string Output {
get {
if (_outWriter != null)
return _outWriter.ToString();
return string.Empty;
}
}
public TestResult(ITest test)
{
Test = test;
ResultState = ResultState.Inconclusive;
}
public XmlNode ToXml(bool recursive)
{
XmlNode xmlNode = XmlNode.CreateTopLevelElement("dummy");
AddToXml(xmlNode, recursive);
return xmlNode.FirstChild;
}
public virtual XmlNode AddToXml(XmlNode parentNode, bool recursive)
{
XmlNode xmlNode = Test.AddToXml(parentNode, false);
XmlNode xmlNode2 = xmlNode;
TestStatus status = ResultState.Status;
xmlNode2.AddAttribute("result", status.ToString());
if (ResultState.Label != string.Empty)
xmlNode.AddAttribute("label", ResultState.Label);
if (ResultState.Site != 0)
xmlNode.AddAttribute("site", ResultState.Site.ToString());
XmlNode xmlNode3 = xmlNode;
DateTime dateTime = StartTime;
xmlNode3.AddAttribute("start-time", dateTime.ToString("u"));
XmlNode xmlNode4 = xmlNode;
dateTime = EndTime;
xmlNode4.AddAttribute("end-time", dateTime.ToString("u"));
xmlNode.AddAttribute("duration", Duration.ToString("0.000000", NumberFormatInfo.InvariantInfo));
int num;
if (Test is TestSuite) {
XmlNode xmlNode5 = xmlNode;
num = PassCount + FailCount + SkipCount + InconclusiveCount;
xmlNode5.AddAttribute("total", num.ToString());
XmlNode xmlNode6 = xmlNode;
num = PassCount;
xmlNode6.AddAttribute("passed", num.ToString());
XmlNode xmlNode7 = xmlNode;
num = FailCount;
xmlNode7.AddAttribute("failed", num.ToString());
XmlNode xmlNode8 = xmlNode;
num = InconclusiveCount;
xmlNode8.AddAttribute("inconclusive", num.ToString());
XmlNode xmlNode9 = xmlNode;
num = SkipCount;
xmlNode9.AddAttribute("skipped", num.ToString());
}
XmlNode xmlNode10 = xmlNode;
num = AssertCount;
xmlNode10.AddAttribute("asserts", num.ToString());
status = ResultState.Status;
switch (status) {
case TestStatus.Failed:
AddFailureElement(xmlNode);
break;
case TestStatus.Skipped:
AddReasonElement(xmlNode);
break;
case TestStatus.Inconclusive:
case TestStatus.Passed:
if (Message != null)
AddReasonElement(xmlNode);
break;
}
if (Output.Length > 0)
AddOutputElement(xmlNode);
if (recursive && HasChildren) {
foreach (TestResult child in Children) {
child.AddToXml(xmlNode, recursive);
}
return xmlNode;
}
return xmlNode;
}
public virtual void AddResult(ITestResult result)
{
Children.Add(result);
if (ResultState != ResultState.Cancelled) {
switch (result.ResultState.Status) {
case TestStatus.Passed:
if (ResultState.Status == TestStatus.Inconclusive)
SetResult(ResultState.Success);
break;
case TestStatus.Failed:
if (ResultState.Status != TestStatus.Failed)
SetResult(ResultState.ChildFailure, CHILD_ERRORS_MESSAGE);
break;
case TestStatus.Skipped:
if (result.ResultState.Label == "Ignored" && (ResultState.Status == TestStatus.Inconclusive || ResultState.Status == TestStatus.Passed))
SetResult(ResultState.Ignored, CHILD_IGNORE_MESSAGE);
break;
}
}
}
public void SetResult(ResultState resultState)
{
SetResult(resultState, null, null);
}
public void SetResult(ResultState resultState, string message)
{
SetResult(resultState, message, null);
}
public void SetResult(ResultState resultState, string message, string stackTrace)
{
ResultState = resultState;
Message = message;
StackTrace = stackTrace;
}
public void RecordException(Exception ex)
{
if (ex is NUnitException)
ex = ex.InnerException;
if (ex is ResultStateException)
SetResult(((ResultStateException)ex).ResultState, ex.Message, StackFilter.Filter(ex.StackTrace));
else if (ex is ThreadAbortException) {
SetResult(ResultState.Cancelled, "Test cancelled by user", ex.StackTrace);
} else {
SetResult(ResultState.Error, ExceptionHelper.BuildMessage(ex), ExceptionHelper.BuildStackTrace(ex));
}
}
public void RecordException(Exception ex, FailureSite site)
{
if (ex is NUnitException)
ex = ex.InnerException;
if (ex is ResultStateException)
SetResult(((ResultStateException)ex).ResultState.WithSite(site), ex.Message, StackFilter.Filter(ex.StackTrace));
else if (ex is ThreadAbortException) {
SetResult(ResultState.Cancelled.WithSite(site), "Test cancelled by user", ex.StackTrace);
} else {
SetResult(ResultState.Error.WithSite(site), ExceptionHelper.BuildMessage(ex), ExceptionHelper.BuildStackTrace(ex));
}
}
public void RecordTearDownException(Exception ex)
{
if (ex is NUnitException)
ex = ex.InnerException;
ResultState resultState = (ResultState == ResultState.Cancelled) ? ResultState.Cancelled : ResultState.Error;
if (Test.IsSuite)
resultState = resultState.WithSite(FailureSite.TearDown);
string text = "TearDown : " + ExceptionHelper.BuildMessage(ex);
if (Message != null)
text = Message + Env.NewLine + text;
string text2 = "--TearDown" + Env.NewLine + ExceptionHelper.BuildStackTrace(ex);
if (StackTrace != null)
text2 = StackTrace + Env.NewLine + text2;
SetResult(resultState, text, text2);
}
private XmlNode AddReasonElement(XmlNode targetNode)
{
XmlNode xmlNode = targetNode.AddElement("reason");
xmlNode.AddElement("message").TextContent = EscapedMessage;
return xmlNode;
}
private XmlNode AddFailureElement(XmlNode targetNode)
{
XmlNode xmlNode = targetNode.AddElement("failure");
if (Message != null)
xmlNode.AddElement("message").TextContent = EscapedMessage;
if (StackTrace != null)
xmlNode.AddElement("stack-trace").TextContent = StackTrace;
return xmlNode;
}
private XmlNode AddOutputElement(XmlNode targetNode)
{
XmlNode xmlNode = targetNode.AddElement("output");
xmlNode.TextContent = Output;
return xmlNode;
}
private static string EscapeInvalidXmlCharacters(string str)
{
return new Regex("[^\t\n\r -�]|([�-�](?![�-�]))|((?<![�-�])[�-�])").Replace(str, (Match match) => CharToUnicodeSequence(match.Value[0]));
}
private static string CharToUnicodeSequence(char symbol)
{
int num = symbol;
return string.Format("\\u{0}", num.ToString("x4"));
}
}
}