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