/// <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> /// 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); if (recursive) foreach (ITestFilter filter in Filters) filter.AddToXml(result, true); return result; }
/// <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> /// 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); if (recursive) { foreach (ITestFilter filter in Filters) { filter.AddToXml(result, true); } } return(result); }
/// <summary> /// Adds a failure element to a node and returns it. /// </summary> /// <param name="targetNode">The target node.</param> /// <returns>The new failure element.</returns> private TNode AddFailureElement(TNode targetNode) { TNode failureNode = targetNode.AddElement("failure"); if (Message != null) { failureNode.AddElementWithCDATA("message", Message); } if (StackTrace != null) { failureNode.AddElementWithCDATA("stack-trace", StackTrace); } return(failureNode); }
private TNode AddAttachmentsElement(TNode targetNode) { TNode attachmentsNode = targetNode.AddElement("attachments"); foreach (var attachment in _testAttachments) { var attachmentNode = attachmentsNode.AddElement("attachment"); attachmentNode.AddElement("filePath", attachment.FilePath); if (attachment.Description != null) { attachmentNode.AddElementWithCDATA("description", attachment.Description); } } return(attachmentsNode); }
/// <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); }
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.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 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); }
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("o")); thisNode.AddAttribute("end-time", EndTime.ToString("o")); thisNode.AddAttribute("duration", Duration.ToString("0.000000", NumberFormatInfo.InvariantInfo)); if (Test is TestSuite) { thisNode.AddAttribute("total", TotalCount.ToString()); thisNode.AddAttribute("passed", PassCount.ToString()); thisNode.AddAttribute("failed", FailCount.ToString()); thisNode.AddAttribute("warnings", WarningCount.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: case TestStatus.Warning: if (Message != null && Message.Trim().Length > 0) { TNode reasonNode = thisNode.AddElement("reason"); reasonNode.AddElementWithCDATA("message", Message); } break; } if (Output.Length > 0) { AddOutputElement(thisNode); } if (AssertionResults.Count > 0) { AddAssertionsElement(thisNode); } if (_testAttachments.Count > 0) { AddAttachmentsElement(thisNode); } if (recursive && HasChildren) { foreach (var child in Children) { child.AddToXml(thisNode, recursive); } } return(thisNode); }
/// <summary> /// Adds a failure element to a node and returns it. /// </summary> /// <param name="targetNode">The target node.</param> /// <returns>The new failure element.</returns> private TNode AddFailureElement(TNode targetNode) { TNode failureNode = targetNode.AddElement("failure"); if (Message != null) failureNode.AddElementWithCDATA("message", Message); if (StackTrace != null) failureNode.AddElementWithCDATA("stack-trace", StackTrace); return failureNode; }
/// <summary> /// Adds a reason element to a node and returns it. /// </summary> /// <param name="targetNode">The target node.</param> /// <returns>The new reason element.</returns> private TNode AddReasonElement(TNode targetNode) { TNode reasonNode = targetNode.AddElement("reason"); return reasonNode.AddElementWithCDATA("message", Message); }
/// <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; }
public override TNode AddToXml(TNode parentNode, bool recursive) { return(parentNode.AddElement("filter")); }
public override TNode AddToXml(TNode parentNode, bool recursive) { return parentNode.AddElement("filter"); }
/// <summary> /// Adds a reason element to a node and returns it. /// </summary> /// <param name="targetNode">The target node.</param> /// <returns>The new reason element.</returns> private TNode AddReasonElement(TNode targetNode) { TNode reasonNode = targetNode.AddElement("reason"); return(reasonNode.AddElementWithCDATA("message", Message)); }
/// <summary> /// Adds a reason element to a node and returns it. /// </summary> /// <param name="targetNode">The target node.</param> /// <returns>The new reason element.</returns> private TNode AddReasonElement(TNode targetNode) { TNode reasonNode = targetNode.AddElement("reason"); return reasonNode.AddElement("message", EscapedMessage); }
public TNode AddToXml(TNode parentNode, bool recursive) { parentNode.AddElement("test", fullName); return(parentNode); }
/// <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; }
private TNode AddOutputElement(TNode targetNode) { return(targetNode.AddElement("output", Output)); }
/// <summary> /// Adds a reason element to a node and returns it. /// </summary> /// <param name="targetNode">The target node.</param> /// <returns>The new reason element.</returns> private TNode AddReasonElement(TNode targetNode) { TNode reasonNode = targetNode.AddElement("reason"); return(reasonNode.AddElement("message", EscapedMessage)); }
///// <summary> ///// Determine whether any descendant of the test matches the filter criteria. ///// </summary> ///// <param name="test">The test to be matched</param> ///// <returns>True if at least one descendant matches the filter criteria</returns> //protected override bool MatchDescendant(ITest test) //{ // if (!test.HasChildren || test.Tests == null || TopLevel && test.RunState == RunState.Explicit) // return false; // foreach (ITest child in test.Tests) // { // if (Match(child) || MatchDescendant(child)) // return true; // } // return false; //} /// <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("not"); if (recursive) BaseFilter.AddToXml(result, true); return result; }
private TNode AddOutputElement(TNode targetNode) { return targetNode.AddElement("output", Output); }
public TNode AddToXml(TNode parentNode, bool recursive) { return(parentNode.AddElement("synchronousOnly")); }
/// <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; }
public override TNode AddToXml(TNode parentNode, bool recursive) { return(parentNode.AddElement("class", expectedValue)); }