/// <summary> /// Constructor /// </summary> /// <param name="name">Test Unit (local) name.</param> /// <param name="parent">Parent/Owner Test Unit of this instance.</param> protected TestUnit(string name, TestUnit parent) { this.Id = null; this.Name = name; this.Parent = parent; if (parent != null) { parent.AddChild(this); } }
/// <summary> /// Helper function which aids in the implementation of QualifiedNameBuilder(TestUnit) constructor /// </summary> /// <param name="root">The test unit which is to be listed</param> private void Initialize(TestUnit root) { if (root == null) { return; } Initialize(root.Parent); this.Push(root); }
/// <summary> /// Constructor /// </summary> /// <param name="name">Test Unit (local) name.</param> /// <param name="parent">Parent/Owner Test Unit of this instance.</param> protected TestUnit(string name, TestUnit parent) { this.Id = null; this.Name = name; this.Parent = parent; this.Labels = Enumerable.Empty<string>(); if (parent != null) { parent.AddChild(this); } }
/// <summary> /// Parses a general test result information from the provided node. /// </summary> /// <param name="node">The XPathNavigator pointing to a TestUnit node.</param> /// <param name="unit">The test unit for which the test results are related to.</param> /// <param name="collection">The TestResultCollection which will host the result.</param> private static TestResult ParseTestResult(XPathNavigator node, TestUnit unit, TestResultCollection collection) { TestResult result = new TestResult(collection); result.Unit = unit; result.Result = ParseResultType(node.GetAttribute(Xml.Result, string.Empty)); result.AssertionsPassed = uint.Parse(node.GetAttribute(Xml.AssertionsPassed, string.Empty), CultureInfo.InvariantCulture); result.AssertionsFailed = uint.Parse(node.GetAttribute(Xml.AssertionsFailed, string.Empty), CultureInfo.InvariantCulture); result.ExpectedFailures = uint.Parse(node.GetAttribute(Xml.ExpectedFailures, string.Empty), CultureInfo.InvariantCulture); return result; }
/// <summary> /// Adds a child to this TestUnit /// </summary> /// <param name="unit">The unit to add as a child</param> public virtual void AddChild(TestUnit unit) { throw new InvalidOperationException(); }
public override void AddChild(TestUnit unit) { this._children.Add(unit); }
/// <summary> /// Constructor. Initializes this qualified name based on the provided TestUnit. /// </summary> /// <param name="root">The TestUnit from which this qualified name is to be initialized.</param> public QualifiedNameBuilder(TestUnit root) : this() { Initialize(root); }
public void Visit(TestSuite testSuite) { Assert.That(this.ExpectedUnit, Is.TypeOf<TestSuite>()); Assert.That(testSuite.Children.Count(), Is.EqualTo(this.ExpectedUnit.Children.Count())); VerifyTestUnit(testSuite, this.ExpectedUnit); var expectedChild = Sort(this.ExpectedUnit.Children).GetEnumerator(); foreach (TestUnit child in Sort(testSuite.Children)) { expectedChild.MoveNext(); this.ExpectedUnit = expectedChild.Current; child.Apply(this); this.ExpectedUnit = this.ExpectedUnit.Parent; } }
private bool Check(TestUnit unit) { bool match = (unit.FullyQualifiedName == this.FullyQualifiedName); if (match) { this.Unit = unit; } return match; }
/// <summary> /// States the number of test suites for the provided test unit (including itself) /// </summary> /// <param name="root">The root test unit from which to start enumerating test suites</param> /// <returns>The number of test suites for the provided test unit</returns> private uint GetTestSuiteCount(TestUnit root) { TestSuiteCounter counter = new TestSuiteCounter(); root.Apply(counter); return counter.Count; }
/// <summary> /// Asserts test suite details /// </summary> /// <param name="unit">The test suite to test</param> /// <param name="id">The expected Id of the test suite</param> /// <param name="parent">The expected parent of the test suite</param> private void AssertTestSuite(TestUnit unit, int id, TestUnit parent) { AssertTestUnit(unit, typeof(TestSuite), id, parent); }
/// <summary> /// Constructor /// </summary> /// <param name="expected">The expected root test unit hierarchy which is to be compared against</param> private FrameworkEqualityVisitor(TestUnit expected) { this.ExpectedUnit = expected; }
/// <summary> /// Verifies that both test units are equal /// </summary> /// <param name="actual">The actual TestUnit to be compared against</param> /// <param name="expected">The expected TestUnit 'actual' should match</param> private static void VerifyTestUnit(TestUnit actual, TestUnit expected) { Assert.That(actual.Name, Is.EqualTo(expected.Name)); Assert.That(actual.Id, Is.EqualTo(expected.Id)); Assert.That(actual.Labels, Is.EquivalentTo(expected.Labels)); if (expected.Source != null) { VerifySoureFileInfo(actual.Source, expected.Source); } else { Assert.That(actual.Source, Is.Null); } }
private static string GetTestResultMessageText(TestUnit unit, LogEntry entry) { Code.Require(unit, "unit"); Code.Require(entry, "entry"); if ((entry is LogEntryStandardOutputMessage) || (entry is LogEntryStandardErrorMessage)) { return entry.Detail.TrimEnd() + Environment.NewLine; } StringBuilder sb = new StringBuilder(); if (entry.Source != null) { AppendSourceInfo(entry.Source, sb); } sb.Append(entry.ToString().ToLowerInvariant()). Append(" in \""). Append(unit.Name). Append("\""); LogEntryMemoryLeak memoryLeak = entry as LogEntryMemoryLeak; if (memoryLeak == null) { sb.Append(": ").Append(entry.Detail.TrimEnd()); } LogEntryException exception = entry as LogEntryException; if (exception != null) { FormatException(exception, sb); } LogEntryError error = entry as LogEntryError; if (error != null) { FormatError(error, sb); } if (memoryLeak != null) { FormatMemoryLeak(memoryLeak, sb); } // Append NewLine so that log entries are listed one per line return sb.Append(Environment.NewLine).ToString(); }
public void Visit(TestSuite testSuite) { Assert.That(this.ExpectedUnit, Is.TypeOf<TestSuite>()); Assert.That(testSuite.Children.Count(), Is.EqualTo(this.ExpectedUnit.Children.Count())); VerifyTestUnit(testSuite, this.ExpectedUnit); foreach (TestUnit child in testSuite.Children) { this.ExpectedUnit = child; child.Apply(this); this.ExpectedUnit = child.Parent; } this.ExpectedUnit = this.ExpectedUnit.Parent; }
/// <summary> /// Asserts test case details /// </summary> /// <param name="unit">The test case to test</param> /// <param name="id">The expected Id of the test case</param> /// <param name="info">The expected source file information of the test case</param> /// <param name="parent">The expected parent of the test case</param> private void AssertTestCase(TestUnit unit, int id, SourceFileInfo info, TestUnit parent) { AssertTestUnit(unit, typeof(TestCase), id, parent); TestCase test = ((TestCase) unit); Assert.That(test.Children, Is.Empty); SourceFileInfo unitInfo = test.Source; if (info == null) { Assert.That(unitInfo, Is.Null); } else { Assert.That(unitInfo.File, Is.EqualTo(info.File)); Assert.That(unitInfo.LineNumber, Is.EqualTo(info.LineNumber)); } }
/// <summary> /// Asserts test unit details /// </summary> /// <param name="unit">The test unit to test</param> /// <param name="type">The expected type of the test unit</param> /// <param name="id">The expected Id of the test unit</param> /// <param name="parent">The expected parent of the test unit</param> private void AssertTestUnit(TestUnit unit, Type type, int id, TestUnit parent) { Assert.That(unit, Is.Not.Null); Assert.That(unit, Is.TypeOf(type)); Assert.That(unit.Id, Is.EqualTo(id)); Assert.That(unit.Parent, Is.EqualTo(parent)); }
private static string GetTestResultMessageText(TestUnit unit, LogEntry entry) { if ((entry is LogEntryStandardOutputMessage) || (entry is LogEntryStandardErrorMessage)) { return entry.Detail.TrimEnd() + Environment.NewLine; } StringBuilder sb = new StringBuilder(); if (entry.Source != null) { AppendSourceInfo(entry.Source, sb); } sb.Append(entry.ToString().ToLowerInvariant()). Append(" in \""). Append(unit.Name). Append("\""); LogEntryMemoryLeak memoryLeak = entry as LogEntryMemoryLeak; if (memoryLeak == null) { sb.Append(": ").Append(entry.Detail.TrimEnd()); } LogEntryException exception = entry as LogEntryException; if (exception != null) { if (exception.LastCheckpoint != null) { sb.Append(Environment.NewLine); AppendSourceInfo(exception.LastCheckpoint, sb); sb.Append("last checkpoint: ").Append(exception.CheckpointDetail); } } if (memoryLeak != null) { if ((memoryLeak.LeakSourceFilePath != null) && (memoryLeak.LeakSourceFileName != null)) { sb.Append("source file path leak detected at :"). Append(memoryLeak.LeakSourceFilePath). Append(memoryLeak.LeakSourceFileName); } if (memoryLeak.LeakLineNumber != null) { sb.Append(", "). Append("Line number: "). Append(memoryLeak.LeakLineNumber); } sb.Append(", "). Append("Memory allocation number: "). Append(memoryLeak.LeakMemoryAllocationNumber); sb.Append(", "). Append("Leak size: "). Append(memoryLeak.LeakSizeInBytes). Append(" byte"); if (memoryLeak.LeakSizeInBytes > 0) { sb.Append('s'); } sb.Append(Environment.NewLine). Append(memoryLeak.LeakLeakedDataContents); } // Append NewLine so that log entries are listed one per line return sb.Append(Environment.NewLine).ToString(); }
/// <summary> /// Looks up a test unit by fully qualified name /// </summary> /// <param name="root">The root test unit from which to start searching</param> /// <param name="fullyQualifiedName">The fully qualified name of the test unit to look for</param> /// <returns>The test unit with the requested fully qualified name or null if it cannot be found</returns> private TestUnit Lookup(TestUnit root, string fullyQualifiedName) { TestUnitLookup lookup = new TestUnitLookup(fullyQualifiedName); root.Apply(lookup); return lookup.Unit; }
/// <summary> /// Pushes the test unit on this structure. /// </summary> /// <param name="unit">The test unit to push</param> /// <returns>this</returns> public QualifiedNameBuilder Push(TestUnit unit) { Utility.Code.Require(unit, "unit"); return this.Push(unit.Name); }
/// <summary> /// Determine the Boost.Test.TestUnit test case for which this BoostTestResult is associated with. /// </summary> /// <param name="unit">The Boost.Test.TestUnit test case to associate with the generated result</param> /// <returns>this</returns> public BoostTestResultBuilder For(TestUnit unit) { this.Unit = unit; return this; }
/// <summary> /// Constructor /// </summary> /// <param name="expected">The expected root test unit hierarchy which is to be compared against</param> private FrameworkEqualityVisitor(TestUnit expected, bool respectOrder = true) { this.ExpectedUnit = expected; this.OrderRespected = respectOrder; }