/// <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();
        }
Example #15
0
 /// <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 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));
            }
        }
 public override void AddChild(TestUnit unit)
 {
     this._children.Add(unit);
 }
 /// <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;
 }