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; }