public void CorrectTestsDiscoveryForFIXTURE_TEST_CASE()
{
using (DummySolution solution = new DummySolution(DefaultSource, "BoostFixtureTestCase.cpp"))
{
#region excercise
/** The BoostFixtureTestCase.cpp file consists of 4 test cases: BoostUnitTest1, Fixturetest_case1, Fixturetest_case1 and Fixturetest_case1,
* BOOST_AUTO_TEST_SUITE -> Suit1
* -->BoostUnitTest1
* -->Fixturetest_case1
* -->Fixturetest_case2
* -> Master Suite
* -->Fixturetest_case3
*/
IList<TestCase> testList = DiscoverTests(solution);
#endregion excercise
#region verify
AssertTestDetails(testList[0], QualifiedNameBuilder.FromString("Suit1/BoostUnitTest1"));
AssertTestDetails(testList[1], QualifiedNameBuilder.FromString("Suit1/Fixturetest_case1"));
AssertTestDetails(testList[2], QualifiedNameBuilder.FromString("Suit1/Fixturetest_case2"));
AssertTestDetails(testList[3], QualifiedNameBuilder.FromString("Fixturetest_case3"));
#endregion verify
}
}
public void DiscoverTestsFromMultipleFiles()
{
using (DummySolution solution = new DummySolution(Source, new string[] { BoostFixtureTestSuite, BoostUnitTestSample }))
{
IEnumerable<VSTestCase> tests = Discover(solution);
Assert.That(tests.Count(), Is.EqualTo(13));
AssertBoostFixtureTestSuiteTestDetails(tests, solution);
AssertBoostUnitTestSampleTestDetails(tests, solution);
}
}
/// <summary>
/// Applies the discovery process over the provided DummySolution
/// </summary>
/// <param name="solution">The dummy solution on which to apply test discovery</param>
/// <returns>The list of tests which were discovered from the dummy solution</returns>
private IList<TestCase> DiscoverTests(DummySolution solution)
{
SourceCodeDiscoverer discoverer = new SourceCodeDiscoverer(solution.Provider);
DefaultTestContext context = new DefaultTestContext();
DefaultTestCaseDiscoverySink discoverySink = new DefaultTestCaseDiscoverySink();
ConsoleMessageLogger logger = new ConsoleMessageLogger();
discoverer.DiscoverTests(new[] { solution.Source }, context, logger, discoverySink);
return discoverySink.Tests.ToList();
}
public void DiscoverTests()
{
using (DummySolution solution = new DummySolution(Source, new string[] { BoostUnitTestSample }))
{
IEnumerable<VSTestCase> tests = Discover(solution);
Assert.That(tests.Count(), Is.EqualTo(6));
AssertBoostUnitTestSampleTestDetails(tests, solution);
// NOTE BoostUnitTest123 should not be available since it is commented out
Assert.That(tests.Any((test) => test.FullyQualifiedName == "BoostUnitTest123"), Is.False);
}
}
public void BOOST_DATA_TEST_CASEDiscovery()
{
using (DummySolution solution = new DummySolution(DefaultSource, "BoostDataTestCase.cpp"))
{
IList<TestCase> testList = DiscoverTests(solution);
Assert.That(testList.Count, Is.EqualTo(3));
AssertTestDetails(testList[0], QualifiedNameBuilder.FromString("data_test_suite/data_1"));
AssertTestDetails(testList[1], QualifiedNameBuilder.FromString("data_test_suite/data_2"));
AssertTestDetails(testList[2], QualifiedNameBuilder.FromString("data_3"));
}
}
public void CorrectDiscoveryGenericBoostTests()
{
using (DummySolution solution = new DummySolution(DefaultSource, "BoostUnitTestSample.cpp"))
{
#region excercise
IList<TestCase> tests = DiscoverTests(solution);
#endregion excercise
#region verify
AssertTestDetails(tests.Last(), QualifiedNameBuilder.FromString("my_test<char>"), solution.SourceFileResourcePaths.First().TempSourcePath, 33);
#endregion verify
}
}
/// <summary>
/// Applies the discovery process over the provided DummySolution
/// </summary>
/// <param name="solution">The dummy solution on which to apply test discovery</param>
/// <returns>The list of tests which were discovered from the dummy solution</returns>
private IList<TestCase> DiscoverTests(DummySolution solution)
{
DefaultTestCaseDiscoverySink discoverySink = new DefaultTestCaseDiscoverySink();
ISourceFilter[] filters = new ISourceFilter[]
{
new QuotedStringsFilter(),
new MultilineCommentFilter(),
new SingleLineCommentFilter(),
new ConditionalInclusionsFilter(new ExpressionEvaluation())
};
SourceCodeDiscoverer discoverer = new SourceCodeDiscoverer(solution.Provider);
discoverer.DiscoverTests(new []{solution.Source}, new DefaultTestContext(true), new ConsoleMessageLogger(), discoverySink);
return discoverySink.Tests.ToList();
}
public void CorrectTestsDiscoveryForFIXTURE_TEST_SUITE()
{
using (DummySolution solution = new DummySolution(DefaultSource, "BoostFixtureTestSuite.cpp"))
{
#region exercise
/** The BoostFixtureSuiteTest.cpp file consists of 3 test cases: FixtureTest1, FixtureTest2 and BoostTest,
* BOOST_FIXTURE_TEST_SUITE -> FixtureSuite1
* -->BoostTest1
* -->BoostTest2
* -> Master Suite
* -->BoostTest3
* BOOST_FIXTURE_TEST_SUITE -> FixtureSuite2
* -->Fixturetest_case1
* -->TemplatedTest<int> (BOOST_AUTO_TEST_CASE_TEMPLATE)
* -->TemplatedTest<long> (BOOST_AUTO_TEST_CASE_TEMPLATE)
* -->TemplatedTest<char> (BOOST_AUTO_TEST_CASE_TEMPLATE)
*/
IList<TestCase> testList = DiscoverTests(solution);
#endregion exercise
#region verification
AssertTestDetails(testList[0], QualifiedNameBuilder.FromString("FixtureSuite1/BoostTest1"));
AssertTestDetails(testList[1], QualifiedNameBuilder.FromString("FixtureSuite1/BoostTest2"));
AssertTestDetails(testList[2], QualifiedNameBuilder.FromString("BoostTest3"));
AssertTestDetails(testList[3], QualifiedNameBuilder.FromString("FixtureSuite2/Fixturetest_case1"));
AssertTestDetails(testList[4], QualifiedNameBuilder.FromString("FixtureSuite2/TemplatedTest<int>"));
AssertTestDetails(testList[5], QualifiedNameBuilder.FromString("FixtureSuite2/TemplatedTest<long>"));
AssertTestDetails(testList[6], QualifiedNameBuilder.FromString("FixtureSuite2/TemplatedTest<char>"));
#endregion verification
}
}
/// <summary>
/// Applies the discovery process over the provided DummySolution
/// </summary>
/// <param name="solution">The dummy solution on which to apply test discovery</param>
/// <returns>The list of tests which were discovered from the dummy solution</returns>
private IList<TestCase> DiscoverTests(DummySolution solution)
{
DefaultTestCaseDiscoverySink discoverySink = new DefaultTestCaseDiscoverySink();
ISourceFilter[] filters = new ISourceFilter[]
{
new QuotedStringsFilter(),
new MultilineCommentFilter(),
new SingleLineCommentFilter(),
new ConditionalInclusionsFilter(new ExpressionEvaluation())
};
BoostTestDiscovererInternal discoverer = new BoostTestDiscovererInternal(solution.Provider, filters);
IDictionary<string, ProjectInfo> solutionInfo = discoverer.PrepareTestCaseData(new string[] { solution.Source });
discoverer.GetBoostTests(solutionInfo, discoverySink);
return discoverySink.Tests.ToList();
}
/// <summary>
/// Applies the discovery procedure over the dummy solution
/// </summary>
/// <param name="solution">A dummy solution from which to discover tests from</param>
/// <param name="context">The IDiscoveryContext to use</param>
/// <returns>An enumeration of discovered test cases</returns>
private IEnumerable<VSTestCase> Discover(DummySolution solution, IDiscoveryContext context)
{
return Discover(solution.Provider, new string[] { solution.Source }, context);
}
/// <summary>
/// Applies the discovery procedure over the dummy solution
/// </summary>
/// <param name="solution">A dummy solution from which to discover tests from</param>
/// <returns>An enumeration of discovered test cases</returns>
private IEnumerable<VSTestCase> Discover(DummySolution solution)
{
return Discover(solution.Provider, new string[] { solution.Source });
}
/// <summary>
/// Asserts test details for tests contained within the "BoostUnitTestSample.cpp" source file
/// </summary>
/// <param name="tests">The discovered test case enumeration</param>
/// <param name="solution">The dummy solution which contains a project referencing "BoostUnitTestSample.cpp"</param>
private void AssertBoostUnitTestSampleTestDetails(IEnumerable<VSTestCase> tests, DummySolution solution)
{
DummySourceFile codeFile = solution.SourceFileResourcePaths.First((source) => source.TempSourcePath.EndsWith(BoostUnitTestSample));
AssertBoostUnitTestSampleTestDetails(tests, solution.Source, codeFile.TempSourcePath);
}
public void DiscoverTestsUsingRunSettings()
{
using (DummySolution solution = new DummySolution(Source, new string[] { BoostUnitTestSampleRequiringUseOfFilters }))
{
DefaultTestContext context = new DefaultTestContext();
context.RegisterSettingProvider(BoostTestAdapterSettings.XmlRootName, new BoostTestAdapterSettingsProvider());
context.LoadEmbeddedSettings("BoostTestAdapterNunit.Resources.Settings.conditionalIncludesDisabled.runsettings");
IEnumerable<VSTestCase> vsTests = Discover(solution, context);
Assert.That(vsTests.Count(), Is.EqualTo(8));
AssertBoostUnitTestSampleRequiringUseOfFilters(vsTests, solution);
VSTestCase testConditional = AssertTestDetails(vsTests, QualifiedNameBuilder.FromString("BoostUnitTestShouldNotAppear3"), Source);
AssertSourceDetails(testConditional, solution.SourceFileResourcePaths.First().TempSourcePath, 47);
}
}
public void DiscoverTestsFromSourceFileRequiringUseOfFilters()
{
using (DummySolution solution = new DummySolution(Source, new string[] { BoostUnitTestSampleRequiringUseOfFilters }))
{
IEnumerable<VSTestCase> vsTests = Discover(solution);
Assert.That(vsTests.Count(), Is.EqualTo(7));
AssertBoostUnitTestSampleRequiringUseOfFilters(vsTests, solution);
}
}
private void AssertBoostUnitTestSampleRequiringUseOfFilters(IEnumerable<VSTestCase> tests, DummySolution solution)
{
DummySourceFile codeFile = solution.SourceFileResourcePaths.First((source) => source.Path.EndsWith(BoostUnitTestSampleRequiringUseOfFilters));
AssertBoostUnitTestSampleRequiringUseOfFilters(tests, solution.Source, codeFile.Path);
}
public void MultilineBoostMacroDefinitions()
{
using (DummySolution solution = new DummySolution(DefaultSource, "BoostMultiLineDefinitions.cpp"))
{
IList<TestCase> testList = DiscoverTests(solution);
AssertTestDetails(testList[0], QualifiedNameBuilder.FromString("AutoSuite/TestA"));
AssertTestDetails(testList[1], QualifiedNameBuilder.FromString("AutoSuite/TestB"));
AssertTestDetails(testList[2], QualifiedNameBuilder.FromString("AutoSuite/TestC"));
AssertTestDetails(testList[3], QualifiedNameBuilder.FromString("AutoSuite/FixtureSuite/TestD"));
}
}
