private void CreateChildWorkItems()
{
_children = new List <WorkItem>();
foreach (ITest test in _suite.Tests)
{
if (_childFilter.Pass(test))
{
var child = WorkItem.CreateWorkItem(test, _childFilter);
child.WorkerId = this.WorkerId;
#if !PORTABLE && !SILVERLIGHT && !NETCF
if (child.TargetApartment == ApartmentState.Unknown && TargetApartment != ApartmentState.Unknown)
{
child.TargetApartment = TargetApartment;
}
#endif
if (test.Properties.ContainsKey(PropertyNames.Order))
{
_children.Insert(0, child);
_countOrder++;
}
else
{
_children.Add(child);
}
}
}
if (_countOrder != 0)
{
SortChildren();
}
}
private void CreateChildWorkItems()
{
Children = new List <UnityWorkItem>();
var testSuite = _suite;
foreach (ITest test in testSuite.Tests)
{
if (_childFilter.Pass(test))
{
var child = m_Factory.Create(test, _childFilter);
if (test.Properties.ContainsKey(PropertyNames.Order))
{
Children.Insert(0, child);
_countOrder++;
}
else
{
Children.Add(child);
}
}
}
if (_countOrder != 0)
{
SortChildren();
}
}
// All forms of Run and BeginRun eventually come here
public virtual TestResult Run(EventListener listener, ITestFilter filter)
{
Log.Info("Run - EventListener={0}", listener.GetType().Name);
// Save active listener for derived classes
this.listener = listener;
ITest[] tests = new ITest[runners.Count];
for (int index = 0; index < runners.Count; index++)
{
tests[index] = ((TestRunner)runners[index]).Test;
}
string name = this.testName.Name;
int count = this.CountTestCases(filter);
Log.Info("Signalling RunStarted({0},{1})", name, count);
this.listener.RunStarted(name, count);
long startTime = DateTime.Now.Ticks;
TestResult result = new TestResult(new TestInfo(testName, tests));
if (this.runInParallel)
{
foreach (TestRunner runner in runners)
{
if (filter.Pass(runner.Test))
{
runner.BeginRun(this, filter);
}
}
result = this.EndRun();
}
else
{
foreach (TestRunner runner in runners)
{
if (filter.Pass(runner.Test))
{
result.AddResult(runner.Run(this, filter));
}
}
}
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
result.Time = time;
this.listener.RunFinished(result);
this.testResult = result;
return(result);
}
private void CreateChildWorkItems()
{
_children = new List <WorkItem>();
foreach (Test test in _suite.Tests)
{
if (_childFilter.Pass(test))
{
_children.Add(WorkItem.CreateWorkItem(test, _childFilter));
}
}
}
public override int CountTestCases( ITestFilter filter )
{
if (filter.Pass(this))
return 1;
return 0;
}
/// <summary>
/// Creates a copy of the given suite with only the descendants that pass the specified filter.
/// </summary>
/// <param name="suite">The <see cref="TestSuite"/> to copy.</param>
/// <param name="filter">Determines which descendants are copied.</param>
public TestSuite(TestSuite suite, ITestFilter filter)
: base(suite.Name)
{
this.FullName = suite.FullName;
this.Method = suite.Method;
this.RunState = suite.RunState;
this.Fixture = suite.Fixture;
foreach (var child in suite.tests)
{
if (filter.Pass(child))
{
if (child.IsSuite)
{
TestSuite childSuite = ((TestSuite)child).Copy(filter);
childSuite.Parent = this;
this.tests.Add(childSuite);
}
else
{
this.tests.Add(child);
}
}
}
}
public TestSuite(TestSuite suite, ITestFilter filter)
: this(suite.Name)
{
this.FullName = suite.FullName;
this.Method = suite.Method;
this.RunState = suite.RunState;
this.Fixture = suite.Fixture;
foreach (string key in suite.Properties.Keys)
{
foreach (object val in suite.Properties[key])
{
this.Properties.Add(key, val);
}
}
foreach (var child in suite.tests)
{
if (filter.Pass(child))
{
if (child.IsSuite)
{
TestSuite childSuite = ((TestSuite)child).Copy(filter);
childSuite.Parent = this;
this.tests.Add(childSuite);
}
else
{
this.tests.Add(child);
}
}
}
}
/// <summary>
/// Method that actually performs the work. Overridden
/// in CompositeWorkItem to do setup, run all child
/// items and then do teardown.
/// </summary>
protected override void PerformWork()
{
// Assume success, since the result will be inconclusive
// if there is no setup method to run or if the
// context initialization fails.
Result.SetResult(ResultState.Success);
PerformOneTimeSetUp();
if (Result.ResultState.Status == TestStatus.Passed && _suite.HasChildren)
{
foreach (Test test in _suite.Tests)
{
if (_childFilter.Pass(test))
{
_children.Enqueue(CreateWorkItem(test, this.Context, _childFilter));
}
}
if (_children.Count > 0)
{
RunChildren();
return;
}
}
// Fall through in case there were no child tests to run.
// Otherwise, this is done in the completion event.
PerformOneTimeTearDown();
WorkItemComplete();
}
private void RunAllTests(
TestSuiteResult suiteResult, EventListener listener, ITestFilter filter)
{
foreach (Test test in ArrayList.Synchronized(Tests))
{
if (filter.Pass(test))
{
RunState saveRunState = test.RunState;
if (test.RunState == RunState.Runnable && this.RunState != RunState.Runnable && this.RunState != RunState.Explicit)
{
test.RunState = this.RunState;
test.IgnoreReason = this.IgnoreReason;
}
TestResult result = test.Run(listener, filter);
suiteResult.AddResult(result);
if (saveRunState != test.RunState)
{
test.RunState = saveRunState;
test.IgnoreReason = null;
}
}
}
}
private void RunAllTests(
TestResult suiteResult, EventListener listener, ITestFilter filter)
{
if (Properties.Contains("Timeout"))
{
TestContext.TestCaseTimeout = (int)Properties["Timeout"];
}
foreach (Test test in ArrayList.Synchronized(Tests))
{
if (filter.Pass(test))
{
RunState saveRunState = test.RunState;
if (test.RunState == RunState.Runnable && this.RunState != RunState.Runnable && this.RunState != RunState.Explicit)
{
test.RunState = this.RunState;
test.IgnoreReason = this.IgnoreReason;
}
TestResult result = test.Run(listener, filter);
suiteResult.AddResult(result);
if (saveRunState != test.RunState)
{
test.RunState = saveRunState;
test.IgnoreReason = null;
}
}
}
}
private void FilterTestCases(xua.IMessageSinkMessage message)
{
try
{
if (message is xua.ITestCaseDiscoveryMessage testDiscovered)
{
if (_filter?.Pass(Wrap(testDiscovered.TestCase)) != false)
{
_testsToRun.Add(testDiscovered.TestCase);
}
}
else if (message is xua.IDiscoveryCompleteMessage discoveryComplete)
{
_tcsFilter.SetResult(_testsToRun.Count);
}
else if (message is xua.IErrorMessage errorMessage)
{
Console.WriteLine($"Error ocurred {errorMessage.ToString()}");
}
else
{
Console.WriteLine($"Unhandled message of type {message.GetType()}");
}
}
catch (Exception ex)
{
_tcsFilter?.SetException(ex);
_tcsRun?.SetException(ex);
_tcs?.SetException(ex);
}
}
public override bool Match(ITest test)
{
if (topLevel && test.RunState == RunState.Explicit)
{
return(false);
}
return(!baseFilter.Pass(test));
}
/// <summary>
/// Gets a count of test cases that would be run using
/// the specified filter.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public virtual int CountTestCases(ITestFilter filter)
{
if (filter.Pass(this))
{
return(1);
}
return(0);
}
public override int CountTestCases(ITestFilter filter)
{
if (filter.Pass(this))
{
return(1);
}
return(0);
}
/// <summary>
/// Creates a work item.
/// </summary>
/// <param name="test">The test for which this WorkItem is being created.</param>
/// <param name="filter">The filter to be used in selecting any child Tests.</param>
/// <param name="debugger">An <see cref="IDebugger" /> instance.</param>
/// <param name="recursive">True if child work items should be created and added.</param>
/// <param name="root"><see langword="true"/> if work item needs to be created unconditionally, if <see langword="false"/> <see langword="null"/> will be returned for tests that don't match the filter.</param>
/// <returns></returns>
internal static WorkItem CreateWorkItem(ITest test, ITestFilter filter, IDebugger debugger, bool recursive = false, bool root = true)
{
// Run filter on leaf nodes only
// use the presence of leaf nodes as an indicator that parent need to be created
// Always create a workitem for the root node
TestSuite suite = test as TestSuite;
if (suite == null)
{
if (root || filter.Pass(test))
{
return(new SimpleWorkItem((TestMethod)test, filter, debugger));
}
return(null);
}
CompositeWorkItem work = root ? new CompositeWorkItem(suite, filter): null;
if (recursive)
{
int countOrderedItems = 0;
foreach (var childTest in suite.Tests)
{
var childItem = CreateWorkItem(childTest, filter, debugger, recursive, root: false);
if (childItem == null)
{
continue;
}
work ??= new CompositeWorkItem(suite, filter);
if (childItem.TargetApartment == ApartmentState.Unknown && work.TargetApartment != ApartmentState.Unknown)
{
childItem.TargetApartment = work.TargetApartment;
}
if (childTest.Properties.ContainsKey(PropertyNames.Order))
{
work.Children.Insert(0, childItem);
countOrderedItems++;
}
else
{
work.Children.Add(childItem);
}
}
if (countOrderedItems > 0)
{
work.Children.Sort(0, countOrderedItems, new WorkItemOrderComparer());
}
}
return(work);
}
private void MarkTestsNotRun(
IList tests, RunState runState, string ignoreReason, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter)
{
foreach (Test test in ArrayList.Synchronized(tests))
{
if (filter.Pass(test))
{
MarkTestNotRun(test, runState, ignoreReason, suiteResult, listener, filter);
}
}
}
private void MarkTestsFailed(
IList tests, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter)
{
foreach (Test test in ArrayList.Synchronized(tests))
{
if (filter.Pass(test))
{
MarkTestFailed(test, suiteResult, listener, filter);
}
}
}
private void RunChildren()
{
var children = new List <WorkItem>();
foreach (Test test in _suite.Tests)
{
if (_childFilter.Pass(test))
{
children.Add(WorkItem.CreateWorkItem(test, new TestExecutionContext(this.Context), _childFilter));
}
}
if (children.Count > 0)
{
_childTestCountdown = new CountdownEvent(children.Count);
foreach (WorkItem child in children)
{
child.Completed += new EventHandler(OnChildCompleted);
#if NUNITLITE
child.Execute();
#else
// We run child items on the same thread as the parent...
// 1. If there is no dispatcher (NUnitLite or LevelOfParallelism = 0).
// 2. If there is no fixture, and so nothing to do but dispatch grandchildren.
// 3. For now, if this represents a test case. This avoids issues of
// tests that access the fixture state and allows handling ApartmentState
// preferences set on the fixture.
if (Context.Dispatcher == null || child is SimpleWorkItem || child.Test.FixtureType == null)
{
log.Debug("Directly executing {0}", child.Test.Name);
child.Execute();
}
else
{
Context.Dispatcher.Dispatch(child);
}
#endif
}
}
}
private void RunChildren()
{
var children = new List <WorkItem>();
foreach (Test test in _suite.Tests)
{
if (_childFilter.Pass(test))
{
children.Add(WorkItem.CreateWorkItem(test, new TestExecutionContext(this.Context), _childFilter));
}
}
if (children.Count > 0)
{
_childTestCountdown = new CountdownEvent(children.Count);
foreach (WorkItem child in children)
{
child.Completed += new EventHandler(OnChildCompleted);
#if NUNITLITE
child.Execute();
#else
if (Context.Dispatcher == null)
{
child.Execute();
}
// For now, run all test cases on the same thread as the fixture
// in order to handle ApartmentState preferences set on the fixture.
else if (child is SimpleWorkItem || child.Test is ParameterizedMethodSuite)
{
log.Debug("Executing WorkItem for {0}", child.Test.FullName);
child.Execute();
}
else
{
Context.Dispatcher.Dispatch(child);
}
#endif
}
}
}
public override int CountTestCases(ITestFilter filter)
{
int count = 0;
if (filter.Pass(this))
{
foreach (Test test in Tests)
{
count += test.CountTestCases(filter);
}
}
return(count);
}
protected override TestCommand MakeTestCommand(ITestFilter filter)
{
TestCommand testCommand = new TestSuiteCommand(this);
foreach (Test test in Tests)
{
if (filter.Pass(test))
{
testCommand.Children.Add(test.GetTestCommand(filter));
}
}
return(testCommand);
}
/// <summary>
/// Counts the test cases that would be run if this
/// test were executed using the provided filter.
/// </summary>
/// <param name="filter">The filter to apply</param>
/// <returns>A count of test cases</returns>
public virtual int CountTestCases(ITestFilter filter)
{
if (filter.IsEmpty)
{
return(TestCount);
}
if (!isSuite)
{
return(filter.Pass(this) ? 1 : 0);
}
int count = 0;
if (filter.Pass(this))
{
foreach (ITest test in Tests)
{
count += test.CountTestCases(filter);
}
}
return(count);
}
private void RunAllTests(
TestResult suiteResult, EventListener listener, ITestFilter filter)
{
if (Properties.Contains("Timeout"))
{
TestExecutionContext.CurrentContext.TestCaseTimeout = (int)Properties["Timeout"];
}
IDictionary settings = TestExecutionContext.CurrentContext.TestPackage.Settings;
bool stopOnError = settings.Contains("StopOnError") && (bool)settings["StopOnError"];
foreach (Test test in ArrayList.Synchronized(Tests))
{
if (filter.Pass(test))
{
RunState saveRunState = test.RunState;
if (test.RunState == RunState.Runnable && this.RunState != RunState.Runnable && this.RunState != RunState.Explicit)
{
test.RunState = this.RunState;
test.IgnoreReason = this.IgnoreReason;
}
TestResult result = test.Run(listener, filter);
log.Debug("Test result = " + result.ResultState);
suiteResult.AddResult(result);
log.Debug("Suite result = " + suiteResult.ResultState);
if (saveRunState != test.RunState)
{
test.RunState = saveRunState;
test.IgnoreReason = null;
}
if (result.ResultState == ResultState.Cancelled)
{
break;
}
if ((result.IsError || result.IsFailure) && stopOnError)
{
break;
}
}
}
}
private bool PruneTests(ITest test, ITestFilter filter)
{
if (test.IsSuite)
{
for (int i = test.Tests.Count - 1; i >= 0; i--)
{
if (!PruneTests(test.Tests[i] as ITest, filter))
{
test.Tests.RemoveAt(i);
}
}
return(test.Tests.Count > 0);
}
return(filter.Pass(test));
}
/// <summary>
/// Creates a work item.
/// </summary>
/// <param name="test">The test for which this WorkItem is being created.</param>
/// <param name="filter">The filter to be used in selecting any child Tests.</param>
/// <param name="recursive">True if child work items should be created and added.</param>
/// <returns></returns>
static public WorkItem CreateWorkItem(ITest test, ITestFilter filter, bool recursive = false)
{
TestSuite suite = test as TestSuite;
if (suite == null)
{
return(new SimpleWorkItem((TestMethod)test, filter));
}
var work = new CompositeWorkItem(suite, filter);
if (recursive)
{
int countOrderedItems = 0;
foreach (var childTest in suite.Tests)
{
if (filter.Pass(childTest))
{
var childItem = CreateWorkItem(childTest, filter, recursive);
#if APARTMENT_STATE
if (childItem.TargetApartment == ApartmentState.Unknown && work.TargetApartment != ApartmentState.Unknown)
{
childItem.TargetApartment = work.TargetApartment;
}
#endif
if (childTest.Properties.ContainsKey(PropertyNames.Order))
{
work.Children.Insert(0, childItem);
countOrderedItems++;
}
else
{
work.Children.Add(childItem);
}
}
}
if (countOrderedItems > 0)
{
work.Children.Sort(0, countOrderedItems, new WorkItemOrderComparer());
}
}
return(work);
}
private int CountTestCases(ITest test, ITestFilter filter)
{
if (!test.IsSuite)
{
return(filter.Pass(test) ? 1: 0);
}
int count = 0;
foreach (ITest child in test.Tests)
{
count += CountTestCases(child, filter);
}
return(count);
}
private static List <string> GetTestsExpectedToRun(ITest test, ITestFilter filter)
{
var expectedTests = new List <string>();
if (filter.Pass(test))
{
if (test.IsSuite)
{
expectedTests.AddRange(test.Tests.SelectMany(subTest => GetTestsExpectedToRun(subTest, filter)));
}
else
{
expectedTests.Add(test.FullName);
}
}
return(expectedTests);
}
protected override TestCommand MakeTestCommand(ITestFilter filter)
{
TestCommand command = new TestSuiteCommand(this);
foreach (Test childTest in Tests)
{
if (filter.Pass(childTest))
{
command.Children.Add(childTest.GetTestCommand(filter));
}
}
#if !NUNITLITE && false
if (ShouldRunOnOwnThread)
{
command = new ThreadedTestCommand(command);
}
#endif
return(command);
}
public virtual TestResult Run(EventListener listener, ITestFilter filter)
{
// Save active listener for derived classes
this.listener = listener;
ITest[] tests = new ITest[runners.Count];
for (int index = 0; index < runners.Count; index++)
{
tests[index] = ((TestRunner)runners[index]).Test;
}
this.listener.RunStarted(this.Test.TestName.Name, this.CountTestCases(filter));
this.listener.SuiteStarted(this.Test.TestName);
long startTime = DateTime.Now.Ticks;
TestSuiteResult result = new TestSuiteResult(new TestInfo(testName, tests), projectName);
result.RunState = RunState.Executed;
foreach (TestRunner runner in runners)
{
if (filter.Pass(runner.Test))
{
result.AddResult(runner.Run(this, filter));
}
}
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
result.Time = time;
this.listener.SuiteFinished(result);
this.listener.RunFinished(result);
this.testResult = result;
return(result);
}
protected override async Task <ITestResult> RunInternalAsync(ITestFilter filter)
{
var results = new MultipleTestResult(_testSuite);
_testFilter = filter;
_runnersToTest = new Queue <ITestRunner>(Runners.Where(r => _testFilter.Pass((r.TestSuite))));
OnTestStarted(new UnitTestTestEventArgs(_testSuite));
try
{
while (_runnersToTest.Count > 0)
{
lock (this)
{
_currentRunner = _runnersToTest.Dequeue();
_currentRunner.Log += currentRunner_Log;
_currentRunner.Progress += currentRunner_Progress;
_currentRunner.TestStarted += currentRunner_TestStarted;
_currentRunner.TestFinished += currentRunner_TestFinished;
}
var result = await _currentRunner.RunAsync(filter);
results.Results.Add(result);
_currentRunner.Log -= currentRunner_Log;
_currentRunner.Progress -= currentRunner_Progress;
_currentRunner.TestStarted -= currentRunner_TestStarted;
_currentRunner.TestFinished -= currentRunner_TestFinished;
}
OnTestFinished(new UnitTestResultEventArgs(results));
}
finally
{
_currentRunner = null;
}
return(results);
}
private void RunAllTests(
TestSuiteResult suiteResult, EventListener listener, ITestFilter filter)
{
foreach (Test test in ArrayList.Synchronized(Tests))
{
if (filter.Pass(test))
{
RunState saveRunState = test.RunState;
if (test.RunState == RunState.Runnable && this.RunState != RunState.Runnable && this.RunState != RunState.Explicit )
{
test.RunState = this.RunState;
test.IgnoreReason = this.IgnoreReason;
}
TestResult result = test.Run(listener, filter);
suiteResult.AddResult(result);
if (saveRunState != test.RunState)
{
test.RunState = saveRunState;
test.IgnoreReason = null;
}
}
}
}
private void MarkTestsNotRun(
IList tests, RunState runState, string ignoreReason, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter)
{
foreach (Test test in ArrayList.Synchronized(tests))
{
if (filter.Pass(test))
MarkTestNotRun(test, runState, ignoreReason, suiteResult, listener, filter);
}
}
private void MarkTestsFailed(
IList tests, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter)
{
foreach (Test test in ArrayList.Synchronized(tests))
if (filter.Pass(test))
MarkTestFailed(test, suiteResult, listener, filter);
}
public override int CountTestCases(ITestFilter filter)
{
int count = 0;
if(filter.Pass(this))
{
foreach(Test test in Tests)
{
count += test.CountTestCases(filter);
}
}
return count;
}
public virtual TestResult Run(EventListener listener, ITestFilter filter )
{
// Save active listener for derived classes
this.listener = listener;
ITest[] tests = new ITest[runners.Count];
for( int index = 0; index < runners.Count; index++ )
tests[index] = ((TestRunner)runners[index]).Test;
this.listener.RunStarted( this.Test.TestName.Name, this.CountTestCases( filter ) );
this.listener.SuiteStarted( this.Test.TestName );
long startTime = DateTime.Now.Ticks;
TestSuiteResult result = new TestSuiteResult( new TestInfo( testName, tests ), projectName );
result.RunState = RunState.Executed;
foreach( TestRunner runner in runners )
if ( filter.Pass( runner.Test ) )
result.AddResult( runner.Run( this, filter ) );
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
result.Time = time;
this.listener.SuiteFinished( result );
this.listener.RunFinished( result );
this.testResult = result;
return result;
}
/// <summary>
/// Count the test cases that pass a filter. The
/// result should match those that would execute
/// when passing the same filter to Run.
/// </summary>
/// <param name="filter">The filter to apply</param>
/// <returns>The count of test cases</returns>
public int CountTestCases(ITestFilter filter)
{
if (filter.IsEmpty)
return TestCount;
if (!IsSuite)
return filter.Pass(this) ? 1 : 0;
int count = 0;
if (filter.Pass(this))
{
count += Tests.Cast<ITest>().Sum(test => test.CountTestCases(filter));
}
return count;
}
private void RunAllTests(TestResult suiteResult, EventListener listener, ITestFilter filter )
{
if (Properties.Contains("Timeout"))
TestExecutionContext.CurrentContext.TestCaseTimeout = (int)Properties["Timeout"];
IDictionary settings = TestExecutionContext.CurrentContext.TestPackage.Settings;
bool stopOnError = settings.Contains("StopOnError") && (bool)settings["StopOnError"];
foreach (Test test in ArrayList.Synchronized(Tests))
{
if (filter.Pass(test))
{
RunState saveRunState = test.RunState;
if (test.RunState == RunState.Runnable && this.RunState != RunState.Runnable && this.RunState != RunState.Explicit )
{
test.RunState = this.RunState;
test.IgnoreReason = this.IgnoreReason;
}
TestResult result = test.Run(listener, filter);
log.Debug("Test result = " + result.ResultState);
suiteResult.AddResult(result);
log.Debug("Suite result = " + suiteResult.ResultState);
if (saveRunState != test.RunState)
{
test.RunState = saveRunState;
test.IgnoreReason = null;
}
if (result.ResultState == ResultState.Cancelled)
break;
if ((result.IsError || result.IsFailure || result.ResultState == ResultState.NotRunnable) && stopOnError)
break;
}
}
}
public override void Visit(TestSuiteTreeNode node)
{
node.Included = filter.Pass(node.Test);
}
private static void FindTestUnits(ITest test, ITestFilter filter,
List<TestUnitWithMetadata> result, TestRun testRun, string assemblyName = null)
{
var assembly = test as TestAssembly;
if (assembly != null)
assemblyName = assembly.TestName.FullName;
if (filter.Pass(test))
{
var isTestSuiteWithAtLeastOneTestMethod = (test.IsSuite && test.Tests != null && test.Tests.Count != 0 &&
!((ITest) test.Tests[0]).IsSuite);
if (!test.IsSuite || isTestSuiteWithAtLeastOneTestMethod)
{
List<TestUnitWithMetadata> subTests = null;
if (test.IsSuite && test.Tests != null)
{
subTests = new List<TestUnitWithMetadata>();
foreach (ITest child in test.Tests)
{
FindTestUnits(child, filter, subTests, testRun, assemblyName);
}
}
var testUnitWithMetadata = new TestUnitWithMetadata(testRun, test, assemblyName, subTests);
result.Add(testUnitWithMetadata);
}
else if ((test.Tests != null && test.Tests.Count > 0))
{
foreach (ITest child in test.Tests)
{
FindTestUnits(child, filter, result, testRun, assemblyName);
}
}
}
}
/// <summary>
/// Gets a count of test cases that would be run using
/// the specified filter.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public virtual int CountTestCases(ITestFilter filter)
{
if (filter.Pass(this))
return 1;
return 0;
}
private int CountTestCases(ITest test, ITestFilter filter)
{
if (!test.IsSuite)
return 1;
int count = 0;
foreach (ITest child in test.Tests)
if (filter.Pass(child))
count += CountTestCases(child, filter);
return count;
}
private void RunAllTests(
TestResult suiteResult, EventListener listener, ITestFilter filter )
{
if (Properties.Contains("Timeout"))
TestContext.TestCaseTimeout = (int)Properties["Timeout"];
foreach (Test test in ArrayList.Synchronized(Tests))
{
if (filter.Pass(test))
{
RunState saveRunState = test.RunState;
if (test.RunState == RunState.Runnable && this.RunState != RunState.Runnable && this.RunState != RunState.Explicit )
{
test.RunState = this.RunState;
test.IgnoreReason = this.IgnoreReason;
}
TestResult result = test.Run(listener, filter);
suiteResult.AddResult(result);
if (saveRunState != test.RunState)
{
test.RunState = saveRunState;
test.IgnoreReason = null;
}
if (result.ResultState == ResultState.Cancelled)
break;
}
}
}
public virtual TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
Log.Info("Run - EventListener={0}", listener.GetType().Name);
// Save active listener for derived classes
this.listener = listener;
ITest[] tests = new ITest[runners.Count];
for( int index = 0; index < runners.Count; index++ )
tests[index] = ((TestRunner)runners[index]).Test;
string name = this.testName.Name;
int count = this.CountTestCases(filter);
Log.Info("Signalling RunStarted({0},{1})", name, count);
this.listener.RunStarted(name, count);
long startTime = DateTime.Now.Ticks;
TestResult result = new TestResult(new TestInfo(testName, tests));
if (this.runInParallel)
{
foreach (TestRunner runner in runners)
if (filter.Pass(runner.Test))
runner.BeginRun(this, filter, tracing, logLevel);
result = this.EndRun();
}
else
{
foreach (TestRunner runner in runners)
if (filter.Pass(runner.Test))
result.AddResult(runner.Run(this, filter, tracing, logLevel));
}
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
result.Time = time;
this.listener.RunFinished( result );
this.testResult = result;
return result;
}
protected virtual TestResult InternalRun(ITestFilter filter, TestResult result)
{
if (this.runInParallel)
{
foreach (TestRunner runner in runners)
if (filter.Pass(runner.Test))
runner.BeginRun(this, filter);
result = this.EndRun();
}
else
{
foreach (TestRunner runner in runners)
if (filter.Pass(runner.Test))
result.AddResult(runner.Run(this, filter));
}
return result;
}
/// <summary>
/// Counts the test cases that would be run if this
/// test were executed using the provided filter.
/// </summary>
/// <param name="filter">The filter to apply</param>
/// <returns>A count of test cases</returns>
public virtual int CountTestCases(ITestFilter filter)
{
if (filter.IsEmpty)
return TestCount;
if (!isSuite)
return filter.Pass(this) ? 1 : 0;
int count = 0;
if (filter.Pass(this))
{
foreach (ITest test in Tests)
{
count += test.CountTestCases(filter);
}
}
return count;
}