public void Start()
{
lock (statusLock)
{
if (Status != AssemblyRunnerStatus.Idle)
{
throw new InvalidOperationException("Cannot start the runner");
}
testCasesToRun.Clear();
discoveryCompleteEvent.Reset();
executionCompleteEvent.Reset();
}
ExecutionXml = new XElement("assembly");
Task.Factory.StartNew(() =>
{
var xmlCreationSink = new XmlCreationSinkDecorator(this);
controller.Find(false, this, GetDiscoveryOptions());
discoveryCompleteEvent.WaitOne();
controller.RunTests(testCasesToRun, xmlCreationSink, GetExecutionOptions());
executionCompleteEvent.WaitOne();
ExecutionXml = xmlCreationSink.GetBuiltXml();
OnExecutionComplete?.Invoke(ExecutionXml);
});
}
internal static void fireExecutionCompleteEvent(TestExecutor testExecutor, TestExecutionCompleteArgs args)
{
OnExecutionComplete?.Invoke(testExecutor, args);
}
bool IMessageSinkWithTypes.OnMessageWithTypes(IMessageSinkMessage message, HashSet <string> messageTypes)
{
if (cancellationToken.IsCancellationRequested)
{
cancelled = true;
}
if (DispatchMessage <ITestCaseDiscoveryMessage>(message, messageTypes, testDiscovered =>
{
++testCasesDiscovered;
if (TestCaseFilter == null || TestCaseFilter(testDiscovered.TestCase))
{
testCasesToRun.Add(testDiscovered.TestCase);
}
}))
{
return(!cancelled);
}
if (DispatchMessage <IDiscoveryCompleteMessage>(message, messageTypes, discoveryComplete =>
{
OnDiscoveryComplete?.Invoke(new TestDiscoveryInfo(testCasesToRun, assemblyFileName));
tcs.TrySetResult("");
}))
{
return(!cancelled);
}
if (DispatchMessage <ITestAssemblyFinished>(message, messageTypes, assemblyFinished =>
{
OnExecutionComplete?.Invoke(new ExecutionCompleteInfo(assemblyFinished.TestsRun, assemblyFinished.TestsFailed, assemblyFinished.TestsSkipped, assemblyFinished.ExecutionTime));
tcs.TrySetResult("");
}))
{
return(!cancelled);
}
if (OnDiagnosticMessage != null)
{
if (DispatchMessage <IDiagnosticMessage>(message, messageTypes, m => OnDiagnosticMessage(new DiagnosticMessageInfo(m.Message))))
{
return(!cancelled);
}
}
if (OnTestFailed != null)
{
if (DispatchMessage <ITestFailed>(message, messageTypes, m => OnTestFailed(new TestFailedInfo(m.TestClass.Class.Name, m.TestMethod.Method.Name, m.TestCase.Traits, m.Test.DisplayName, m.TestCollection.DisplayName, m.ExecutionTime, m.Output, m.ExceptionTypes.FirstOrDefault(), m.Messages.FirstOrDefault(), m.StackTraces.FirstOrDefault()))))
{
return(!cancelled);
}
}
if (OnTestFinished != null)
{
if (DispatchMessage <ITestFinished>(message, messageTypes, m => OnTestFinished(new TestFinishedInfo(m.TestClass.Class.Name, m.TestMethod.Method.Name, m.TestCase.Traits, m.Test.DisplayName, m.TestCollection.DisplayName, m.ExecutionTime, m.Output))))
{
return(!cancelled);
}
}
if (OnTestOutput != null)
{
if (DispatchMessage <ITestOutput>(message, messageTypes, m => OnTestOutput(new TestOutputInfo(m.TestClass.Class.Name, m.TestMethod.Method.Name, m.TestCase.Traits, m.Test.DisplayName, m.TestCollection.DisplayName, m.Output))))
{
return(!cancelled);
}
}
if (OnTestPassed != null)
{
if (DispatchMessage <ITestPassed>(message, messageTypes, m => OnTestPassed(new TestPassedInfo(m.TestClass.Class.Name, m.TestMethod.Method.Name, m.TestCase.Traits, m.Test.DisplayName, m.TestCollection.DisplayName, m.ExecutionTime, m.Output))))
{
return(!cancelled);
}
}
if (OnTestSkipped != null)
{
if (DispatchMessage <ITestSkipped>(message, messageTypes, m => OnTestSkipped(new TestSkippedInfo(m.TestClass.Class.Name, m.TestMethod.Method.Name, m.TestCase.Traits, m.Test.DisplayName, m.TestCollection.DisplayName, m.Reason))))
{
return(!cancelled);
}
}
if (OnTestStarting != null)
{
if (DispatchMessage <ITestStarting>(message, messageTypes, m => OnTestStarting(new TestStartingInfo(m.TestClass.Class.Name, m.TestMethod.Method.Name, m.TestCase.Traits, m.Test.DisplayName, m.TestCollection.DisplayName))))
{
return(!cancelled);
}
}
if (OnErrorMessage != null)
{
if (DispatchMessage <IErrorMessage>(message, messageTypes, m => OnErrorMessage(new ErrorMessageInfo(ErrorMessageType.CatastrophicError, m.ExceptionTypes.FirstOrDefault(), m.Messages.FirstOrDefault(), m.StackTraces.FirstOrDefault()))))
{
return(!cancelled);
}
if (DispatchMessage <ITestAssemblyCleanupFailure>(message, messageTypes, m => OnErrorMessage(new ErrorMessageInfo(ErrorMessageType.TestAssemblyCleanupFailure, m.ExceptionTypes.FirstOrDefault(), m.Messages.FirstOrDefault(), m.StackTraces.FirstOrDefault()))))
{
return(!cancelled);
}
if (DispatchMessage <ITestCaseCleanupFailure>(message, messageTypes, m => OnErrorMessage(new ErrorMessageInfo(ErrorMessageType.TestCaseCleanupFailure, m.ExceptionTypes.FirstOrDefault(), m.Messages.FirstOrDefault(), m.StackTraces.FirstOrDefault()))))
{
return(!cancelled);
}
if (DispatchMessage <ITestClassCleanupFailure>(message, messageTypes, m => OnErrorMessage(new ErrorMessageInfo(ErrorMessageType.TestClassCleanupFailure, m.ExceptionTypes.FirstOrDefault(), m.Messages.FirstOrDefault(), m.StackTraces.FirstOrDefault()))))
{
return(!cancelled);
}
if (DispatchMessage <ITestCleanupFailure>(message, messageTypes, m => OnErrorMessage(new ErrorMessageInfo(ErrorMessageType.TestCleanupFailure, m.ExceptionTypes.FirstOrDefault(), m.Messages.FirstOrDefault(), m.StackTraces.FirstOrDefault()))))
{
return(!cancelled);
}
if (DispatchMessage <ITestCollectionCleanupFailure>(message, messageTypes, m => OnErrorMessage(new ErrorMessageInfo(ErrorMessageType.TestCollectionCleanupFailure, m.ExceptionTypes.FirstOrDefault(), m.Messages.FirstOrDefault(), m.StackTraces.FirstOrDefault()))))
{
return(!cancelled);
}
if (DispatchMessage <ITestMethodCleanupFailure>(message, messageTypes, m => OnErrorMessage(new ErrorMessageInfo(ErrorMessageType.TestMethodCleanupFailure, m.ExceptionTypes.FirstOrDefault(), m.Messages.FirstOrDefault(), m.StackTraces.FirstOrDefault()))))
{
return(!cancelled);
}
}
return(!cancelled);
}
private void FireExecutionCompleteEvent(TestSuite testSuite, TestSuiteResult testSuiteResult)
{
OnExecutionComplete?.Invoke(testSuite, testSuiteResult);
}