public override bool OnMessage(IMessageSinkMessage message)
{
return(DoVisit <ITestProgressMessage>(message, m => Visit(m)) &&
DoVisit <ITestSummaryStatisticsMessage>(message, m => Visit(m)) &&
DoVisit <ITestStatisticsMessage>(message, m => Visit(m)) &&
base.OnMessage(message));
}
/// <inheritdoc/>
public override bool OnMessage(IMessageSinkMessage message)
{
var result = base.OnMessage(message);
result = innerMessageSink.OnMessage(message) || result;
return(result);
}
protected override bool OnMessage(IMessageSinkMessage message)
{
var testFailed = message as ITestFailed;
if (testFailed != null)
{
OnTestFailed(testFailed);
}
var testPassed = message as ITestPassed;
if (testPassed != null)
{
OnTestPassed(testPassed);
}
var testSkipped = message as ITestSkipped;
if (testSkipped != null)
{
OnTestSkipped(testSkipped);
}
if (message is ITestAssemblyFinished)
{
Finished.Set();
}
return ShouldContinue;
}
public DelegatingExecutionSummarySinkTests()
{
innerSink = Substitute.For <IMessageSinkWithTypes>();
innerSink.OnMessageWithTypes(null, null).ReturnsForAnyArgs(true);
testMessage = Substitute.For <IMessageSinkMessage>();
}
private void OnMessageHandled(IMessageSinkMessage message)
{
if (message is ITestCollectionFinished testCollectionFinished)
{
TestCollectionFinished?.Invoke(this, testCollectionFinished.TestCollection);
}
}
public bool OnMessageWithTypes(IMessageSinkMessage message, HashSet <string> messageTypes)
{
var result = _innerSink.OnMessageWithTypes(message, messageTypes);
message.Dispatch <ITestAssemblyFinished>(messageTypes, args => _completionCallback(ExecutionSummary));
return(result);
}
/// <inheritdoc/> public bool OnMessageWithTypes(IMessageSinkMessage message, HashSet <string> messageTypes) => message.Dispatch(messageTypes, AfterTestFinishedEvent) && message.Dispatch(messageTypes, AfterTestStartingEvent) && message.Dispatch(messageTypes, BeforeTestFinishedEvent) && message.Dispatch(messageTypes, BeforeTestStartingEvent) && message.Dispatch(messageTypes, TestAssemblyCleanupFailureEvent) && message.Dispatch(messageTypes, TestAssemblyFinishedEvent) && message.Dispatch(messageTypes, TestAssemblyStartingEvent) && message.Dispatch(messageTypes, TestCaseCleanupFailureEvent) && message.Dispatch(messageTypes, TestCaseFinishedEvent) && message.Dispatch(messageTypes, TestCaseStartingEvent) && message.Dispatch(messageTypes, TestClassCleanupFailureEvent) && message.Dispatch(messageTypes, TestClassConstructionFinishedEvent) && message.Dispatch(messageTypes, TestClassConstructionStartingEvent) && message.Dispatch(messageTypes, TestClassDisposeFinishedEvent) && message.Dispatch(messageTypes, TestClassDisposeStartingEvent) && message.Dispatch(messageTypes, TestClassFinishedEvent) && message.Dispatch(messageTypes, TestClassStartingEvent) && message.Dispatch(messageTypes, TestCleanupFailureEvent) && message.Dispatch(messageTypes, TestCollectionCleanupFailureEvent) && message.Dispatch(messageTypes, TestCollectionFinishedEvent) && message.Dispatch(messageTypes, TestCollectionStartingEvent) && message.Dispatch(messageTypes, TestFailedEvent) && message.Dispatch(messageTypes, TestFinishedEvent) && message.Dispatch(messageTypes, TestMethodCleanupFailureEvent) && message.Dispatch(messageTypes, TestMethodFinishedEvent) && message.Dispatch(messageTypes, TestMethodStartingEvent) && message.Dispatch(messageTypes, TestOutputEvent) && message.Dispatch(messageTypes, TestPassedEvent) && message.Dispatch(messageTypes, TestSkippedEvent) && message.Dispatch(messageTypes, TestStartingEvent);
// making sure all texts are Xml valid
public static IMessageSinkMessage SanitizeXml(this IMessageSinkMessage message)
{
var failed = message as TestFailed;
if (failed != null)
{
return(new TestFailed(failed.Test,
failed.ExecutionTime,
XmlUtility.Sanitize(failed.Output),
failed.ExceptionTypes,
failed.Messages == null ? null : failed.Messages.Select(m => XmlUtility.Sanitize(m)).ToArray(),
failed.StackTraces,
failed.ExceptionParentIndices));
}
var skipped = message as TestSkipped;
if (skipped != null)
{
skipped = new TestSkipped(skipped.Test, XmlUtility.Sanitize(skipped.Reason));
skipped.SetOutput(XmlUtility.Sanitize(skipped.Output));
return(skipped);
}
var passed = message as TestPassed;
if (passed != null)
{
return(new TestPassed(passed.Test, passed.ExecutionTime, XmlUtility.Sanitize(passed.Output)));
}
return(message);
}
HashSet<string> GetMessageTypes(IMessageSinkMessage message)
{
var messageType = message.GetType();
HashSet<string> result;
cacheLock.TryEnterReadLock(-1);
try
{
interfaceCache.TryGetValue(messageType, out result);
}
finally
{
cacheLock.ExitReadLock();
}
if (result == null)
{
cacheLock.TryEnterWriteLock(-1);
try
{
result = new HashSet<string>(messageType.GetInterfaces().Select(x => x.FullName));
interfaceCache[messageType] = result;
}
finally
{
cacheLock.ExitWriteLock();
}
}
return result;
}
public bool OnMessage(IMessageSinkMessage message)
{
var testCaseDiscoveryMessage = message as ITestCaseDiscoveryMessage;
if (testCaseDiscoveryMessage != null)
{
//TODO: Improve this
if (Regex.IsMatch(testCaseDiscoveryMessage.TestClass.Class.Name, @"\d+$"))
{
var details = GetTestDetails(testCaseDiscoveryMessage);
List <NodeTest> tests;
if (Tests.TryGetValue(details.TestName, out tests))
{
tests.Add(details);
}
else
{
tests = new List <NodeTest>(new[] { details });
}
Tests[details.TestName] = tests;
}
}
if (message is IDiscoveryCompleteMessage)
{
Finished.Set();
}
return(true);
}
protected override bool OnMessage(IMessageSinkMessage message)
{
var testFailed = message as ITestFailed;
if (testFailed != null)
{
OnTestFailed(testFailed);
}
var testPassed = message as ITestPassed;
if (testPassed != null)
{
OnTestPassed(testPassed);
}
var testSkipped = message as ITestSkipped;
if (testSkipped != null)
{
OnTestSkipped(testSkipped);
}
if (message is ITestAssemblyFinished)
{
Finished.Set();
}
return(ShouldContinue);
}
public bool QueueMessage(IMessageSinkMessage message)
{
_listener.Flush();
var output = GetActualOutput();
// Inject Trace.WriteLine calls that might have happened as the test output.
if (message is ITestResultMessage && !string.IsNullOrEmpty(output))
{
var passed = message as ITestPassed;
var failed = message as ITestFailed;
if (passed != null)
{
_buffer.GetStringBuilder().Clear();
return(_innerBus.QueueMessage(new TestPassed(passed.Test, passed.ExecutionTime,
string.IsNullOrEmpty(passed.Output) ? output : passed.Output + Environment.NewLine + output)));
}
if (failed != null)
{
_buffer.GetStringBuilder().Clear();
return(_innerBus.QueueMessage(new TestFailed(failed.Test, failed.ExecutionTime,
string.IsNullOrEmpty(failed.Output) ? output : failed.Output + Environment.NewLine + output,
failed.ExceptionTypes, failed.Messages, failed.StackTraces, failed.ExceptionParentIndices)));
}
}
if (message is ITestMethodMessage)
{
return(_innerBus.QueueMessage(message));
}
return(true);
}
public void AddsErrorMessagesToXml(IMessageSinkMessage errorMessage, string messageType, string name)
{
var assemblyFinished = Substitute.For <ITestAssemblyFinished>();
var assemblyElement = new XElement("assembly");
var visitor = new XmlTestExecutionVisitor(assemblyElement, () => false);
visitor.OnMessage(errorMessage);
visitor.OnMessage(assemblyFinished);
var errorElement = Assert.Single(assemblyElement.Element("errors").Elements());
Assert.Equal(messageType, errorElement.Attribute("type").Value);
if (name == null)
{
Assert.Null(errorElement.Attribute("name"));
}
else
{
Assert.Equal(name, errorElement.Attribute("name").Value);
}
var failureElement = Assert.Single(errorElement.Elements("failure"));
Assert.Equal("ExceptionType", failureElement.Attribute("exception-type").Value);
Assert.Equal("ExceptionType : This is my message \\t\\r\\n", failureElement.Elements("message").Single().Value);
Assert.Equal("Line 1\r\nLine 2\r\nLine 3", failureElement.Elements("stack-trace").Single().Value);
}
public bool QueueMessage(IMessageSinkMessage message)
{
var result = message as TestResultMessage;
if (result != null && String.IsNullOrEmpty(result.Output))
{
result.SetOutput(TestTracer.GetTraceString());
}
lock (_messages)
{
var testFailed = result as TestFailed;
if (testFailed != null && testFailed.ExceptionTypes.LastOrDefault() == typeof(KuduXunitTestSkippedException).FullName)
{
TestSkipped = true;
message = new TestSkipped(result.Test, testFailed.Messages.LastOrDefault() ?? "unknown");
}
_messages.Add(message);
}
// No way to ask the inner bus if they want to cancel without sending them the message, so
// we just go ahead and continue always.
return(true);
}
public bool OnMessage(IMessageSinkMessage message)
{
if (showDiagnostics && message is IDiagnosticMessage diagnosticMessage)
{
lock (consoleLock)
{
if (!noColor)
{
ConsoleHelper.SetForegroundColor(displayColor);
}
if (assemblyDisplayName != null)
{
Console.WriteLine($" {assemblyDisplayName}: {diagnosticMessage.Message}");
}
else
{
Console.WriteLine($" {diagnosticMessage.Message}");
}
if (!noColor)
{
ConsoleHelper.ResetColor();
}
}
}
return(true);
}
/// <inheritdoc/>
public bool OnMessageWithTypes(IMessageSinkMessage message, HashSet <string> messageTypes)
{
var result = executionSink.OnMessageWithTypes(message, messageTypes);
result = innerSink.OnMessageWithTypes(message, messageTypes) && result;
return(result);
}
public DelegatingExecutionSummarySinkTests()
{
innerSink = Substitute.For<IMessageSinkWithTypes>();
innerSink.OnMessageWithTypes(null, null).ReturnsForAnyArgs(true);
testMessage = Substitute.For<IMessageSinkMessage>();
}
public bool OnMessage(IMessageSinkMessage message)
{
var testCaseDiscoveryMessage = message as ITestCaseDiscoveryMessage;
if (testCaseDiscoveryMessage != null)
{
//TODO: Improve this
if (Regex.IsMatch(testCaseDiscoveryMessage.TestClass.Class.Name, @"\d+$"))
{
var details = GetTestDetails(testCaseDiscoveryMessage);
List<NodeTest> tests;
if (Tests.TryGetValue(details.TestName, out tests))
{
tests.Add(details);
}
else
{
tests = new List<NodeTest>(new[] {details});
}
Tests[details.TestName] = tests;
}
}
if (message is IDiscoveryCompleteMessage)
Finished.Set();
return true;
}
/// <inheritdoc/>
public virtual bool OnMessage(IMessageSinkMessage message)
{
return
(DoVisit <IAfterTestFinished>(message, Visit) &&
DoVisit <IAfterTestStarting>(message, Visit) &&
DoVisit <IBeforeTestFinished>(message, Visit) &&
DoVisit <IBeforeTestStarting>(message, Visit) &&
DoVisit <IDiscoveryCompleteMessage>(message, Visit) &&
DoVisit <IErrorMessage>(message, Visit) &&
DoVisit <ITestAssemblyFinished>(message, Visit) &&
DoVisit <ITestAssemblyStarting>(message, Visit) &&
DoVisit <ITestCaseDiscoveryMessage>(message, Visit) &&
DoVisit <ITestCaseFinished>(message, Visit) &&
DoVisit <ITestCaseStarting>(message, Visit) &&
DoVisit <ITestClassConstructionFinished>(message, Visit) &&
DoVisit <ITestClassConstructionStarting>(message, Visit) &&
DoVisit <ITestClassDisposeFinished>(message, Visit) &&
DoVisit <ITestClassDisposeStarting>(message, Visit) &&
DoVisit <ITestClassFinished>(message, Visit) &&
DoVisit <ITestClassStarting>(message, Visit) &&
DoVisit <ITestCollectionFinished>(message, Visit) &&
DoVisit <ITestCollectionStarting>(message, Visit) &&
DoVisit <ITestFailed>(message, Visit) &&
DoVisit <ITestFinished>(message, Visit) &&
DoVisit <ITestMethodFinished>(message, Visit) &&
DoVisit <ITestMethodStarting>(message, Visit) &&
DoVisit <ITestPassed>(message, Visit) &&
DoVisit <ITestSkipped>(message, Visit) &&
DoVisit <ITestStarting>(message, Visit));
}
/// <inheritdoc/>
public virtual bool QueueMessage(IMessageSinkMessage message)
{
if (callback != null)
callback(message);
return innerMessageBus.QueueMessage(message);
}
HashSet <string> GetMessageTypes(IMessageSinkMessage message)
{
var messageType = message.GetType();
HashSet <string> result;
cacheLock.TryEnterReadLock(-1);
try
{
interfaceCache.TryGetValue(messageType, out result);
}
finally
{
cacheLock.ExitReadLock();
}
if (result == null)
{
cacheLock.TryEnterWriteLock(-1);
try
{
result = new HashSet <string>(messageType.GetInterfaces().Select(x => x.FullName));
interfaceCache[messageType] = result;
}
finally
{
cacheLock.ExitWriteLock();
}
}
return(result);
}
public bool QueueMessage(IMessageSinkMessage message)
{
if (this.invalidConfigurationExpected)
{
if (message is TestFailed)
{
// TODO: allow for derived types of allowed exceptions
var failedMessage = (TestFailed)message;
if (failedMessage.ExceptionTypes.Length > 0 &&
AllowedFailureExceptionTypes.Any(t => t.FullName == failedMessage.ExceptionTypes[0]))
{
message = new TestPassed(failedMessage.Test, failedMessage.ExecutionTime, failedMessage.Output);
this.InvertedFailures++;
}
}
else if (message is TestPassed)
{
var passedMessage = (TestPassed)message;
message = new TestFailed(passedMessage.Test, passedMessage.ExecutionTime, passedMessage.Output, new AssertActualExpectedException(false, true, "Expected invalid configuration but no exception thrown."));
this.InvertedSuccesses++;
}
}
return(this.inner.QueueMessage(message));
}
/// <summary>
/// Reports the presence of a message on the message bus with an optional list of message types.
/// This method should never throw exceptions.
/// </summary>
/// <param name="message">The message from the message bus.</param>
/// <param name="messageTypes">The list of message types, or <see language="null"/>.</param>
/// <returns>Return <see language="true"/> to continue running tests, or <see language="false"/> to stop.</returns>
public bool OnMessageWithTypes(
IMessageSinkMessage message
, HashSet <string> messageTypes
)
{
throw new NotImplementedException( );
}
static HashSet <string>?GetImplementedInterfaces(IMessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
if (message is IMessageSinkMessageWithTypes messageWithTypes)
{
return(messageWithTypes.InterfaceTypes);
}
#if NETFRAMEWORK
// Can't get the list of interfaces across the remoting boundary
if (System.Runtime.Remoting.RemotingServices.IsTransparentProxy(message))
{
return(null);
}
#endif
var result = new HashSet <string>(message.GetType().GetInterfaces().Select(i => i.FullName !), StringComparer.OrdinalIgnoreCase);
// TODO: Hack this to include the concrete type, while we transition from v2 to v3 so that we
// can support our new message types which aren't interfaces.
result.Add(message.GetType().FullName !);
return(result);
}
/// <inheritdoc />
public bool QueueMessage(IMessageSinkMessage message)
{
if (message is TestFailed failed)
{
var outerException = failed.ExceptionTypes.FirstOrDefault();
bool skipTest = false;
string?skipReason = null;
switch (outerException)
{
case string _ when this.ShouldSkipException(outerException):
skipTest = true;
skipReason = failed.Messages?.FirstOrDefault();
break;
case "Xunit.Sdk.ThrowsException" when failed.ExceptionTypes.Length > 1:
outerException = failed.ExceptionTypes[1];
if (this.ShouldSkipException(outerException))
{
skipTest = true;
skipReason = failed.Messages?.Length > 1 ? failed.Messages[1] : null;
}
break;
}
if (skipTest)
{
this.SkippedCount++;
return(this.inner.QueueMessage(new TestSkipped(failed.Test, skipReason)));
}
}
return(this.inner.QueueMessage(message));
}
/// <inheritdoc/>
public virtual bool OnMessage(IMessageSinkMessage message)
{
if (callback != null)
callback(message);
return innerSink.OnMessage(message);
}
private void OnMessage(IMessageSinkMessage obj)
{
var testCaseFinishedMessage = obj as ITestCaseFinished;
if (testCaseFinishedMessage != null)
{
_receivers.ForEach(receiver => receiver.OnTestCaseFinished(testCaseFinishedMessage));
}
}
public bool QueueMessage(IMessageSinkMessage message)
{
_messageQueue.Enqueue(message);
// Returns if execution should continue. Since we are intercepting the message, we
// have no way of checking this so always continue...
return(true);
}
public bool QueueMessage (IMessageSinkMessage message)
{
var result = innerBus.QueueMessage (message);
callbacks.ForEach (callback => callback (message));
return result;
}
public bool OnMessage(IMessageSinkMessage message)
{
if (message is IDiagnosticMessage diagnosticMessage)
{
return(true);
}
return(false);
}
public bool QueueMessage(IMessageSinkMessage message)
{
return(RunInjections(_testCaseStartingInjections, message) &&
RunInjections(_testStartingInjections, message) &&
RunInjections(_testFinishedInjections, message) &&
RunInjections(_testCaseFinishedInjections, message) &&
_innerMessageBus.QueueMessage(message));
}
/// <inheritdoc />
public bool QueueMessage(IMessageSinkMessage message)
{
lock (_messages)
_messages.Add(message);
// No way to ask the inner bus if they want to cancel without sending them the message, so
// we just go ahead and continue always.
return(true);
}
/// <inheritdoc/>
public virtual bool OnMessage(IMessageSinkMessage message)
{
if (callback != null)
{
callback(message);
}
return(innerSink.OnMessage(message));
}
public bool QueueMessage(IMessageSinkMessage message)
{
lock (messages)
messages.Add(message);
// No way to ask the inner bus if they want to cancel without sending them the message, so
// we just go ahead and continue always.
return true;
}
public bool QueueMessage(IMessageSinkMessage message)
{
lock (this.delayedMessages)
{
this.delayedMessages.Add(message);
}
return(true);
}
/// <summary/>
public bool QueueMessage(IMessageSinkMessage message)
{
if (shutdownRequested)
throw new ObjectDisposedException("MessageBus");
reporterQueue.Enqueue(message);
reporterWorkEvent.Set();
return continueRunning;
}
public bool OnMessage(IMessageSinkMessage message)
{
if (message is IDiagnosticMessage diagnosticMessage)
{
Console.WriteLine(diagnosticMessage.Message);
}
return(true);
}
/// <summary>
/// Forwards the message on to all subscribed visitors
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public override bool OnMessage(IMessageSinkMessage message)
{
foreach (var visitor in _visitors)
{
visitor.OnMessage(message);
}
return(base.OnMessage(message));
}
bool IMessageSinkWithTypes.OnMessageWithTypes(IMessageSinkMessage message, HashSet <string> messageTypes)
{
DispatchMessage <ITestCaseDiscoveryMessage>(message, messageTypes, testDiscovered =>
testCasesToRun.Add(testDiscovered.TestCase));
DispatchMessage <IDiscoveryCompleteMessage>(message, messageTypes, discoveryComplete => discoveryCompleteEvent.Set());
DispatchMessage <ITestAssemblyFinished>(message, messageTypes, assemblyFinished => executionCompleteEvent.Set());
return(true);
}
public static string GetIdentifier(IMessageSinkMessage message)
{
return GetIdentifier(message as ITestMessage)
?? GetIdentifier(message as ITestCaseMessage)
?? GetIdentifier(message as ITestMethodMessage)
?? GetIdentifier(message as ITestClassMessage)
?? GetIdentifier(message as ITestCollectionMessage)
?? GetIdentifier(message as ITestAssemblyMessage)
?? "Unknown message";
}
public bool QueueMessage(IMessageSinkMessage message)
{
var result = message as TestResultMessage;
if (result != null && String.IsNullOrEmpty(result.Output))
{
result.SetOutput(TestTracer.GetTraceString());
}
return _innerBus.QueueMessage(message.SanitizeXml());
}
/// <inheritdoc/>
public bool OnMessage(IMessageSinkMessage message)
{
var discoveryMessage = message as ITestCaseDiscoveryMessage;
if (discoveryMessage != null)
TestCases.Add(discoveryMessage.TestCase);
if (message is IDiscoveryCompleteMessage)
Finished.Set();
return true;
}
public void Dispose() { } // Assume the thing we're wrapping gets disposed elsewhere
/// <summary>
/// Returns the implemented interface types, if known.
/// </summary>
/// <param name="message">The message interfaces to retrieve.</param>
/// <returns>The hash set of interfaces, if known; <c>null</c>, otherwise.</returns>
public static HashSet<string> GetImplementedInterfaces(IMessageSinkMessage message)
{
var messageWithTypes = message as IMessageSinkMessageWithTypes;
if (messageWithTypes != null)
return messageWithTypes.InterfaceTypes;
#if !PLATFORM_DOTNET
// Can't get the list of interfaces across the remoting boundary
if (System.Runtime.Remoting.RemotingServices.IsTransparentProxy(message))
return null;
#endif
return new HashSet<string>(message.GetType().GetInterfaces().Select(i => i.FullName), StringComparer.OrdinalIgnoreCase);
}
/// <inheritdoc />
public bool QueueMessage(IMessageSinkMessage message)
{
var failed = message as TestFailed;
if (failed != null)
{
if (failed.ExceptionTypes.Length == 1 && Array.IndexOf(this.SkippingExceptionNames, failed.ExceptionTypes[0]) >= 0)
{
this.SkippedCount++;
return this.inner.QueueMessage(new TestSkipped(failed.Test, failed.Messages[0]));
}
}
return this.inner.QueueMessage(message);
}
public bool QueueMessage(IMessageSinkMessage message)
{
var testFailed = message as ITestFailed;
if (testFailed != null)
{
var exceptionType = testFailed.ExceptionTypes.FirstOrDefault();
if (exceptionType == typeof(SkipTestException).FullName)
{
DynamicallySkippedTestCount++;
return _innerBus.QueueMessage(new TestSkipped(testFailed.Test, testFailed.Messages.FirstOrDefault()));
}
}
return _innerBus.QueueMessage(message);
}
/// <inheritdoc />
public bool QueueMessage(IMessageSinkMessage message)
{
var failed = message as TestFailed;
if (failed != null)
{
var outerException = failed.ExceptionTypes.FirstOrDefault();
if (outerException != null && Array.IndexOf(this.SkippingExceptionNames, outerException) >= 0)
{
this.SkippedCount++;
return this.inner.QueueMessage(new TestSkipped(failed.Test, failed.Messages[0]));
}
}
return this.inner.QueueMessage(message);
}
protected override bool OnMessage(IMessageSinkMessage message)
{
var discoveryMessage = message as ITestCaseDiscoveryMessage;
if (discoveryMessage != null)
{
OnTestDiscovered(discoveryMessage);
}
if (message is IDiscoveryCompleteMessage)
{
Finished.Set();
}
return ShouldContinue;
}
/// <inheritdoc/>
public bool OnMessageWithTypes(IMessageSinkMessage message, HashSet<string> messageTypes)
{
var result = innerSink.OnMessageWithTypes(message, messageTypes);
return message.Dispatch<IErrorMessage>(messageTypes, args => Interlocked.Increment(ref errors))
&& message.Dispatch<ITestAssemblyCleanupFailure>(messageTypes, args => Interlocked.Increment(ref errors))
&& message.Dispatch<ITestAssemblyFinished>(messageTypes, HandleTestAssemblyFinished)
&& message.Dispatch<ITestCaseCleanupFailure>(messageTypes, args => Interlocked.Increment(ref errors))
&& message.Dispatch<ITestClassCleanupFailure>(messageTypes, args => Interlocked.Increment(ref errors))
&& message.Dispatch<ITestCleanupFailure>(messageTypes, args => Interlocked.Increment(ref errors))
&& message.Dispatch<ITestCollectionCleanupFailure>(messageTypes, args => Interlocked.Increment(ref errors))
&& message.Dispatch<ITestMethodCleanupFailure>(messageTypes, args => Interlocked.Increment(ref errors))
&& result
&& !cancelThunk();
}
public bool OnMessage(IMessageSinkMessage message)
{
var discoveryMessage = message as ITestCaseDiscoveryMessage;
if (discoveryMessage != null)
{
OnDiscoveryMessage(discoveryMessage);
}
if (message is IDiscoveryCompleteMessage)
{
Finished.Set();
}
return _writer.IsConnected;
}
public bool QueueMessage(IMessageSinkMessage message)
{
var testPassedMessage = message as ITestPassed;
if (testPassedMessage != null)
{
var output = string.Format(
CultureInfo.InvariantCulture,
"Execution time: {0}ms",
testPassedMessage.ExecutionTime * 1000);
message = new TestPassed(testPassedMessage.Test, testPassedMessage.ExecutionTime, output);
}
return this.inner.QueueMessage(message);
}
public bool QueueMessage(IMessageSinkMessage message)
{
var testFailed = message as ITestFailed;
if (testFailed != null)
{
var exceptionType = testFailed.ExceptionTypes.FirstOrDefault();
if (exceptionType == typeof(SkipStepException).FullName || exceptionType == typeof(NotImplementedException).FullName || exceptionType == typeof(SkipScenarioException).FullName)
{
DynamicallySkippedTestCount++;
return innerBus.QueueMessage(new TestSkipped(testFailed.Test, testFailed.Messages.FirstOrDefault()));
}
}
// Nothing we care about, send it on its way
return innerBus.QueueMessage(message);
}
public bool OnMessage(IMessageSinkMessage message)
{
var resultMessage = message as ITestResultMessage;
if (resultMessage != null)
{
_logger.Tell(resultMessage.Output);
Console.WriteLine(resultMessage.Output);
}
var testPassed = message as ITestPassed;
if (testPassed != null)
{
//the MultiNodeTestRunner uses 1-based indexing, which is why we have to add 1 to the index.
var specPass = new SpecPass(_nodeIndex + 1, testPassed.TestCase.DisplayName);
_logger.Tell(specPass.ToString());
Console.WriteLine(specPass.ToString()); //so the message also shows up in the individual per-node build log
Passed = true;
return true;
}
var testFailed = message as ITestFailed;
if (testFailed != null)
{
//the MultiNodeTestRunner uses 1-based indexing, which is why we have to add 1 to the index.
var specFail = new SpecFail(_nodeIndex + 1, testFailed.TestCase.DisplayName);
foreach (var failedMessage in testFailed.Messages) specFail.FailureMessages.Add(failedMessage);
foreach (var stackTrace in testFailed.StackTraces) specFail.FailureStackTraces.Add(stackTrace);
foreach(var exceptionType in testFailed.ExceptionTypes) specFail.FailureExceptionTypes.Add(exceptionType);
_logger.Tell(specFail.ToString());
Console.WriteLine(specFail.ToString());
return true;
}
var errorMessage = message as ErrorMessage;
if (errorMessage != null)
{
var specFail = new SpecFail(_nodeIndex + 1, "ERRORED");
foreach (var failedMessage in errorMessage.Messages) specFail.FailureMessages.Add(failedMessage);
foreach (var stackTrace in errorMessage.StackTraces) specFail.FailureStackTraces.Add(stackTrace);
foreach (var exceptionType in errorMessage.ExceptionTypes) specFail.FailureExceptionTypes.Add(exceptionType);
_logger.Tell(specFail.ToString());
Console.WriteLine(specFail.ToString());
}
if (message is ITestAssemblyFinished)
{
Finished.Set();
}
return true;
}
/// <inheritdoc/>
public bool OnMessageWithTypes(IMessageSinkMessage message, HashSet<string> messageTypes)
{
// Call the inner sink first, because we want to be able to depend on ExecutionSummary
// being correctly filled out.
var result = innerSink.OnMessageWithTypes(message, messageTypes);
return message.Dispatch<IErrorMessage>(messageTypes, HandleErrorMessage)
&& message.Dispatch<ITestAssemblyCleanupFailure>(messageTypes, HandleTestAssemblyCleanupFailure)
&& message.Dispatch<ITestAssemblyFinished>(messageTypes, HandleTestAssemblyFinished)
&& message.Dispatch<ITestAssemblyStarting>(messageTypes, HandleTestAssemblyStarting)
&& message.Dispatch<ITestCaseCleanupFailure>(messageTypes, HandleTestCaseCleanupFailure)
&& message.Dispatch<ITestClassCleanupFailure>(messageTypes, HandleTestClassCleanupFailure)
&& message.Dispatch<ITestCleanupFailure>(messageTypes, HandleTestCleanupFailure)
&& message.Dispatch<ITestCollectionCleanupFailure>(messageTypes, HandleTestCollectionCleanupFailure)
&& message.Dispatch<ITestCollectionFinished>(messageTypes, HandleTestCollectionFinished)
&& message.Dispatch<ITestFailed>(messageTypes, HandleTestFailed)
&& message.Dispatch<ITestMethodCleanupFailure>(messageTypes, HandleTestMethodCleanupFailure)
&& message.Dispatch<ITestPassed>(messageTypes, HandleTestPassed)
&& message.Dispatch<ITestSkipped>(messageTypes, HandleTestSkipped)
&& result;
}
/// <inheritdoc/>
public bool OnMessageWithTypes(IMessageSinkMessage message, HashSet<string> messageTypes)
{
var testSkipped = message.Cast<ITestSkipped>(messageTypes);
if (testSkipped != null)
{
skipCount++;
var testFailed = new TestFailed(testSkipped.Test, 0M, "",
new[] { "FAIL_SKIP" },
new[] { testSkipped.Reason },
new[] { "" },
new[] { -1 });
return innerSink.OnMessage(testFailed);
}
var testCollectionFinished = message.Cast<ITestCollectionFinished>(messageTypes);
if (testCollectionFinished != null)
{
testCollectionFinished = new TestCollectionFinished(testCollectionFinished.TestCases,
testCollectionFinished.TestCollection,
testCollectionFinished.ExecutionTime,
testCollectionFinished.TestsRun,
testCollectionFinished.TestsFailed + testCollectionFinished.TestsSkipped,
0);
return innerSink.OnMessage(testCollectionFinished);
}
var assemblyFinished = message.Cast<ITestAssemblyFinished>(messageTypes);
if (assemblyFinished != null)
{
assemblyFinished = new TestAssemblyFinished(assemblyFinished.TestCases,
assemblyFinished.TestAssembly,
assemblyFinished.ExecutionTime,
assemblyFinished.TestsRun,
assemblyFinished.TestsFailed + assemblyFinished.TestsSkipped,
0);
return innerSink.OnMessage(assemblyFinished);
}
return innerSink.OnMessageWithTypes(message, messageTypes);
}
public bool OnMessage(IMessageSinkMessage message)
{
Console.WriteLine(message.ToString());
return true;
}
/// <inheritdoc/>
public override bool OnMessage(IMessageSinkMessage message)
{
var result = base.OnMessage(message);
result = innerMessageSink.OnMessage(message) || result;
return result;
}
/// <summary/>
public bool OnMessage(IMessageSinkMessage message)
{
return InnerSink.OnMessage(message);
}
/// <inheritdoc/>
public bool OnMessageWithTypes(IMessageSinkMessage message, HashSet<string> messageTypes)
=> true;
/// <inheritdoc/>
public bool OnMessage(IMessageSinkMessage message)
=> true;
bool IMessageSink.OnMessage(IMessageSinkMessage message)
{
return OnMessage(message);
}
