public void CorrectMultipleBoostTestDiscovererDispatchingWithExternalExe()
{
var sources = new[]
{
"ListContentSupport" + BoostTestDiscoverer.ExeExtension,
"ParseSources1" + BoostTestDiscoverer.ExeExtension,
"ParseSources2" + BoostTestDiscoverer.ExeExtension,
"DllProject1" + BoostTestDiscoverer.DllExtension,
"DllProject2" + BoostTestDiscoverer.DllExtension,
};
BoostTestAdapterSettings settings = CreateAdapterSettings();
settings.ExternalTestRunner = CreateExternalRunnerSettings(BoostTestDiscoverer.ExeExtension);
var results = this.DiscovererFactory.GetDiscoverers(sources, settings);
Assert.That(results.Count(), Is.EqualTo(1));
Assert.That(results.FirstOrDefault(x => x.Discoverer is ListContentDiscoverer), Is.Null);
Assert.That(results.FirstOrDefault(x => x.Discoverer is SourceCodeDiscoverer), Is.Null);
Assert.That(results.FirstOrDefault(x => x.Discoverer is ExternalDiscoverer), Is.Not.Null);
var exd = results.First(x => x.Discoverer is ExternalDiscoverer);
Assert.That(exd.Sources, Is.EqualTo(new[] { "ListContentSupport" + BoostTestDiscoverer.ExeExtension,
"ParseSources1" + BoostTestDiscoverer.ExeExtension,
"ParseSources2" + BoostTestDiscoverer.ExeExtension, }));
}
/// <summary>
/// Provides a collection of ISourceFilters based on the provided BoostTestAdapterSettings.
/// </summary>
/// <param name="settings">The BoostTestAdapterSettings</param>
/// <returns>An collection of ISourceFilters based on the provided settings.</returns>
public static ISourceFilter[] Get(BoostTestAdapterSettings settings)
{
Utility.Code.Require(settings, "settings");
if (settings.ConditionalInclusionsFilteringEnabled)
{
return(new ISourceFilter[]
{
new QuotedStringsFilter(),
new MultilineCommentFilter(),
new SingleLineCommentFilter(),
new ConditionalInclusionsFilter(
new ExpressionEvaluation()
)
});
}
else
{
Logger.Warn("Conditional inclusions filtering is disabled.");
return(new ISourceFilter[]
{
new QuotedStringsFilter(),
new MultilineCommentFilter(),
new SingleLineCommentFilter(),
//conditional inclusions filter omitted
});
}
}
/// <summary>
/// Parses the Xml report and log file as specified within the provided
/// BoostTestRunnerCommandLineArgs instance.
/// </summary>
/// <param name="args">The BoostTestRunnerCommandLineArgs which specify the report and log file.</param>
/// <param name="settings">The BoostTestAdapterSettings which specify adapter specific settings.</param>
public void Parse(BoostTestRunnerCommandLineArgs args, BoostTestAdapterSettings settings)
{
IEnumerable <IBoostTestResultOutput> parsers = Enumerable.Empty <IBoostTestResultOutput>();
try
{
parsers = new IBoostTestResultOutput[] {
GetReportParser(args),
GetLogParser(args),
GetStandardOutput(args, settings),
GetStandardError(args, settings)
};
Parse(parsers);
}
finally
{
foreach (IBoostTestResultOutput parser in parsers)
{
if (parser != null)
{
parser.Dispose();
}
}
}
}
public void CorrectSingleProjectBoostTestDiscovererDispatchingExternalDll()
{
BoostTestAdapterSettings settings = CreateAdapterSettings();
settings.ExternalTestRunner = CreateExternalRunnerSettings(BoostTestDiscoverer.DllExtension);
// source that supports --list-content parameter
var source = "ListContentSupport" + BoostTestDiscoverer.ExeExtension;
var discoverer = this.DiscovererFactory.GetDiscoverer(source, settings);
Assert.That(discoverer, Is.Not.Null);
Assert.That(discoverer, Is.AssignableFrom(typeof(ListContentDiscoverer)));
// source that NOT supports --list-content parameter
source = "ParseSources" + BoostTestDiscoverer.ExeExtension;
discoverer = this.DiscovererFactory.GetDiscoverer(source, settings);
Assert.That(discoverer, Is.Not.Null);
Assert.That(discoverer, Is.AssignableFrom(typeof(SourceCodeDiscoverer)));
// source dll project
source = "DllProject" + BoostTestDiscoverer.DllExtension;
discoverer = this.DiscovererFactory.GetDiscoverer(source, settings);
Assert.That(discoverer, Is.Not.Null);
Assert.That(discoverer, Is.AssignableFrom(typeof(ExternalDiscoverer)));
}
public void SetUp()
{
RunnerFactory = A.Fake <IBoostTestRunnerFactory>();
A.CallTo(() => RunnerFactory.GetRunner(A <string> ._, A <BoostTestRunnerFactoryOptions> ._)).Returns(A.Fake <IBoostTestRunner>());
Settings = new BoostTestAdapterSettings();
ArgsBuilder = (string source, BoostTestAdapterSettings settings) => { return(new BoostTestRunnerCommandLineArgs()); };
}
/// <summary>
/// Run tests one test at a time and update results back to framework.
/// </summary>
/// <param name="testBatches">List of test batches to run</param>
/// <param name="runContext">Solution properties</param>
/// <param name="frameworkHandle">Unit test framework handle</param>
private void RunBoostTests(IEnumerable <TestRun> testBatches, IRunContext runContext, IFrameworkHandle frameworkHandle)
{
BoostTestAdapterSettings settings = BoostTestAdapterSettingsProvider.GetSettings(runContext);
foreach (TestRun batch in testBatches)
{
if (_cancelled)
{
break;
}
DateTimeOffset start = new DateTimeOffset(DateTime.Now);
try
{
Logger.Info("{0}: -> [{1}]", ((runContext.IsBeingDebugged) ? "Debugging" : "Executing"), string.Join(", ", batch.Tests));
using (TemporaryFile report = new TemporaryFile(batch.Arguments.ReportFile))
using (TemporaryFile log = new TemporaryFile(batch.Arguments.LogFile))
using (TemporaryFile stdout = new TemporaryFile(batch.Arguments.StandardOutFile))
using (TemporaryFile stderr = new TemporaryFile(batch.Arguments.StandardErrorFile))
{
Logger.Debug("Working directory: {0}", batch.Arguments.WorkingDirectory ?? "(null)");
Logger.Debug("Report file : {0}", batch.Arguments.ReportFile);
Logger.Debug("Log file : {0}", batch.Arguments.LogFile);
Logger.Debug("StdOut file : {0}", batch.Arguments.StandardOutFile ?? "(null)");
Logger.Debug("StdErr file : {0}", batch.Arguments.StandardErrorFile ?? "(null)");
// Execute the tests
if (ExecuteTests(batch, runContext, frameworkHandle))
{
foreach (VSTestResult result in GenerateTestResults(batch, start, settings))
{
// Identify test result to Visual Studio Test framework
frameworkHandle.RecordResult(result);
}
}
}
}
catch (Boost.Runner.TimeoutException ex)
{
foreach (VSTestCase testCase in batch.Tests)
{
VSTestResult testResult = GenerateTimeoutResult(testCase, ex);
testResult.StartTime = start;
frameworkHandle.RecordResult(testResult);
}
}
catch (Exception ex)
{
Logger.Exception(ex, "Exception caught while running test batch {0} [{1}] ({2})", batch.Source, string.Join(", ", batch.Tests), ex.Message);
}
}
}
/// <summary>
/// Determines whether the provided source has --list_content capabilities
/// </summary>
/// <param name="source">The source to test</param>
/// <param name="settings">Test adapter settings</param>
/// <returns>true if the source has list content capabilities; false otherwise</returns>
private bool IsListContentSupported(string source, BoostTestAdapterSettings settings)
{
BoostTestRunnerFactoryOptions options = new BoostTestRunnerFactoryOptions()
{
ExternalTestRunnerSettings = settings.ExternalTestRunner
};
IBoostTestRunner runner = _factory.GetRunner(source, options);
return((runner != null) && runner.ListContentSupported);
}
/// <summary>
/// Retrieves and assigns parameters by resolving configurations from different possible resources
/// </summary>
/// <param name="source">The TestCases source</param>
/// <param name="settings">The Boost Test adapter settings currently in use</param>
/// <returns>A string for the default working directory</returns>
private void GetDebugConfigurationProperties(string source, BoostTestAdapterSettings settings, BoostTestRunnerCommandLineArgs args)
{
try
{
args.SetWorkingEnvironment(source, settings, ((_vsProvider == null) ? null : _vsProvider.Instance));
}
catch (COMException ex)
{
Logger.Exception(ex, "Could not retrieve WorkingDirectory from Visual Studio Configuration-{0}", ex.Message);
}
}
/// <summary>
/// Determines whether the provided source has --list_content capabilities
/// </summary>
/// <param name="source">The source to test</param>
/// <param name="settings">Test adapter settings</param>
/// <returns>true if the source has list content capabilities; false otherwise</returns>
private bool IsListContentSupported(string source, BoostTestAdapterSettings settings)
{
BoostTestRunnerFactoryOptions options = new BoostTestRunnerFactoryOptions()
{
ExternalTestRunnerSettings = settings.ExternalTestRunner
};
IBoostTestRunner runner = _factory.GetRunner(source, options);
// Convention over configuration. Assume test runners utilising such an extension
return((runner != null) && (runner.Source.EndsWith(ForceListContentExtension, StringComparison.OrdinalIgnoreCase) || runner.ListContentSupported));
}
public void ParseSampleSettings()
{
BoostTestAdapterSettings settings = ParseEmbeddedResource("BoostTestAdapterNunit.Resources.Settings.sample.runsettings");
Assert.That(settings.ExecutionTimeoutMilliseconds, Is.EqualTo(600000));
Assert.That(settings.DiscoveryTimeoutMilliseconds, Is.EqualTo(600000));
Assert.That(settings.FailTestOnMemoryLeak, Is.True);
Assert.That(settings.ExternalTestRunner, Is.Not.Null);
Assert.That(settings.ExternalTestRunner.ExtensionType.ToString(), Is.EqualTo(".dll"));
Assert.That(settings.ExternalTestRunner.ExecutionCommandLine.ToString(), Is.EqualTo("C:\\ExternalTestRunner.exe --test {source} "));
}
/// <summary>
/// Compares the serialized content of the settings structure against an Xml embedded resource string.
/// </summary>
/// <param name="settings">The settings structure whose serialization is to be compared</param>
/// <param name="resource">The path to an embedded resource which contains the serialized Xml content to compare against</param>
private void Compare(BoostTestAdapterSettings settings, string resource)
{
XmlElement element = settings.ToXml();
using (Stream stream = TestHelper.LoadEmbeddedResource(resource))
{
XmlDocument doc = new XmlDocument();
doc.Load(stream);
XmlNode root = doc.DocumentElement.SelectSingleNode("/RunSettings/BoostTest");
XmlComparer comparer = new XmlComparer();
comparer.CompareXML(element, root, XmlNodeTypeFilter.DefaultFilter);
}
}
public void SerialiseExternalTestRunnerDiscoveryMapSettings()
{
BoostTestAdapterSettings settings = new BoostTestAdapterSettings();
settings.ExternalTestRunner = new ExternalBoostTestRunnerSettings
{
DiscoveryMethodType = DiscoveryMethodType.DiscoveryFileMap,
ExecutionCommandLine = new CommandLine("C:\\ExternalTestRunner.exe", "--test \"{source}\"")
};
settings.ExternalTestRunner.DiscoveryFileMap.Add("test_1.dll", "C:\\tests\\test_1.xml");
settings.ExternalTestRunner.DiscoveryFileMap.Add("test_2.dll", "C:\\tests\\test_2.xml");
Compare(settings, "BoostTestAdapterNunit.Resources.Settings.externalTestRunner.runsettings");
}
public void SerializeSettings()
{
BoostTestAdapterSettings settings = new BoostTestAdapterSettings();
settings.ExecutionTimeoutMilliseconds = 600000;
settings.DiscoveryTimeoutMilliseconds = 600000;
settings.FailTestOnMemoryLeak = true;
settings.ExternalTestRunner = new ExternalBoostTestRunnerSettings()
{
DiscoveryMethodType = DiscoveryMethodType.DiscoveryCommandLine,
DiscoveryCommandLine = new CommandLine("C:\\ExternalTestRunner.exe", "--test \"{source}\" --list-debug \"{out}\""),
ExecutionCommandLine = new CommandLine("C:\\ExternalTestRunner.exe", "--test \"{source}\"")
};
Compare(settings, "BoostTestAdapterNunit.Resources.Settings.sample.runsettings");
}
/// <summary>
/// Tests the contents of a BoostTestAdapterSettings instance, making sure they comply to the default expected values.
/// </summary>
/// <param name="settings">The BoostTestAdapterSettings instance to test</param>
private void AssertDefaultSettings(BoostTestAdapterSettings settings)
{
Assert.That(settings.ExecutionTimeoutMilliseconds, Is.EqualTo(-1));
Assert.That(settings.DiscoveryTimeoutMilliseconds, Is.EqualTo(30000));
Assert.That(settings.FailTestOnMemoryLeak, Is.False);
Assert.That(settings.ConditionalInclusionsFilteringEnabled, Is.True);
Assert.That(settings.LogLevel, Is.EqualTo(LogLevel.TestSuite));
Assert.That(settings.ExternalTestRunner, Is.Null);
Assert.That(settings.DetectFloatingPointExceptions, Is.False);
Assert.That(settings.CatchSystemErrors, Is.True);
Assert.That(settings.TestBatchStrategy, Is.EqualTo(Strategy.TestCase));
Assert.That(settings.UseListContent, Is.True);
Assert.That(settings.ForceListContent, Is.False);
Assert.That(settings.WorkingDirectory, Is.Null);
Assert.That(settings.EnableStdOutRedirection, Is.True);
Assert.That(settings.EnableStdErrRedirection, Is.True);
Assert.That(settings.Filters, Is.EqualTo(TestSourceFilter.Empty));
}
/// <summary>
/// Provides a test batching strategy based on the provided arguments
/// </summary>
/// <param name="strategy">The base strategy to provide</param>
/// <param name="settings">Adapter settings currently in use</param>
/// <returns>An ITestBatchingStrategy instance or null if one cannot be provided</returns>
private ITestBatchingStrategy GetBatchStrategy(TestBatch.Strategy strategy, BoostTestAdapterSettings settings)
{
TestBatch.CommandLineArgsBuilder argsBuilder = GetDefaultArguments;
if (strategy != Strategy.TestCase)
{
argsBuilder = GetBatchedTestRunsArguments;
}
switch (strategy)
{
case Strategy.Source: return(new SourceTestBatchStrategy(this._testRunnerFactory, settings, argsBuilder));
case Strategy.TestSuite: return(new TestSuiteTestBatchStrategy(this._testRunnerFactory, settings, argsBuilder));
case Strategy.TestCase: return(new IndividualTestBatchStrategy(this._testRunnerFactory, settings, argsBuilder));
}
return(null);
}
/// <summary>
/// Factory function which returns an appropriate BoostTestRunnerCommandLineArgs structure
/// </summary>
/// <param name="source">The TestCases source</param>
/// <param name="settings">The Boost Test adapter settings currently in use</param>
/// <returns>A BoostTestRunnerCommandLineArgs structure for the provided source</returns>
private BoostTestRunnerCommandLineArgs GetDefaultArguments(string source, BoostTestAdapterSettings settings)
{
BoostTestRunnerCommandLineArgs args = settings.CommandLineArgs.Clone();
GetDebugConfigurationProperties(source, settings, args);
// Specify log and report file information
args.LogFormat = OutputFormat.XML;
args.LogLevel = settings.LogLevel;
args.LogFile = TestPathGenerator.Generate(source, FileExtensions.LogFile);
args.ReportFormat = OutputFormat.XML;
args.ReportLevel = ReportLevel.Detailed;
args.ReportFile = TestPathGenerator.Generate(source, FileExtensions.ReportFile);
args.StandardOutFile = ((settings.EnableStdOutRedirection) ? TestPathGenerator.Generate(source, FileExtensions.StdOutFile) : null);
args.StandardErrorFile = ((settings.EnableStdErrRedirection) ? TestPathGenerator.Generate(source, FileExtensions.StdErrFile) : null);
return(args);
}
public Type TestDiscovererProvisioning(string source, string externalExtension)
{
ExternalBoostTestRunnerSettings externalSettings = null;
if (!string.IsNullOrEmpty(externalExtension))
{
externalSettings = new ExternalBoostTestRunnerSettings {
ExtensionType = new Regex(externalExtension)
};
}
BoostTestAdapterSettings settings = new BoostTestAdapterSettings()
{
ExternalTestRunner = externalSettings
};
IBoostTestDiscoverer discoverer = this.DiscovererFactory.GetDiscoverer(source, settings);
return((discoverer == null) ? null : discoverer.GetType());
}
public void ParseComplexSettings()
{
BoostTestAdapterSettings settings = ParseEmbeddedResource("BoostTestAdapterNunit.Resources.Settings.sample.2.runsettings");
Assert.That(settings.ExecutionTimeoutMilliseconds, Is.EqualTo(100));
Assert.That(settings.DiscoveryTimeoutMilliseconds, Is.EqualTo(100));
Assert.That(settings.CatchSystemErrors, Is.False);
Assert.That(settings.DetectFloatingPointExceptions, Is.True);
Assert.That(settings.TestBatchStrategy, Is.EqualTo(Strategy.TestSuite));
Assert.That(settings.RunDisabledTests, Is.True);
Assert.That(settings.Filters, Is.Not.Null);
Assert.That(settings.Filters.Include, Is.Not.Empty);
Assert.That(settings.Filters.Include, Is.EquivalentTo(new[] { "mytest.exe$" }));
Assert.That(settings.Filters.Exclude, Is.Not.Empty);
Assert.That(settings.Filters.Exclude, Is.EquivalentTo(new[] { "test.exe$" }));
}
/// <summary>
/// Execute the tests one by one. Run Selected
/// </summary>
/// <param name="tests">Testcases object</param>
/// <param name="runContext">Solution properties</param>
/// <param name="frameworkHandle">Unit test framework handle</param>
/// <remarks>Entry point of the execution procedure whenever the user requests to run one or a specific lists of tests</remarks>
public void RunTests(IEnumerable <VSTestCase> tests, IRunContext runContext, IFrameworkHandle frameworkHandle)
{
Code.Require(tests, "tests");
Code.Require(runContext, "runContext");
Code.Require(frameworkHandle, "frameworkHandle");
SetUp(frameworkHandle);
Logger.Debug("IRunContext.IsDataCollectionEnabled: {0}", runContext.IsDataCollectionEnabled);
Logger.Debug("IRunContext.RunSettings.SettingsXml: {0}", runContext.RunSettings.SettingsXml);
BoostTestAdapterSettings settings = BoostTestAdapterSettingsProvider.GetSettings(runContext);
// Batch tests into grouped runs based on test source and test suite so that we minimize symbol reloading
//
// NOTE Required batching at test suite level since Boost Unit Test Framework command-line arguments only allow
// multiple test name specification for tests which reside in the same test suite
//
// NOTE For code-coverage speed is given preference over adapter responsiveness.
TestBatch.Strategy strategy = ((runContext.IsDataCollectionEnabled) ? TestBatch.Strategy.TestSuite : settings.TestBatchStrategy);
// Source strategy is invalid in such context since explicit tests are chosen. TestSuite is used instead.
if (strategy == Strategy.Source)
{
strategy = Strategy.TestSuite;
}
ITestBatchingStrategy batchStrategy = GetBatchStrategy(strategy, settings, runContext);
if (batchStrategy == null)
{
Logger.Error("No valid test batching strategy was found. Tests skipped.");
}
else
{
// NOTE Apply distinct to avoid duplicate test cases. Common issue when using BOOST_DATA_TEST_CASE.
IEnumerable <TestRun> batches = batchStrategy.BatchTests(tests.Distinct(new TestCaseComparer()));
RunBoostTests(batches, runContext, frameworkHandle);
}
TearDown();
}
/// <summary>
/// Retrieves and assigns parameters by resolving configurations from different possible resources
/// </summary>
/// <param name="source">The TestCases source</param>
/// <param name="settings">The Boost Test adapter settings currently in use</param>
/// <returns>A string for the default working directory</returns>
private void GetDebugConfigurationProperties(string source, BoostTestAdapterSettings settings, BoostTestRunnerCommandLineArgs args)
{
try
{
var vs = _vsProvider?.Instance;
if (vs != null)
{
Logger.Debug("Connected to Visual Studio {0} instance", vs.Version);
}
args.SetWorkingEnvironment(source, settings, vs);
}
catch (ROTException ex)
{
Logger.Exception(ex, "Could not retrieve WorkingDirectory from Visual Studio Configuration");
}
catch (COMException ex)
{
Logger.Exception(ex, "Could not retrieve WorkingDirectory from Visual Studio Configuration-{0}", ex.Message);
}
}
/// <summary>
/// Filters out any tests which are not intended to run
/// </summary>
/// <param name="settings">Adapter settings which determines test filtering</param>
/// <param name="tests">The entire test corpus</param>
/// <returns>A test corpus which contains only the test which are intended to run</returns>
private static IEnumerable <VSTestCase> GetTestsToRun(BoostTestAdapterSettings settings, IEnumerable <VSTestCase> tests)
{
IEnumerable <VSTestCase> testsToRun = tests;
if (!settings.RunDisabledTests)
{
testsToRun = tests.Where((test) =>
{
foreach (var trait in test.Traits)
{
if ((trait.Name == VSTestModel.StatusTrait) && (trait.Value == VSTestModel.TestEnabled))
{
return(true);
}
}
return(false);
});
}
return(testsToRun);
}
/// <summary>
/// Provides a test batching strategy based on the provided arguments
/// </summary>
/// <param name="strategy">The base strategy to provide</param>
/// <param name="settings">Adapter settings currently in use</param>
/// <param name="runContext">The RunContext for this TestCase. Determines whether the test should be debugged or not.</param>
/// <returns>An ITestBatchingStrategy instance or null if one cannot be provided</returns>
private ITestBatchingStrategy GetBatchStrategy(TestBatch.Strategy strategy, BoostTestAdapterSettings settings, IRunContext runContext)
{
TestBatch.CommandLineArgsBuilder argsBuilder = (string _source, BoostTestAdapterSettings _settings) =>
{
return(GetDefaultArguments(_source, _settings, runContext.IsBeingDebugged));
};
if (strategy != Strategy.TestCase)
{
// Disable stdout, stderr and memory leak detection since it is difficult
// to distinguish from which test does portions of the output map to
argsBuilder = (string _source, BoostTestAdapterSettings _settings) =>
{
var args = GetDefaultArguments(_source, _settings, runContext.IsBeingDebugged);
// Disable standard error/standard output capture
args.StandardOutFile = null;
args.StandardErrorFile = null;
// Disable memory leak detection
args.DetectMemoryLeaks = 0;
return(args);
};
}
switch (strategy)
{
case Strategy.Source: return(new SourceTestBatchStrategy(_testRunnerFactory, settings, argsBuilder));
case Strategy.TestSuite: return(new TestSuiteTestBatchStrategy(_testRunnerFactory, settings, argsBuilder));
case Strategy.TestCase: return(new IndividualTestBatchStrategy(_testRunnerFactory, settings, argsBuilder));
case Strategy.One: return(new OneShotTestBatchStrategy(_testRunnerFactory, settings, argsBuilder));
}
return(null);
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, ITestCaseDiscoverySink discoverySink)
{
if (sources == null)
{
return;
}
BoostTestAdapterSettings settings = BoostTestAdapterSettingsProvider.GetSettings(discoveryContext);
try
{
// Filter out any sources which are not of interest
if (!TestSourceFilter.IsNullOrEmpty(settings.Filters))
{
sources = sources.Where(settings.Filters.ShouldInclude);
}
var results = _boostTestDiscovererFactory.GetDiscoverers(sources.ToList(), settings);
if (results == null)
{
return;
}
// Test discovery
foreach (var discoverer in results)
{
if (discoverer.Sources.Count > 0)
{
Logger.Info("Discovering ({0}): -> [{1}]", discoverer.Discoverer.GetType().Name, string.Join(", ", discoverer.Sources));
discoverer.Discoverer.DiscoverTests(discoverer.Sources, discoveryContext, discoverySink);
}
}
}
catch (Exception ex)
{
Logger.Exception(ex, "Exception caught while discovering tests: {0} ({1})", ex.Message, ex.HResult);
}
}
public void ParseExternalTestRunnerDiscoveryMapSettings()
{
BoostTestAdapterSettings settings = Parse("BoostTestAdapterNunit.Resources.Settings.externalTestRunner.runsettings");
Assert.That(settings.ExecutionTimeoutMilliseconds, Is.EqualTo(-1));
Assert.That(settings.DiscoveryTimeoutMilliseconds, Is.EqualTo(30000));
Assert.That(settings.FailTestOnMemoryLeak, Is.False);
Assert.That(settings.ConditionalInclusionsFilteringEnabled, Is.True);
Assert.That(settings.LogLevel, Is.EqualTo(LogLevel.TestSuite));
Assert.That(settings.ExternalTestRunner, Is.Not.Null);
Assert.That(settings.ExternalTestRunner.ExtensionType.ToString(), Is.EqualTo(".dll"));
Assert.That(settings.ExternalTestRunner.DiscoveryMethodType, Is.EqualTo(DiscoveryMethodType.DiscoveryFileMap));
IDictionary <string, string> fileMap = new Dictionary <string, string>
{
{ "test_1.dll", "C:\\tests\\test_1.xml" },
{ "test_2.dll", "C:\\tests\\test_2.xml" }
};
Assert.That(settings.ExternalTestRunner.DiscoveryFileMap, Is.EqualTo(fileMap));
Assert.That(settings.ExternalTestRunner.ExecutionCommandLine.ToString(), Is.EqualTo("C:\\ExternalTestRunner.exe --test {source} "));
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, ITestCaseDiscoverySink discoverySink)
{
Code.Require(sources, "sources");
Code.Require(discoverySink, "discoverySink");
BoostTestAdapterSettings settings = BoostTestAdapterSettingsProvider.GetSettings(discoveryContext);
_sourceFilters = SourceFilterFactory.Get(settings);
IDictionary <string, ProjectInfo> solutioninfo = null;
var numberOfAttempts = 100;
// try several times to overcome "Application is Busy" COMException
while (numberOfAttempts > 0)
{
try
{
solutioninfo = PrepareTestCaseData(sources);
// set numberOfAttempts = 0, because there is no need to try again,
// since obviously no exception was thrown at this point
numberOfAttempts = 0;
}
catch (COMException)
{
--numberOfAttempts;
// re-throw after all attempts have failed
if (numberOfAttempts == 0)
{
throw;
}
}
}
GetBoostTests(solutioninfo, discoverySink);
}
/// <summary>
/// Factory function which returns an appropriate BoostTestRunnerCommandLineArgs structure
/// </summary>
/// <param name="source">The TestCases source</param>
/// <param name="settings">The Boost Test adapter settings currently in use</param>
/// <param name="debugMode">Determines whether the test should be debugged or not.</param>
/// <returns>A BoostTestRunnerCommandLineArgs structure for the provided source</returns>
private BoostTestRunnerCommandLineArgs GetDefaultArguments(string source, BoostTestAdapterSettings settings, bool debugMode)
{
BoostTestRunnerCommandLineArgs args = settings.CommandLineArgs.Clone();
GetDebugConfigurationProperties(source, settings, args);
// Specify log and report file information
args.LogFormat = OutputFormat.XML;
args.LogLevel = settings.LogLevel;
args.LogFile = TestPathGenerator.Generate(source, FileExtensions.LogFile);
args.ReportFormat = OutputFormat.XML;
args.ReportLevel = ReportLevel.Detailed;
args.ReportFile = TestPathGenerator.Generate(source, FileExtensions.ReportFile);
args.StandardOutFile = ((settings.EnableStdOutRedirection) ? TestPathGenerator.Generate(source, FileExtensions.StdOutFile) : null);
args.StandardErrorFile = ((settings.EnableStdErrRedirection) ? TestPathGenerator.Generate(source, FileExtensions.StdErrFile) : null);
// Set '--catch_system_errors' to 'yes' if the test is not being debugged
// or if this value was not overridden via configuration before-hand
args.CatchSystemErrors = args.CatchSystemErrors.GetValueOrDefault(false) || !debugMode;
return(args);
}
public void DefaultSettings()
{
BoostTestAdapterSettings settings = new BoostTestAdapterSettings();
AssertDefaultSettings(settings);
}
public Strategy ParseTestBatchStrategy(string settingsXml)
{
BoostTestAdapterSettings settings = ParseXml(settingsXml);
return(settings.TestBatchStrategy);
}
public bool?ParseCatchSystemErrorsOption(string settingsXml)
{
BoostTestAdapterSettings settings = ParseXml(settingsXml);
return(settings.CatchSystemErrors);
}
public int ParsePostTestDelayOption(string settingsXml)
{
BoostTestAdapterSettings settings = ParseXml(settingsXml);
return(settings.PostTestDelay);
}
