private static void AddSetting(TNode settingsNode, string name, object value)
{
TNode setting = new TNode("setting");
setting.AddAttribute("name", name);
if (value != null)
{
var dict = value as IDictionary;
if (dict != null)
{
AddDictionaryEntries(setting, dict);
AddBackwardsCompatibleDictionaryEntries(setting, dict);
}
else
{
setting.AddAttribute("value", value.ToString());
}
}
else
{
setting.AddAttribute("value", null);
}
settingsNode.ChildNodes.Add(setting);
}
/// <summary>
/// Called when a test has just started
/// </summary>
/// <param name="test">The test that is starting</param>
public void TestStarted(ITest test)
{
string startElement = test is TestSuite
? "start-suite"
: "start-test";
var parent = GetParent(test);
try
{
TNode thisNode = new TNode(startElement);
thisNode.AddAttribute("id", test.Id);
thisNode.AddAttribute("parentId", parent != null ? parent.Id : string.Empty);
thisNode.AddAttribute("name", FormatAttributeValue(test.Name));
thisNode.AddAttribute("fullname", FormatAttributeValue(test.FullName));
thisNode.AddAttribute("type", test.TestType);
if (test.StdIn != null)
{
thisNode.AddElementWithCDATA("stdin", test.StdIn);
}
handler.RaiseCallbackEvent(thisNode.OuterXml);
}
catch (Exception ex)
{
log.Error("Exception processing " + test.FullName + Environment.NewLine + ex.ToString());
}
}
private static void AddSetting(TNode settingsNode, string name, object value)
{
TNode setting = new TNode("setting");
setting.AddAttribute("name", name);
setting.AddAttribute("value", value.ToString());
settingsNode.ChildNodes.Add(setting);
}
/// <summary>
/// Convert the TestOutput object to an XML string
/// </summary>
public string ToXml()
{
TNode tnode = new TNode("test-output", Text, true);
tnode.AddAttribute("stream", Stream);
if (TestName != null)
tnode.AddAttribute("testname", TestName);
return tnode.OuterXml;
}
private static void AddDictionaryEntries(TNode settingNode, IDictionary entries)
{
foreach (var key in entries.Keys)
{
var value = entries[key];
var entryNode = new TNode("item");
entryNode.AddAttribute("key", key.ToString());
entryNode.AddAttribute("value", value?.ToString() ?? "");
settingNode.ChildNodes.Add(entryNode);
}
}
/// <summary>
/// Adds an XML node
/// </summary>
/// <param name="parentNode">Parent node</param>
/// <param name="recursive">True if recursive</param>
/// <returns>The added XML node</returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode result = base.AddToXml(parentNode, recursive);
result.AddAttribute("name", _propertyName);
return(result);
}
private TNode AddAssertionsElement(TNode targetNode)
{
var assertionsNode = targetNode.AddElement("assertions");
foreach (var assertion in AssertionResults)
{
TNode assertionNode = assertionsNode.AddElement("assertion");
assertionNode.AddAttribute("result", assertion.Status.ToString());
if (assertion.Actual != null && assertion.Expected != null)
{
assertionNode.AddElementWithCDATA("actual", assertion.Actual.ToString());
assertionNode.AddElementWithCDATA("expected", assertion.Expected.ToString());
}
if (assertion.Message != null)
{
assertionNode.AddElementWithCDATA("message", assertion.Message);
}
if (assertion.StackTrace != null)
{
assertionNode.AddElementWithCDATA("stack-trace", assertion.StackTrace);
}
}
return(assertionsNode);
}
/// <summary>
/// Returns an XmlNode representing the PropertyBag after
/// adding it as a child of the supplied parent node.
/// </summary>
/// <param name="parentNode">The parent node.</param>
/// <param name="recursive">Not used</param>
/// <returns></returns>
public TNode AddToXml(TNode parentNode, bool recursive)
{
TNode properties = parentNode.AddElement("properties");
foreach (string key in Keys)
{
foreach (object value in this[key])
{
TNode prop = properties.AddElement("property");
// TODO: Format as string
prop.AddAttribute("name", key.ToString());
prop.AddAttribute("value", value.ToString());
}
}
return(properties);
}
/// <summary>
/// Returns a TNode representing the current result after
/// adding it as a child of the supplied parent node.
/// </summary>
/// <param name="parentNode">The parent node.</param>
/// <param name="recursive">If true, descendant results are included</param>
/// <returns></returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode thisNode = parentNode.AddElement(XmlElementName);
PopulateTestNode(thisNode, recursive);
thisNode.AddAttribute("seed", this.Seed.ToString());
return(thisNode);
}
private static void AddBackwardsCompatibleDictionaryEntries(TNode settingsNode, IDictionary entries)
{
var pairs = new List <string>(entries.Count);
foreach (var key in entries.Keys)
{
pairs.Add($"[{key}, {entries[key]}]");
}
settingsNode.AddAttribute("value", string.Join(", ", pairs.ToArray()));
}
/// <summary>
/// Adds an XML node
/// </summary>
/// <param name="parentNode">Parent node</param>
/// <param name="recursive">True if recursive</param>
/// <returns>The added XML node</returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode result = parentNode.AddElement(ElementName, ExpectedValue);
if (IsRegex)
{
result.AddAttribute("re", "1");
}
return(result);
}
/// <summary>
/// Returns an XmlNode representing the current result after
/// adding it as a child of the supplied parent node.
/// </summary>
/// <param name="parentNode">The parent node.</param>
/// <param name="recursive">If true, descendant results are included</param>
/// <returns></returns>
public override TNode AddToXml(TNode parentNode, bool recursive)
{
TNode thisNode = parentNode.AddElement("test-suite");
thisNode.AddAttribute("type", this.TestType);
PopulateTestNode(thisNode, recursive);
thisNode.AddAttribute("testcasecount", this.TestCaseCount.ToString());
if (recursive)
{
foreach (Test test in this.Tests)
{
test.AddToXml(thisNode, recursive);
}
}
return(thisNode);
}
/// <summary>
/// Inserts environment element
/// </summary>
/// <param name="targetNode">Target node</param>
/// <returns>The new node</returns>
#if NETSTANDARD1_6
public static TNode InsertEnvironmentElement(TNode targetNode)
{
TNode env = new TNode("environment");
targetNode.ChildNodes.Insert(0, env);
var assemblyName = AssemblyHelper.GetAssemblyName(typeof(FrameworkController).GetTypeInfo().Assembly);
env.AddAttribute("framework-version", assemblyName.Version.ToString());
env.AddAttribute("cwd", Directory.GetCurrentDirectory());
env.AddAttribute("culture", CultureInfo.CurrentCulture.ToString());
env.AddAttribute("uiculture", CultureInfo.CurrentUICulture.ToString());
env.AddAttribute("clr-version", RuntimeInformation.FrameworkDescription);
env.AddAttribute("os-version", RuntimeInformation.OSDescription);
env.AddAttribute("machine-name", Environment.MachineName);
env.AddAttribute("os-architecture", RuntimeInformation.ProcessArchitecture.ToString());
return(env);
}
protected void PopulateTestNode(TNode thisNode, bool recursive)
{
thisNode.AddAttribute("id", this.Id.ToString());
thisNode.AddAttribute("name", this.Name);
thisNode.AddAttribute("fullname", this.FullName);
if (this.MethodName != null)
{
thisNode.AddAttribute("methodname", this.MethodName);
}
if (this.ClassName != null)
{
thisNode.AddAttribute("classname", this.ClassName);
}
thisNode.AddAttribute("runstate", this.RunState.ToString());
if (Properties.Keys.Count > 0)
{
Properties.AddToXml(thisNode, recursive);
}
}
private TNode MakeTestRunElement(ITestResult result)
{
TNode testRun = new TNode("test-run");
testRun.AddAttribute("id", "2");
testRun.AddAttribute("name", result.Name);
testRun.AddAttribute("fullname", result.FullName);
testRun.AddAttribute("testcasecount", result.Test.TestCaseCount.ToString());
testRun.AddAttribute("result", result.ResultState.Status.ToString());
if (result.ResultState.Label != string.Empty)
{
testRun.AddAttribute("label", result.ResultState.Label);
}
testRun.AddAttribute("start-time", result.StartTime.ToString("u"));
testRun.AddAttribute("end-time", result.EndTime.ToString("u"));
testRun.AddAttribute("duration", result.Duration.ToString("0.000000", NumberFormatInfo.InvariantInfo));
testRun.AddAttribute("total", (result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount).ToString());
testRun.AddAttribute("passed", result.PassCount.ToString());
testRun.AddAttribute("failed", result.FailCount.ToString());
testRun.AddAttribute("inconclusive", result.InconclusiveCount.ToString());
testRun.AddAttribute("skipped", result.SkipCount.ToString());
testRun.AddAttribute("asserts", result.AssertCount.ToString());
testRun.AddAttribute("random-seed", Randomizer.InitialSeed.ToString());
// NOTE: The console runner adds attributes for engine-version and clr-version
// Neither of these is needed under nunitlite since there is no engine involved
// and we are running under the same runtime as the tests.
return(testRun);
}
/// <summary>
/// Inserts environment element
/// </summary>
/// <param name="targetNode">Target node</param>
/// <returns>The new node</returns>
#if NETSTANDARD1_6
public static TNode InsertEnvironmentElement(TNode targetNode)
{
TNode env = new TNode("environment");
targetNode.ChildNodes.Insert(0, env);
var assemblyName = AssemblyHelper.GetAssemblyName(typeof(FrameworkController).GetTypeInfo().Assembly);
env.AddAttribute("framework-version", assemblyName.Version.ToString());
env.AddAttribute("clr-version", RuntimeInformation.FrameworkDescription);
env.AddAttribute("os-version", RuntimeInformation.OSDescription);
env.AddAttribute("cwd", Directory.GetCurrentDirectory());
env.AddAttribute("machine-name", Environment.MachineName);
env.AddAttribute("culture", CultureInfo.CurrentCulture.ToString());
env.AddAttribute("uiculture", CultureInfo.CurrentUICulture.ToString());
env.AddAttribute("os-architecture", RuntimeInformation.ProcessArchitecture.ToString());
return env;
}
/// <summary>
/// Inserts environment element
/// </summary>
/// <param name="targetNode">Target node</param>
/// <returns>The new node</returns>
public static TNode InsertEnvironmentElement(TNode targetNode)
{
TNode env = new TNode("environment");
targetNode.ChildNodes.Insert(0, env);
env.AddAttribute("framework-version", Assembly.GetExecutingAssembly().GetName().Version.ToString());
env.AddAttribute("clr-version", Environment.Version.ToString());
env.AddAttribute("os-version", Environment.OSVersion.ToString());
env.AddAttribute("platform", Environment.OSVersion.Platform.ToString());
#if !NETCF
env.AddAttribute("cwd", Environment.CurrentDirectory);
env.AddAttribute("machine-name", Environment.MachineName);
env.AddAttribute("user", Environment.UserName);
env.AddAttribute("user-domain", Environment.UserDomainName);
#endif
env.AddAttribute("culture", CultureInfo.CurrentCulture.ToString());
env.AddAttribute("uiculture", CultureInfo.CurrentUICulture.ToString());
env.AddAttribute("os-architecture", GetProcessorArchitecture());
return(env);
}
private static void AddSetting(TNode settingsNode, string name, object value)
{
TNode setting = new TNode("setting");
setting.AddAttribute("name", name);
setting.AddAttribute("value", value.ToString());
settingsNode.ChildNodes.Add(setting);
}
/// <summary>
/// Inserts environment element
/// </summary>
/// <param name="targetNode">Target node</param>
/// <returns>The new node</returns>
public static TNode InsertEnvironmentElement(TNode targetNode)
{
TNode env = new TNode("environment");
targetNode.ChildNodes.Insert(0, env);
env.AddAttribute("framework-version", Assembly.GetExecutingAssembly().GetName().Version.ToString());
env.AddAttribute("clr-version", Environment.Version.ToString());
env.AddAttribute("os-version", Environment.OSVersion.ToString());
env.AddAttribute("platform", Environment.OSVersion.Platform.ToString());
#if !NETCF
env.AddAttribute("cwd", Environment.CurrentDirectory);
env.AddAttribute("machine-name", Environment.MachineName);
env.AddAttribute("user", Environment.UserName);
env.AddAttribute("user-domain", Environment.UserDomainName);
#endif
env.AddAttribute("culture", CultureInfo.CurrentCulture.ToString());
env.AddAttribute("uiculture", CultureInfo.CurrentUICulture.ToString());
env.AddAttribute("os-architecture", GetProcessorArchitecture());
return env;
}
void WriteResultsToXml(ITestResultAdaptor result, XmlWriter xmlWriter)
{
// XML format as specified at https://github.com/nunit/docs/wiki/Test-Result-XML-Format
var testRunNode = new TNode(k_TestRunNode);
testRunNode.AddAttribute(k_Id, "2");
testRunNode.AddAttribute(k_Testcasecount, (result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount).ToString());
testRunNode.AddAttribute(k_Result, result.ResultState.ToString());
testRunNode.AddAttribute(k_Total, (result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount).ToString());
testRunNode.AddAttribute(k_Passed, result.PassCount.ToString());
testRunNode.AddAttribute(k_Failed, result.FailCount.ToString());
testRunNode.AddAttribute(k_Inconclusive, result.InconclusiveCount.ToString());
testRunNode.AddAttribute(k_Skipped, result.SkipCount.ToString());
testRunNode.AddAttribute(k_Asserts, result.AssertCount.ToString());
testRunNode.AddAttribute(k_EngineVersion, k_nUnitVersion);
testRunNode.AddAttribute(k_ClrVersion, Environment.Version.ToString());
testRunNode.AddAttribute(k_StartTime, result.StartTime.ToString(k_TimeFormat));
testRunNode.AddAttribute(k_EndTime, result.EndTime.ToString(k_TimeFormat));
testRunNode.AddAttribute(k_Duration, result.Duration.ToString());
var resultNode = result.ToXml();
testRunNode.ChildNodes.Add(resultNode);
testRunNode.WriteTo(xmlWriter);
}
/// <summary>
/// Inserts environment element
/// </summary>
/// <param name="targetNode">Target node</param>
/// <returns>The new node</returns>
public static TNode InsertEnvironmentElement(TNode targetNode)
{
TNode env = new TNode("environment");
targetNode.ChildNodes.Insert(0, env);
env.AddAttribute("framework-version", typeof(FrameworkController).GetTypeInfo().Assembly.GetName().Version.ToString());
#if NETSTANDARD1_6
env.AddAttribute("clr-version", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription);
#else
env.AddAttribute("clr-version", Environment.Version.ToString());
#endif
#if !PLATFORM_DETECTION
env.AddAttribute("os-version", System.Runtime.InteropServices.RuntimeInformation.OSDescription);
#else
env.AddAttribute("os-version", OSPlatform.CurrentPlatform.ToString());
#endif
#if !NETSTANDARD1_6
env.AddAttribute("platform", Environment.OSVersion.Platform.ToString());
#endif
env.AddAttribute("cwd", Directory.GetCurrentDirectory());
env.AddAttribute("machine-name", Environment.MachineName);
#if !NETSTANDARD1_6
env.AddAttribute("user", Environment.UserName);
env.AddAttribute("user-domain", Environment.UserDomainName);
#endif
env.AddAttribute("culture", CultureInfo.CurrentCulture.ToString());
env.AddAttribute("uiculture", CultureInfo.CurrentUICulture.ToString());
env.AddAttribute("os-architecture", GetProcessorArchitecture());
return(env);
}
/// <summary>
/// Add standard attributes and members to a test node.
/// </summary>
/// <param name="thisNode"></param>
/// <param name="recursive"></param>
protected void PopulateTestNode(TNode thisNode, bool recursive)
{
thisNode.AddAttribute("id", this.Id.ToString());
thisNode.AddAttribute("name", this.Name);
thisNode.AddAttribute("fullname", this.FullName);
if (this.MethodName != null)
thisNode.AddAttribute("methodname", this.MethodName);
if (this.ClassName != null)
thisNode.AddAttribute("classname", this.ClassName);
thisNode.AddAttribute("runstate", this.RunState.ToString());
if (Properties.Keys.Count > 0)
Properties.AddToXml(thisNode, recursive);
}
/// <summary>
/// Adds the XML representation of the result as a child of the
/// supplied parent node..
/// </summary>
/// <param name="parentNode">The parent node.</param>
/// <param name="recursive">If true, descendant results are included</param>
/// <returns></returns>
public virtual TNode AddToXml(TNode parentNode, bool recursive)
{
// A result node looks like a test node with extra info added
TNode thisNode = Test.AddToXml(parentNode, false);
thisNode.AddAttribute("result", ResultState.Status.ToString());
if (ResultState.Label != string.Empty) // && ResultState.Label != ResultState.Status.ToString())
{
thisNode.AddAttribute("label", ResultState.Label);
}
if (ResultState.Site != FailureSite.Test)
{
thisNode.AddAttribute("site", ResultState.Site.ToString());
}
thisNode.AddAttribute("start-time", StartTime.ToString("u"));
thisNode.AddAttribute("end-time", EndTime.ToString("u"));
thisNode.AddAttribute("duration", Duration.ToString("0.000000", NumberFormatInfo.InvariantInfo));
if (Test is TestSuite)
{
thisNode.AddAttribute("total", (PassCount + FailCount + SkipCount + InconclusiveCount).ToString());
thisNode.AddAttribute("passed", PassCount.ToString());
thisNode.AddAttribute("failed", FailCount.ToString());
thisNode.AddAttribute("inconclusive", InconclusiveCount.ToString());
thisNode.AddAttribute("skipped", SkipCount.ToString());
}
thisNode.AddAttribute("asserts", AssertCount.ToString());
switch (ResultState.Status)
{
case TestStatus.Failed:
AddFailureElement(thisNode);
break;
case TestStatus.Skipped:
case TestStatus.Passed:
case TestStatus.Inconclusive:
if (Message != null)
{
AddReasonElement(thisNode);
}
break;
}
if (Output.Length > 0)
{
AddOutputElement(thisNode);
}
if (recursive && HasChildren)
{
foreach (TestResult child in Children)
{
child.AddToXml(thisNode, recursive);
}
}
return(thisNode);
}
private TNode MakeTestRunElement(ITestResult result)
{
TNode testRun = new TNode("test-run");
testRun.AddAttribute("id", "2");
testRun.AddAttribute("name", result.Name);
testRun.AddAttribute("fullname", result.FullName);
testRun.AddAttribute("testcasecount", result.Test.TestCaseCount.ToString());
testRun.AddAttribute("result", result.ResultState.Status.ToString());
if (result.ResultState.Label != string.Empty)
testRun.AddAttribute("label", result.ResultState.Label);
testRun.AddAttribute("start-time", result.StartTime.ToString("u"));
testRun.AddAttribute("end-time", result.EndTime.ToString("u"));
testRun.AddAttribute("duration", result.Duration.ToString("0.000000", NumberFormatInfo.InvariantInfo));
testRun.AddAttribute("total", (result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount).ToString());
testRun.AddAttribute("passed", result.PassCount.ToString());
testRun.AddAttribute("failed", result.FailCount.ToString());
testRun.AddAttribute("inconclusive", result.InconclusiveCount.ToString());
testRun.AddAttribute("skipped", result.SkipCount.ToString());
testRun.AddAttribute("asserts", result.AssertCount.ToString());
testRun.AddAttribute("random-seed", Randomizer.InitialSeed.ToString());
// NOTE: The console runner adds attributes for engine-version and clr-version
// Neither of these is needed under nunitlite since there is no engine involved
// and we are running under the same runtime as the tests.
return testRun;
}
