public static void DefaultRunStateIsNoTests()
{
var listener = Substitute.For <ITestListener>();
var visitor = new ResultSink(listener, 42);
Assert.Equal(TestRunState.NoTests, visitor.TestRunState);
}
public async ValueTask TestCollectionCleanupFailure()
{
var collectionStarting = new _TestCollectionStarting
{
AssemblyUniqueID = assemblyID,
TestCollectionDisplayName = "FooBar",
TestCollectionUniqueID = collectionID
};
var collectionCleanupFailure = new _TestCollectionCleanupFailure
{
AssemblyUniqueID = assemblyID,
ExceptionParentIndices = exceptionParentIndices,
ExceptionTypes = exceptionTypes,
Messages = messages,
StackTraces = stackTraces,
TestCollectionUniqueID = collectionID
};
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42)
{
TestRunState = TestRunState.NoTests
};
sink.OnMessage(collectionStarting);
sink.OnMessage(collectionCleanupFailure);
AssertFailure(listener, sink.TestRunState, "Test Collection Cleanup Failure (FooBar)");
}
public static void ConvertsITestFailed()
{
Exception ex;
try
{
throw new Exception();
}
catch (Exception e)
{
ex = e;
}
TestResult testResult = null;
var listener = Substitute.For <ITestListener>();
listener.WhenAny(l => l.TestFinished(null))
.Do <TestResult>(result => testResult = result);
var visitor = new ResultSink(listener, 42);
var message = Mocks.TestFailed(typeof(object), nameof(object.GetHashCode), "Display Name", executionTime: 123.45M, ex: ex);
visitor.OnMessageWithTypes(message, null);
Assert.NotNull(testResult);
Assert.Same(typeof(object), testResult.FixtureType);
Assert.Equal(nameof(object.GetHashCode), testResult.Method.Name);
Assert.Equal("Display Name", testResult.Name);
Assert.Equal(TestState.Failed, testResult.State);
Assert.Equal(123.45, testResult.TimeSpan.TotalMilliseconds);
Assert.Equal(42, testResult.TotalTests);
Assert.Equal("System.Exception : " + ex.Message, testResult.Message);
Assert.Equal(ex.StackTrace, testResult.StackTrace);
}
public async ValueTask TestAssemblyCleanupFailure()
{
var collectionStarting = new _TestAssemblyStarting
{
AssemblyUniqueID = assemblyID,
AssemblyPath = "assembly-file-path"
};
var collectionCleanupFailure = new _TestAssemblyCleanupFailure
{
AssemblyUniqueID = assemblyID,
ExceptionParentIndices = exceptionParentIndices,
ExceptionTypes = exceptionTypes,
Messages = messages,
StackTraces = stackTraces
};
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42)
{
TestRunState = TestRunState.NoTests
};
sink.OnMessage(collectionStarting);
sink.OnMessage(collectionCleanupFailure);
AssertFailure(listener, sink.TestRunState, "Test Assembly Cleanup Failure (assembly-file-path)");
}
public async ValueTask TestMethodCleanupFailure()
{
var methodStarting = new _TestMethodStarting
{
AssemblyUniqueID = assemblyID,
TestClassUniqueID = classID,
TestCollectionUniqueID = collectionID,
TestMethod = "MyMethod",
TestMethodUniqueID = methodID,
};
var methodCleanupFailure = new _TestMethodCleanupFailure
{
AssemblyUniqueID = assemblyID,
ExceptionParentIndices = exceptionParentIndices,
ExceptionTypes = exceptionTypes,
Messages = messages,
StackTraces = stackTraces,
TestCollectionUniqueID = collectionID,
TestClassUniqueID = classID,
TestMethodUniqueID = methodID
};
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42)
{
TestRunState = TestRunState.NoTests
};
sink.OnMessage(methodStarting);
sink.OnMessage(methodCleanupFailure);
AssertFailure(listener, sink.TestRunState, "Test Method Cleanup Failure (MyMethod)");
}
public static async void DefaultRunStateIsNoTests()
{
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42);
Assert.Equal(TestRunState.NoTests, sink.TestRunState);
}
public static ResultSink Push(HttpContextBase ctx, string route)
{
var r = new ResultSink {
_prev = ctx.Items[Key], _route = route
};
ctx.Items[Key] = r;
return(r);
}
public static void SignalsFinishedEventUponReceiptOfITestAssemblyFinished()
{
var listener = Substitute.For <ITestListener>();
var visitor = new ResultSink(listener, 42);
var message = Substitute.For <ITestAssemblyFinished>();
visitor.OnMessageWithTypes(message, null);
Assert.True(visitor.Finished.WaitOne(0));
}
public static async void SignalsFinishedEventUponReceiptOfITestAssemblyFinished()
{
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42);
var message = TestData.TestAssemblyFinished();
sink.OnMessage(message);
Assert.True(sink.Finished.WaitOne(0));
}
public static void FailureSetsStateToFailed(TestRunState initialState)
{
var listener = Substitute.For <ITestListener>();
var visitor = new ResultSink(listener, 42)
{
TestRunState = initialState
};
visitor.OnMessageWithTypes(Mocks.TestFailed(typeof(object), "GetHashCode"), null);
Assert.Equal(TestRunState.Failure, visitor.TestRunState);
}
public static void Skip_MovesToSuccess()
{
var listener = Substitute.For <ITestListener>();
var visitor = new ResultSink(listener, 42)
{
TestRunState = TestRunState.NoTests
};
visitor.OnMessageWithTypes(Substitute.For <ITestSkipped>(), null);
Assert.Equal(TestRunState.Success, visitor.TestRunState);
}
public static void Skip_StaysInCurrentState(TestRunState initialState)
{
var listener = Substitute.For <ITestListener>();
var visitor = new ResultSink(listener, 42)
{
TestRunState = initialState
};
visitor.OnMessageWithTypes(Substitute.For <ITestSkipped>(), null);
Assert.Equal(initialState, visitor.TestRunState);
}
public static async void Skip_MovesToSuccess()
{
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42)
{
TestRunState = TestRunState.NoTests
};
sink.OnMessage(TestData.TestClassStarting());
sink.OnMessage(TestData.TestMethodStarting());
sink.OnMessage(TestData.TestStarting());
sink.OnMessage(TestData.TestSkipped());
Assert.Equal(TestRunState.Success, sink.TestRunState);
}
public static async void FailureSetsStateToFailed(TestRunState initialState)
{
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42)
{
TestRunState = initialState
};
sink.OnMessage(TestData.TestClassStarting());
sink.OnMessage(TestData.TestMethodStarting());
sink.OnMessage(TestData.TestStarting());
sink.OnMessage(TestData.TestFailed());
Assert.Equal(TestRunState.Failure, sink.TestRunState);
}
public static async void Success_StaysInCurrentState(TestRunState initialState)
{
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42)
{
TestRunState = initialState
};
sink.OnMessage(TestData.TestClassStarting());
sink.OnMessage(TestData.TestMethodStarting());
sink.OnMessage(TestData.TestStarting());
sink.OnMessage(TestData.TestPassed());
Assert.Equal(initialState, sink.TestRunState);
}
public RoutedComputation(RequestContext reqCtx, string route)
{
Route = route;
_value = new Lazy <TResult>(() =>
{
var httpCtx = new HttpCtx(HttpContext.Current, route);
var rd = RouteTable.Routes.GetRouteData(httpCtx);
if (rd == null)
{
throw new InvalidOperationException();
}
var reqc = new RequestContext(httpCtx, rd);
var cf = ControllerBuilder.Current.GetControllerFactory();
var ctrName = rd.GetRequiredString("controller");
var ctrl = cf.CreateController(reqc, ctrName) as Controller;
if (ctrl == null)
{
throw new InvalidOperationException("Cannot find controller '" + ctrName + "' or it does not inherit from System.Web.Mvc.Controller");
}
var res = ResultSink.Push(httpCtx, route);
try
{
ctrl.ControllerContext = new ControllerContext(reqc, ctrl);
ctrl.ValueProvider = new ValueProviderCollection(new IValueProvider[]
{
new NameValueCollectionValueProvider(httpCtx.Request.QueryString, System.Threading.Thread.CurrentThread.CurrentCulture),
new DictionaryValueProvider <object>(rd.Values.ToDictionary(v => v.Key, v => v.Value), System.Threading.Thread.CurrentThread.CurrentCulture)
});
if (false == ctrl.ActionInvoker.InvokeAction(ctrl.ControllerContext, rd.GetRequiredString("action")))
{
throw new InvalidOperationException(string.Format("Cannot find action '{0}' on controller '{1}' or it did not pass current filter, such as HTTP method, auth requirements, etc.", rd.GetRequiredString("action"), ctrName));
}
return(res.Result);
}
finally
{
cf.ReleaseController(ctrl);
res.Pop(httpCtx);
}
});
}
public static async void ConvertsTestFailed()
{
(string?[] ExceptionTypes, string[] Messages, string?[] StackTraces, int[] ExceptionParentIndices, FailureCause _)errorMetadata;
try
{
throw new Exception();
}
catch (Exception e)
{
errorMetadata = ExceptionUtility.ExtractMetadata(e);
}
TestResult?testResult = null;
var listener = Substitute.For <ITestListener>();
listener
.WhenAny(l => l.TestFinished(null))
.Do <TestResult>(result => testResult = result);
await using var sink = new ResultSink(listener, 42);
sink.OnMessage(TestData.TestClassStarting(testClass: typeof(object).FullName !));
sink.OnMessage(TestData.TestMethodStarting(testMethod: nameof(object.GetHashCode)));
sink.OnMessage(TestData.TestStarting(testDisplayName: "Display Name"));
var message = TestData.TestFailed(
exceptionParentIndices: errorMetadata.ExceptionParentIndices,
exceptionTypes: errorMetadata.ExceptionTypes,
executionTime: 123.45m,
messages: errorMetadata.Messages,
stackTraces: errorMetadata.StackTraces
);
sink.OnMessage(message);
Assert.NotNull(testResult);
Assert.Same(typeof(object), testResult.FixtureType);
Assert.Equal(nameof(object.GetHashCode), testResult.Method.Name);
Assert.Equal("Display Name", testResult.Name);
Assert.Equal(TestState.Failed, testResult.State);
Assert.Equal(123.45, testResult.TimeSpan.TotalMilliseconds);
Assert.Equal(42, testResult.TotalTests);
Assert.Equal($"{errorMetadata.ExceptionTypes[0]} : {errorMetadata.Messages[0]}", testResult.Message);
Assert.Equal(errorMetadata.StackTraces[0], testResult.StackTrace);
}
public static void LogsTestFailure(IMessageSinkMessage message, string messageType)
{
var listener = Substitute.For <ITestListener>();
using (var visitor = new ResultSink(listener, 42)
{
TestRunState = TestRunState.NoTests
})
{
visitor.OnMessageWithTypes(message, null);
Assert.Equal(TestRunState.Failure, visitor.TestRunState);
var testResult = listener.Captured(x => x.TestFinished(null)).Arg <TestResult>();
Assert.Equal($"*** {messageType} ***", testResult.Name);
Assert.Equal(TestState.Failed, testResult.State);
Assert.Equal(1, testResult.TotalTests);
Assert.Equal("ExceptionType : This is my message \t\r\n", testResult.Message);
Assert.Equal("Line 1\r\nLine 2\r\nLine 3", testResult.StackTrace);
}
}
public async ValueTask ErrorMessage()
{
var errorMessage = new _ErrorMessage
{
ExceptionParentIndices = exceptionParentIndices,
ExceptionTypes = exceptionTypes,
Messages = messages,
StackTraces = stackTraces
};
var listener = Substitute.For <ITestListener>();
await using var sink = new ResultSink(listener, 42)
{
TestRunState = TestRunState.NoTests
};
sink.OnMessage(errorMessage);
AssertFailure(listener, sink.TestRunState, "Fatal Error");
}
public static void ConvertsITestPassed()
{
TestResult testResult = null;
var listener = Substitute.For <ITestListener>();
listener.WhenAny(l => l.TestFinished(null))
.Do <TestResult>(result => testResult = result);
var visitor = new ResultSink(listener, 42);
var message = Mocks.TestPassed(typeof(object), nameof(object.GetHashCode), "Display Name", executionTime: 123.45M);
visitor.OnMessageWithTypes(message, null);
Assert.NotNull(testResult);
Assert.Same(typeof(object), testResult.FixtureType);
Assert.Equal(nameof(object.GetHashCode), testResult.Method.Name);
Assert.Equal("Display Name", testResult.Name);
Assert.Equal(TestState.Passed, testResult.State);
Assert.Equal(123.45, testResult.TimeSpan.TotalMilliseconds);
Assert.Equal(42, testResult.TotalTests);
}
public static void ConvertsITestSkipped()
{
TestResult testResult = null;
var listener = Substitute.For <ITestListener>();
listener.WhenAny(l => l.TestFinished(null))
.Do <TestResult>(result => testResult = result);
var visitor = new ResultSink(listener, 42);
var message = Mocks.TestSkipped(typeof(string), "Contains", "Display Name", executionTime: 123.45M, skipReason: "I forgot how to run");
visitor.OnMessageWithTypes(message, null);
Assert.NotNull(testResult);
Assert.Same(typeof(string), testResult.FixtureType);
Assert.Equal("Contains", testResult.Method.Name);
Assert.Equal("Display Name", testResult.Name);
Assert.Equal(TestState.Ignored, testResult.State);
Assert.Equal(123.45, testResult.TimeSpan.TotalMilliseconds);
Assert.Equal(42, testResult.TotalTests);
Assert.Equal("I forgot how to run", testResult.Message);
}
public static async void ConvertsTestPassed()
{
TestResult?testResult = null;
var listener = Substitute.For <ITestListener>();
listener
.WhenAny(l => l.TestFinished(null))
.Do <TestResult>(result => testResult = result);
await using var sink = new ResultSink(listener, 42);
sink.OnMessage(TestData.TestClassStarting(testClass: typeof(object).FullName !));
sink.OnMessage(TestData.TestMethodStarting(testMethod: nameof(object.GetHashCode)));
sink.OnMessage(TestData.TestStarting(testDisplayName: "Display Name"));
sink.OnMessage(TestData.TestPassed(executionTime: 123.45m));
Assert.NotNull(testResult);
Assert.Same(typeof(object), testResult.FixtureType);
Assert.Equal(nameof(object.GetHashCode), testResult.Method.Name);
Assert.Equal("Display Name", testResult.Name);
Assert.Equal(TestState.Passed, testResult.State);
Assert.Equal(123.45, testResult.TimeSpan.TotalMilliseconds);
Assert.Equal(42, testResult.TotalTests);
}
private void ExecuteInstruction(Instruction inst)
{
int operand1;
int operand2;
switch (inst.Opcode)
{
case Opcode.Add:
operand1 = ReadValue(inst.A);
operand2 = ReadValue(inst.B);
Program[inst.C.Value] = operand1 + operand2;
IP += inst.Length;
break;
case Opcode.Multiply:
operand1 = ReadValue(inst.A);
operand2 = ReadValue(inst.B);
Program[inst.C.Value] = operand1 * operand2;
IP += inst.Length;
break;
case Opcode.Input:
operand1 = InputProvider.GetInput();
Program[inst.A.Value] = operand1;
IP += inst.Length;
break;
case Opcode.Output:
operand1 = ReadValue(inst.A);
foreach (var sink in OutputSinks)
{
sink.SendOutput(operand1);
}
ResultSink.SendOutput(operand1);
IP += inst.Length;
break;
case Opcode.JumpIfTrue:
operand1 = ReadValue(inst.A);
if (operand1 != 0)
{
IP = ReadValue(inst.B);
}
else
{
IP += inst.Length;
}
break;
case Opcode.JumpIfFalse:
operand1 = ReadValue(inst.A);
if (operand1 == 0)
{
IP = ReadValue(inst.B);
}
else
{
IP += inst.Length;
}
break;
case Opcode.LessThan:
operand1 = ReadValue(inst.A);
operand2 = ReadValue(inst.B);
if (operand1 < operand2)
{
Program[inst.C.Value] = 1;
}
else
{
Program[inst.C.Value] = 0;
}
IP += inst.Length;
break;
case Opcode.Equals:
operand1 = ReadValue(inst.A);
operand2 = ReadValue(inst.B);
if (operand1 == operand2)
{
Program[inst.C.Value] = 1;
}
else
{
Program[inst.C.Value] = 0;
}
IP += inst.Length;
break;
}
}
private void ExecuteInstruction(Instruction inst)
{
BigInteger operand1;
BigInteger operand2;
switch (inst.Opcode)
{
case Opcode.Add:
operand1 = ReadValue(inst.A);
operand2 = ReadValue(inst.B);
WriteValue(operand1 + operand2, inst.C);
break;
case Opcode.Multiply:
operand1 = ReadValue(inst.A);
operand2 = ReadValue(inst.B);
WriteValue(operand1 * operand2, inst.C);
break;
case Opcode.Input:
operand1 = InputProvider.GetInput();
WriteValue(operand1, inst.A);
break;
case Opcode.Output:
operand1 = ReadValue(inst.A);
foreach (var sink in OutputSinks)
{
sink.SendOutput(operand1);
}
ResultSink.SendOutput(operand1);
break;
case Opcode.JumpIfTrue:
operand1 = ReadValue(inst.A);
if (operand1 != 0)
{
IP = (int)ReadValue(inst.B) - inst.Length;
}
break;
case Opcode.JumpIfFalse:
operand1 = ReadValue(inst.A);
if (operand1 == 0)
{
IP = (int)ReadValue(inst.B) - inst.Length;
}
break;
case Opcode.LessThan:
operand1 = ReadValue(inst.A);
operand2 = ReadValue(inst.B);
if (operand1 < operand2)
{
WriteValue(1, inst.C);
}
else
{
WriteValue(0, inst.C);
}
break;
case Opcode.Equals:
operand1 = ReadValue(inst.A);
operand2 = ReadValue(inst.B);
if (operand1 == operand2)
{
WriteValue(1, inst.C);
}
else
{
WriteValue(0, inst.C);
}
break;
case Opcode.AddRelativeOffset:
operand1 = ReadValue(inst.A);
RelativeBase += (int)operand1;
break;
case Opcode.Halt:
IsHalted = true;
break;
}
IP += inst.Length;
}
