/// <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 test result collection which will host the result.</param>
private static void ParseTestCaseLog(XmlNode node, QualifiedNameBuilder path, IDictionary <string, TestResult> collection)
{
// Temporarily push TestCase on TestSuite name builder to acquire the fully qualified name of the TestCase
path.Push(node.Attributes[Xml.Name].Value);
var currentPath = path.ToString();
// Acquire result record of this TestCase
TestResult result = null;
if (!collection.TryGetValue(currentPath, out result))
{
result = new TestResult(collection);
collection[currentPath] = 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>
/// 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>
/// Parses a TestSuite log node.
/// </summary>
/// <param name="node">The TestSuite Xml node to parse.</param>
/// <param name="path">The QualifiedNameBuilder which hosts the current fully qualified path.</param>
/// <param name="collection">The test result collection which will host the result.</param>
private static void ParseTestSuiteLog(XmlNode node, QualifiedNameBuilder path, IDictionary <string, TestResult> collection)
{
path.Push(node.Attributes[Xml.Name].Value);
ParseTestUnitsLog(node.ChildNodes, path, collection);
path.Pop();
}
/// <summary>
/// Asserts general test details for the provided test case
/// </summary>
/// <param name="vsTest">The test case to test</param>
/// <param name="fqn">The expected test case fully qualified name</param>
/// <param name="source">The expected test case source</param>
private void AssertTestDetails(VSTestCase vsTest, QualifiedNameBuilder fqn, string source)
{
Assert.That(vsTest, Is.Not.Null);
Assert.That(vsTest.DisplayName, Is.EqualTo(fqn.Peek()));
Assert.That(vsTest.ExecutorUri, Is.EqualTo(BoostTestExecutor.ExecutorUri));
Assert.That(vsTest.Source, Is.EqualTo(source));
string suite = fqn.Pop().ToString();
if (string.IsNullOrEmpty(suite))
{
suite = QualifiedNameBuilder.DefaultMasterTestSuiteName;
}
Assert.That(vsTest.Traits.Where((trait) => (trait.Name == VSTestModel.TestSuiteTrait) && (trait.Value == suite)).Count(), Is.EqualTo(1));
}
/// <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>
/// Given a fully qualified name of a <b>test case</b>, generates the respective test unit hierarchy.
/// </summary>
/// <param name="fullyQualifiedName">The fully qualified name of the <b>test case</b></param>
/// <returns>The test case hierarchy represented by the provided fully qualified name</returns>
/// <remarks>The parameter 'fullyQualifiedName' will be modified and emptied in due process</remarks>
private static TestCase FromFullyQualifiedName(QualifiedNameBuilder fullyQualifiedName)
{
// Reverse the fully qualified name stack i.e. Master Test Suite should be first element and Test Case should be last element
Stack <string> hierarchy = new Stack <string>();
while (fullyQualifiedName.Peek() != null)
{
hierarchy.Push(fullyQualifiedName.Peek());
fullyQualifiedName.Pop();
}
TestSuite parent = null;
// Treat each entry (except for the last) as a test suite
while (hierarchy.Count > 1)
{
parent = new TestSuite(hierarchy.Peek(), parent);
hierarchy.Pop();
}
// Treat the last entry as a test case
return((hierarchy.Count == 1) ? new TestCase(hierarchy.Peek(), parent) : null);
}
private static void DiscoverBoostTests(CppSourceFile cppSourceFile, string source, ITestCaseDiscoverySink discoverySink)
{
string[] code = cppSourceFile.SourceCode.TrimEnd(new[] { ' ', '\n', '\r' }).Split('\n');
SourceFileInfo sourceInfo = new SourceFileInfo(cppSourceFile.FileName, 0);
QualifiedNameBuilder suite = new QualifiedNameBuilder();
// Push the equivalent of the Master Test Suite
suite.Push(QualifiedNameBuilder.DefaultMasterTestSuiteName);
var templateLists = new Dictionary <string, IEnumerable <string> >();
for (sourceInfo.LineNumber = 1; sourceInfo.LineNumber <= code.Length; ++sourceInfo.LineNumber)
{
string line = code[sourceInfo.LineNumber - 1];
string[] splitMacro = SplitMacro(line);
string desiredMacro = splitMacro[0].Trim();
switch (desiredMacro)
{
case Constants.TypedefListIdentifier:
case Constants.TypedefMplListIdentifier:
case Constants.TypedefBoostMplListIdentifier:
{
var templateList = ParseTemplateList(splitMacro);
templateLists.Add(templateList.Key, templateList.Value);
break;
}
case Constants.TestCaseTemplateIdentifier:
{
var templateTest = ParseTemplateTestCase(splitMacro, templateLists, sourceInfo, code, ref line);
foreach (string testCaseDataType in templateTest.Value)
{
string testCaseNameWithDataType = templateTest.Key + '<' + testCaseDataType + '>';
var testCase = TestCaseUtils.CreateTestCase(source, sourceInfo, suite, testCaseNameWithDataType);
TestCaseUtils.AddTestCase(testCase, discoverySink);
}
break;
}
case Constants.FixtureTestSuiteIdentifier:
case Constants.AutoTestSuiteIdentifier:
{
string suiteName = ParseBeginTestSuite(splitMacro, sourceInfo, code, ref line);
suite.Push(suiteName);
break;
}
case Constants.FixtureTestCaseIdentifier:
case Constants.AutoTestCaseIdentifier:
case Constants.DataTestCaseIdentifier:
{
string testCaseName = ParseTestCase(splitMacro, sourceInfo, code, ref line);
var testCase = TestCaseUtils.CreateTestCase(source, sourceInfo, suite, testCaseName);
TestCaseUtils.AddTestCase(testCase, discoverySink);
break;
}
case Constants.FixtureDataTestCaseIdentifier:
{
string testCaseName = ParseDataTestCaseF(splitMacro, sourceInfo, code, ref line);
var testCase = TestCaseUtils.CreateTestCase(source, sourceInfo, suite, testCaseName);
TestCaseUtils.AddTestCase(testCase, discoverySink);
break;
}
case Constants.AutoTestSuiteEndIdentifier:
{
suite.Pop();
break;
}
default:
break;
}
}
}
