/// <summary> /// Start a run of the tests in the loaded TestPackage. The tests are run /// asynchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> public void BeginRun(ITestEventHandler listener, TestFilter filter) { if (runner != null) { runner.BeginRun(listener, filter); } }
/// <summary> /// Run tests from all assemblies<br/> /// Will block until all tests finished<br/> /// 运行所有程序集中的所有测试<br/> /// 会阻塞到运行完成<br/> /// </summary> /// <param name="eventHandler">Extra test event handler, can be null</param> public virtual void RunAllAssemblyTest(ITestEventHandler eventHandler = null) { foreach (var assembly in GetAssembliesForTest()) { RunAssemblyTest(assembly, eventHandler); } }
/// <summary> /// Start a run of the tests in the loaded TestPackage. The tests are run /// asynchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> public override void BeginRun(ITestEventHandler listener, TestFilter filter) { _listener = listener; _filter = filter; var threadStart = new System.Threading.ThreadStart(RunnerProc); System.Threading.Thread runnerThread = new System.Threading.Thread(threadStart); runnerThread.Start(); }
/// <summary> /// Executes the tests in an assembly. /// </summary> /// <param name="listener">An ITestEventHandler that receives progress notices</param> /// <param name="filter">A filter that controls which tests are executed</param> /// <returns>An Xml string representing the result</returns> public string Run(ITestEventHandler listener, TestFilter filter) { CallbackHandler handler = new RunTestsCallbackHandler(listener); log.Info("Running {0} - see separate log file", Path.GetFileName(_testAssemblyPath)); CreateObject(RUN_ACTION, _frameworkController, filter.Text, handler); return(handler.Result); }
/// <summary> /// Runs tests specified in the test package, applying /// the supplied filter. /// </summary> /// <param name="package">A TestPackage.</param> /// <param name="filter">A TestFilter (currently ignored)</param> /// <returns>An XmlNode representing the test results.</returns> public XmlNode Run(TestPackage package, ITestEventHandler listener, TestFilter filter) { using (ITestRunner runner = GetRunner()) { runner.Load(package); return(runner.Run(listener, filter)); } }
/// <summary> /// Run the tests in a loaded TestPackage /// </summary> /// <param name="filter">A TestFilter used to select tests</param> /// <returns> /// A TestEngineResult giving the result of the test execution. The /// top-level node of the result is <direct-runner> and wraps /// all the <test-assembly> elements returned by the drivers. /// </returns> public override TestEngineResult Run(ITestEventHandler listener, TestFilter filter) { List <TestEngineResult> results = new List <TestEngineResult>(); foreach (NUnitFrameworkDriver driver in drivers) { results.Add(driver.Run(listener, filter)); } return(MakePackageResult(results)); }
/// <summary> /// Runs tests specified in the test package, applying /// the supplied filter. /// </summary> /// <param name="package">A TestPackage.</param> /// <param name="filter">A TestFilter (currently ignored)</param> /// <returns>An XmlNode representing the test results.</returns> public ITestEngineResult Run(TestPackage package, ITestEventHandler listener, TestFilter filter) { using (ITestRunner runner = GetRunner()) { ITestEngineResult loadResult = runner.Load(package); return(loadResult.HasErrors ? loadResult : runner.Run(listener, filter)); } }
/// <summary> /// Run the tests in a loaded TestPackage /// </summary> /// <param name="filter">A TestFilter used to select tests</param> /// <returns> /// A TestEngineResult giving the result of the test execution. /// </returns> public override TestEngineResult Run(ITestEventHandler listener, TestFilter filter) { List <TestEngineResult> results = new List <TestEngineResult>(); // TODO: Eliminate need for implicit cast to AbstractTestRunner foreach (AbstractTestRunner runner in runners) { results.Add(runner.Run(listener, filter)); } return(MakePackageResult(results)); }
/// <summary> /// Run the tests in a loaded TestPackage /// </summary> /// <param name="filter">A TestFilter used to select tests</param> /// <returns> /// A TestEngineResult giving the result of the test execution. The /// top-level node of the result is <direct-runner> and wraps /// all the <test-assembly> elements returned by the drivers. /// </returns> public override TestEngineResult Run(ITestEventHandler listener, TestFilter filter) { TestEngineResult result = new TestEngineResult(); foreach (IFrameworkDriver driver in drivers) { result.Add(driver.Run(listener, filter)); } return(IsProjectPackage(this.package) ? result.MakePackageResult(package.Name, package.FullName) : result); }
/// <summary> /// Run tests from assembly<br/> /// Will block until all tests finished<br/> /// 运行指定程序集中的所有测试<br/> /// 会阻塞到运行完成<br/> /// </summary> /// <param name="assembly">Assembly</param> /// <param name="eventHandler">Extra test event handler, can be null</param> public virtual void RunAssemblyTest( Assembly assembly, ITestEventHandler eventHandler = null) { // Get registered test event handlers var eventHandlers = Application.Ioc.ResolveMany <ITestEventHandler>().ToList(); if (eventHandler != null) { eventHandlers.Add(eventHandler); } // Create runner and execute tests var runner = new TestRunner(assembly, eventHandlers); runner.Run(); }
/// <summary> /// Run the tests in a loaded TestPackage /// </summary> /// <param name="filter">A TestFilter used to select tests</param> /// <returns> /// A TestEngineResult giving the result of the test execution. /// </returns> public override TestEngineResult Run(ITestEventHandler listener, TestFilter filter) { List <TestEngineResult> results = new List <TestEngineResult>(); // TODO: Eliminate need for implicit cast to AbstractTestRunner foreach (AbstractTestRunner runner in runners) { results.Add(runner.Run(listener, filter)); } TestEngineResult result = ResultHelper.Merge(results); return(IsProjectPackage(this.package) ? result.MakePackageResult(package.Name, package.FullName) : result); }
/// <summary> /// Run the tests in the loaded TestPackage and return a test result. The tests /// are run synchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> /// <returns>A TestEngineResult giving the result of the test execution</returns> public override TestEngineResult Run(ITestEventHandler listener, TestFilter filter) { DateTime startTime = DateTime.UtcNow; long startTicks = Stopwatch.GetTimestamp(); TestEngineResult result = realRunner.Run(listener, filter).Aggregate("test-run", package.Name, package.FullName); result.Xml.InsertEnvironmentElement(); double duration = (double)(Stopwatch.GetTimestamp() - startTicks) / Stopwatch.Frequency; result.Xml.AddAttribute("start-time", XmlConvert.ToString(startTime, "u")); result.Xml.AddAttribute("end-time", XmlConvert.ToString(DateTime.UtcNow, "u")); result.Xml.AddAttribute("duration", duration.ToString("0.000000", NumberFormatInfo.InvariantInfo)); return(result); }
public RunTestsCallbackHandler(ITestEventHandler listener) { this.listener = listener; }
/// <summary> /// Run the tests in a loaded TestPackage. The explicit /// implementation returns an ITestEngineResult for use /// by external clients. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> /// <returns>An XmlNode giving the result of the test execution</returns> XmlNode ITestRunner.Run(ITestEventHandler listener, TestFilter filter) { return(this.Run(listener, filter).Xml); }
/// <summary> /// Start a run of the tests in the loaded TestPackage. The tests are run /// asynchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> public override void BeginRun(ITestEventHandler listener, TestFilter filter) { realRunner.BeginRun(listener, filter); }
/// <summary> /// Start a run of the tests in the loaded TestPackage. The tests are run /// asynchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> void ITestRunner.BeginRun(ITestEventHandler listener, TestFilter filter) { this.BeginRun(listener, filter); }
/// <summary> /// Run the tests in the loaded TestPackage and return a test result. The tests /// are run synchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> /// <returns>A TestEngineResult giving the result of the test execution</returns> public TestEngineResult Run(ITestEventHandler listener, TestFilter filter) { return(runner == null ? null : runner.Run(listener, filter)); }
public TestController(ITestEventHandler testEventHandler) { TestEventHandler = testEventHandler ?? throw new ArgumentNullException(nameof(testEventHandler)); }
/// <summary> /// Run the tests in a loaded TestPackage. The explicit /// implementation returns an ITestEngineResult for use /// by external clients. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> /// <returns>An ITestEngineResult giving the result of the test execution</returns> ITestEngineResult ITestRunner.Run(ITestEventHandler listener, TestFilter filter) { return(this.Run(listener, filter)); }
/// <summary> /// Start a run of the tests in the loaded TestPackage. The tests are run /// asynchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> public abstract void BeginRun(ITestEventHandler listener, TestFilter filter);
/// <summary> /// Start a run of the tests in the loaded TestPackage. The tests are run /// asynchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> public override void BeginRun(ITestEventHandler listener, TestFilter filter) { throw new NotImplementedException(); }
/// <summary> /// Run the tests in a loaded TestPackage. This is the interal /// implementation, returning a TestEngineResult. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> /// <returns>A TestEngineResult giving the result of the test execution</returns> public abstract TestEngineResult Run(ITestEventHandler listener, TestFilter filter);
/// <summary> /// Start a run of the tests in the loaded TestPackage. The tests are run /// asynchronously and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">An ITestEventHandler to receive events</param> /// <param name="filter">A TestFilter used to select tests</param> public override void BeginRun(ITestEventHandler listener, TestFilter filter) { this.remoteRunner.BeginRun(listener, filter); }
/// <summary> /// Run the tests in a loaded TestPackage /// </summary> /// <param name="filter">A TestFilter used to select tests</param> /// <returns>A TestResult giving the result of the test execution</returns> public override TestEngineResult Run(ITestEventHandler listener, TestFilter filter) { return((TestEngineResult)this.remoteRunner.Run(listener, filter)); }