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