// This constructor is called by the others and is used directly for testing
public AssemblyRunner(TestLogger logger, string assemblyName)
{
this.logger = logger;
this.assemblyName = assemblyName;
this.testConverter = new TestConverter(logger, assemblyName);
this.loadedTestCases = new List<TestCase>();
this.nunitFilter = TestFilter.Empty;
}
// This constructor is used when the executor is called with a list of assemblies
public AssemblyRunner(TestLogger logger, string assemblyName, TFSTestFilter tfsFilter)
: this(logger, assemblyName)
{
if (tfsFilter.HasTfsFilterValue)
{
var filteredTestCases = tfsFilter.CheckFilter(this.LoadedTestCases);
this.nunitFilter = MakeTestFilter(filteredTestCases);
}
}
private TestResults RunTests(TestPackage package, TestFilter filter, Messages.OnMessage[] subscribers)
{
NUnit.Core.TestResult result;
ProcessModel processModel = package.Settings.Contains("ProcessModel") ? (ProcessModel)package.Settings["ProcessModel"] : ProcessModel.Default;
DomainUsage domainUsage = package.Settings.Contains("DomainUsage") ? (DomainUsage)package.Settings[(object)"DomainUsage"] : DomainUsage.Default;
RuntimeFramework runtimeFramework = package.Settings.Contains("RuntimeFramework") ? (RuntimeFramework)package.Settings["RuntimeFramework"] : RuntimeFramework.CurrentFramework;
using (new SaveConsoleOutput())
using (TestRunner testRunner = new DefaultTestRunnerFactory().MakeTestRunner(package))
using (var ms = new MemoryStream())
using (var output = CreateOutputWriter(ms))
{
try
{
TestEventHandler eventCollector = new TestEventHandler(_options, output, subscribers);
testRunner.Load(package);
if (testRunner.Test == null)
{
testRunner.Unload();
return new TestResults(TestResults.Code.FixtureNotFound, "Unable to locate fixture");
}
result = testRunner.Run(eventCollector, filter, false, LoggingThreshold.All);
var summary = eventCollector.GetSummary();
output.Flush();
if (summary.UnexpectedError)
return new TestResults(TestResults.Code.UnexpectedError, GetResultText(ms), summary);
return new TestResults(summary.InvalidAssemblies > 0
? TestResults.Code.InvalidAssembly
: GetCode(summary.FailureCount + summary.ErrorCount + summary.InvalidCount),
GetResultText(ms), summary);
}
catch (FileNotFoundException ex)
{
output.WriteLine(ex.Message);
output.Flush();
return new TestResults(TestResults.Code.InvalidAssembly, GetResultText(ms));
}
catch (DirectoryNotFoundException ex)
{
output.WriteLine(ex.Message);
output.Flush();
return new TestResults(TestResults.Code.InvalidAssembly, GetResultText(ms));
}
catch (Exception ex)
{
output.WriteLine(ex.ToString());
output.Flush();
return new TestResults(TestResults.Code.UnexpectedError, GetResultText(ms));
}
}
}
private TestResult run(TestRunner testRunner, TestHarvester harvester, TestFilter testFilter, string savedDirectory)
{
TestResult result = null;
try
{
result = testRunner.Run(harvester, testFilter, false, LoggingThreshold.Off);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
Environment.CurrentDirectory = savedDirectory;
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="NUnitTestsFilter"/> class.
/// </summary>
/// <param name="include">The include parameter.</param>
/// <param name="exclude">The exclude parameter.</param>
/// <param name="run">The run parameter.</param>
public NUnitTestsFilter(string include, string exclude, string run = null)
{
var filters = new List<TestFilter>();
if (!string.IsNullOrEmpty(run))
filters.Add(new SimpleNameFilter(run));
if (!string.IsNullOrEmpty(include))
filters.Add(new CategoryExpression(include).Filter);
if (!string.IsNullOrEmpty(exclude))
filters.Add(new NotFilter(new CategoryExpression(exclude).Filter));
if (filters.Count == 0)
nativeFilter = TestFilter.Empty;
else if (filters.Count == 1)
nativeFilter = filters[0];
else
nativeFilter = new AndFilter(filters.ToArray());
var notFilter = nativeFilter as NotFilter;
if (notFilter != null)
notFilter.TopLevel = true;
}
private void RestoreVisualState( VisualState visualState )
{
this.CheckBoxes = visualState.ShowCheckBoxes;
foreach (VisualTreeNode visualNode in visualState.Nodes)
{
TestSuiteTreeNode treeNode = this[visualNode.UniqueName];
if (treeNode != null)
{
if (treeNode.IsExpanded != visualNode.Expanded)
treeNode.Toggle();
treeNode.Checked = visualNode.Checked;
}
}
if (visualState.SelectedNode != null)
{
TestSuiteTreeNode treeNode = this[visualState.SelectedNode];
if (treeNode != null)
this.SelectedNode = treeNode;
}
if (visualState.TopNode != null)
{
TestSuiteTreeNode treeNode = this[visualState.TopNode];
if (treeNode != null)
TryToSetTopNode(treeNode);
}
if (visualState.SelectedCategories != null)
{
TestFilter filter = new CategoryFilter(visualState.SelectedCategories.Split(new char[] { ',' }));
if (visualState.ExcludeCategories)
filter = new NotFilter(filter);
this.CategoryFilter = filter;
}
this.Select();
}
internal static bool CreateTestFilter(ConsoleOptions options, out TestFilter testFilter)
{
testFilter = TestFilter.Empty;
SimpleNameFilter nameFilter = new SimpleNameFilter();
if (options.run != null && options.run != string.Empty)
{
Console.WriteLine("Selected test(s): " + options.run);
foreach (string name in TestNameParser.Parse(options.run))
nameFilter.Add(name);
testFilter = nameFilter;
}
if (options.runlist != null && options.runlist != string.Empty)
{
Console.WriteLine("Run list: " + options.runlist);
try
{
using (StreamReader rdr = new StreamReader(options.runlist))
{
// NOTE: We can't use rdr.EndOfStream because it's
// not present in .NET 1.x.
string line = rdr.ReadLine();
while (line != null && line.Length > 0)
{
if (line[0] != '#')
nameFilter.Add(line);
line = rdr.ReadLine();
}
}
}
catch (Exception e)
{
if (e is FileNotFoundException || e is DirectoryNotFoundException)
{
Console.WriteLine("Unable to locate file: " + options.runlist);
return false;
}
throw;
}
testFilter = nameFilter;
}
if (options.include != null && options.include != string.Empty)
{
TestFilter includeFilter = new CategoryExpression(options.include).Filter;
Console.WriteLine("Included categories: " + includeFilter.ToString());
if (testFilter.IsEmpty)
testFilter = includeFilter;
else
testFilter = new AndFilter(testFilter, includeFilter);
}
if (options.exclude != null && options.exclude != string.Empty)
{
TestFilter excludeFilter = new NotFilter(new CategoryExpression(options.exclude).Filter);
Console.WriteLine("Excluded categories: " + excludeFilter.ToString());
if (testFilter.IsEmpty)
testFilter = excludeFilter;
else if (testFilter is AndFilter)
((AndFilter) testFilter).Add(excludeFilter);
else
testFilter = new AndFilter(testFilter, excludeFilter);
}
if (testFilter is NotFilter)
((NotFilter) testFilter).TopLevel = true;
return true;
}
public static TestFilter AddBabysitterFilter(TestFilter currentFilter)
{
if (Override == OverrideMode.None)
return currentFilter;
return new AndFilter(currentFilter, new BabysitterFilter());
}
protected override int DoRun(Console.ConsoleOptions options, bool redirectOutput, bool redirectError, TestPackage package, TextWriter outWriter, TextWriter errorWriter, TestFilter testFilter, out TestResult result, EventCollector collector)
{
result = null;
var testRunner1 = new DefaultTestRunnerFactory().MakeTestRunner(package);
try
{
testRunner1.Load(package);
if (testRunner1.Test == null)
{
testRunner1.Unload();
System.Console.Error.WriteLine("Unable to locate fixture {0}", options.fixture);
return FIXTURE_NOT_FOUND;
}
}
finally
{
var disp = testRunner1 as IDisposable;
if (disp != null)
disp.Dispose();
}
result = new TestResult(new TestName { Name = "Global" });
var timer = new Stopwatch();
timer.Start();
var testRunnerId = 0;
{
var syncTestRunner = new DefaultTestRunnerFactory().MakeTestRunner(package);
var syncFilter = new AndFilter(testFilter, new SynchronousFilter());
var logger = new ConsoleLoggingEventListener(collector);
result.AddResult(RunPartition(redirectOutput, redirectError, package, outWriter, errorWriter, syncFilter, syncTestRunner, logger));
testRunnerId = syncTestRunner.ID;
}
var dep = 0;
var consoleOptions = options as ConsoleOptions;
if (options != null)
dep = consoleOptions.degreeofparallelism;
if (dep == 0)
dep = 4;
System.Console.WriteLine("Degree of Parallelism: {0}", dep);
var state = new AsynchronousFilterState(dep);
var asyncTestRunner = new ParallelTestRunner(testRunnerId + 1, dep, state);
result.AddResult(RunPartition(redirectOutput, redirectError, package, outWriter, errorWriter, testFilter, asyncTestRunner, collector));
if (consoleOptions != null && consoleOptions.retestfailures)
{
var failedTests = (from test in Flatten(result)
where test.Result.IsFailure
select test).ToList();
var failedTestFilter = new SimpleNameFilter(failedTests.Select(t => t.Result.FullName));
var retestTestRunner = new DefaultTestRunnerFactory().MakeTestRunner(package);
var retestFilter = new AndFilter(testFilter, failedTestFilter);
var logger = new ConsoleLoggingEventListener(collector);
var retestResults = RunPartition(redirectOutput, redirectError, package, outWriter, errorWriter, retestFilter, retestTestRunner, logger);
var newTests = Flatten(retestResults).ToDictionary(test => test.Result.FullName);
foreach (var failedTest in failedTests)
{
var newTest = newTests[failedTest.Result.FullName];
if (newTest.Result.IsSuccess)
{
failedTest.Parent.Results.Remove(failedTest.Result);
failedTest.Parent.Results.Add(newTest.Result);
}
}
}
result = MergeResults(result.Test, (TestResult)result.Results[0], (TestResult)result.Results[1]);
timer.Stop();
result.Time = timer.ElapsedTicks / (double)TimeSpan.TicksPerSecond;
return 0;
}
private TestResult RunPartition(bool redirectOutput, bool redirectError, TestRunner testRunner, TextWriter outWriter, TextWriter errorWriter, TestFilter testFilter, EventListener collector)
{
TestResult result = null;
var savedDirectory = Environment.CurrentDirectory;
var savedOut = System.Console.Out;
var savedError = System.Console.Error;
try
{
result = testRunner.Run(collector, testFilter);
}
finally
{
outWriter.Flush();
errorWriter.Flush();
if (redirectOutput)
outWriter.Close();
if (redirectError)
errorWriter.Close();
Environment.CurrentDirectory = savedDirectory;
System.Console.SetOut(savedOut);
System.Console.SetError(savedError);
}
System.Console.WriteLine();
return result;
}
private TestResult RunPartition(bool redirectOutput, bool redirectError, TestPackage package, TextWriter outWriter, TextWriter errorWriter, TestFilter testFilter, TestRunner testRunner, EventListener collector)
{
TestResult result;
try
{
testRunner.Load(package);
result = RunPartition(redirectOutput, redirectError, testRunner, outWriter, errorWriter, testFilter, collector);
}
finally
{
var disp = testRunner as IDisposable;
if (disp != null)
disp.Dispose();
}
return result;
}
// This constructor is used when the executor is called with a list of test cases
public AssemblyRunner(TestLogger logger, string assemblyName, IEnumerable<TestCase> selectedTestCases)
: this(logger, assemblyName)
{
this.nunitFilter = MakeTestFilter(selectedTestCases);
}
private bool CreateTestFilter(HostedOptions options, out TestFilter testFilter)
{
testFilter = TestFilter.Empty;
SimpleNameFilter simpleNameFilter = new SimpleNameFilter();
if (testFilter is NotFilter)
{
((NotFilter)testFilter).TopLevel = true;
}
return true;
}
protected abstract int DoRun(ConsoleOptions options, bool redirectOutput, bool redirectError, TestPackage package, TextWriter outWriter, TextWriter errorWriter, TestFilter testFilter, out TestResult result, EventCollector collector);
