/// <summary>
/// Parses a TestCase node.
/// </summary>
/// <param name="node">The XPathNavigator pointing to a TestCase node.</param>
/// <param name="parent">The parent TestSuite to which TestUnits are attached to.</param>
/// <param name="collection">The TestResultCollection which will host the result.</param>
private static void ParseTestCaseReport(XPathNavigator node, TestSuite parent, TestResultCollection collection)
{
QualifiedNameBuilder fullname = new QualifiedNameBuilder(parent);
fullname.Push(node.GetAttribute(Xml.Name, string.Empty));
TestCase testCase = null;
// If the test is already available, reuse it
TestResult current = collection[fullname.ToString()];
if (current != null)
{
testCase = current.Unit as TestCase;
}
// Else construct and add it to the appropriate parent
if (testCase == null)
{
testCase = new TestCase(fullname.Peek(), parent);
}
TestResult result = ParseTestResult(node, testCase, collection);
// Aggregate results. Common use-case in BOOST_DATA_TEST_CASE.
collection[fullname.ToString()] = Aggregate(result, current);
}
/// <summary>
/// Parses a TestCase log node.
/// </summary>
/// <param name="node">The TestCase Xml node to parse.</param>
/// <param name="path">The QualifiedNameBuilder which hosts the current fully qualified path.</param>
/// <param name="collection">The TestResultCollection which will host the result.</param>
private static void ParseTestCaseLog(XmlNode node, QualifiedNameBuilder path, TestResultCollection collection)
{
// Temporarily push TestCase on TestSuite name builder to acquire the fully qualified name of the TestCase
path.Push(node.Attributes[Xml.Name].Value);
// Acquire result record of this TestCase
TestResult result = collection[path.ToString()];
if (result == null)
{
result = new TestResult(collection);
collection[path.ToString()] = result;
}
// Reset path to original value
path.Pop();
XmlNode testingTime = node.SelectSingleNode(Xml.TestingTime);
if (testingTime != null)
{
// Boost test testing time is listed in microseconds
result.Duration += ulong.Parse(testingTime.InnerText, CultureInfo.InvariantCulture);
}
ParseTestCaseLogEntries(node.ChildNodes, result);
}
/// <summary>
/// Creates a new TestCase object.
/// </summary>
/// <param name="sourceExe">Name of the project executable</param>
/// <param name="sourceInfo">.cpp file path and TestCase line number</param>
/// <param name="suite">The suite in which testcase is present</param>
/// <param name="testCaseName">Name of the testcase</param>
/// <param name="isEnabled">The enabling status of the testcase</param>
/// <returns>The created TestCase object</returns>
public static TestCase CreateTestCase(string sourceExe, SourceFileInfo sourceInfo, QualifiedNameBuilder suite, string testCaseName, bool isEnabled = true)
{
suite.Push(testCaseName);
string qualifiedName = suite.ToString();
suite.Pop();
var testCase = new TestCase(qualifiedName, BoostTestExecutor.ExecutorUri, sourceExe)
{
CodeFilePath = sourceInfo.File,
LineNumber = sourceInfo.LineNumber,
DisplayName = testCaseName,
};
GroupViaTraits(suite.ToString(), testCase, isEnabled);
return(testCase);
}
/// <summary>
/// Asserts general test properties
/// </summary>
/// <param name="tests">The enumeration of discovered tests</param>
/// <param name="qualifiedName">The qualified test name which is to be tested</param>
/// <param name="source">The source from which the test should have been discovered</param>
/// <param name="info">Optional source file information related to the test under question</param>
private void AssertVSTestCaseProperties(IEnumerable <VSTestCase> tests, QualifiedNameBuilder qualifiedName, string source, SourceFileInfo info)
{
VSTestCase test = tests.FirstOrDefault((_test) => (_test.FullyQualifiedName == qualifiedName.ToString()));
Assert.That(test, Is.Not.Null);
Assert.That(test.DisplayName, Is.EqualTo(qualifiedName.Peek()));
Assert.That(test.Source, Is.EqualTo(source));
Assert.That(test.ExecutorUri, Is.EqualTo(BoostTestExecutor.ExecutorUri));
if (info != null)
{
Assert.That(test.CodeFilePath, Is.EqualTo(info.File));
Assert.That(test.LineNumber, Is.EqualTo(info.LineNumber));
}
Assert.That(test.Traits.Count(), Is.EqualTo(1));
Trait trait = test.Traits.First();
Assert.That(trait.Name, Is.EqualTo(VSTestModel.TestSuiteTrait));
string suite = qualifiedName.Pop().ToString();
if (string.IsNullOrEmpty(suite))
{
suite = qualifiedName.MasterTestSuite;
}
Assert.That(trait.Value, Is.EqualTo(suite));
}
/// <summary>
/// Asserts general test details for the test with the requested fully qualified name
/// </summary>
/// <param name="tests">The discovered test case enumeration</param>
/// <param name="fqn">The fully qualified name of the test case to test</param>
/// <param name="source">The expected test case source</param>
/// <returns>The test case which has been tested</returns>
private VSTestCase AssertTestDetails(IEnumerable <VSTestCase> tests, QualifiedNameBuilder fqn, string source)
{
VSTestCase vsTest = tests.FirstOrDefault(test => test.FullyQualifiedName == fqn.ToString());
Assert.That(vsTest, Is.Not.Null);
AssertTestDetails(vsTest, fqn, source);
return(vsTest);
}
