public void FinishedTasksAreRemovedFromRunner() { var exHandler = new MockExceptionHandler(); using (var runner = new LocalTaskRunner(exHandler)) { runner.AssertRunningTaskCount(0); runner.StartTask(TestOfTAsync); runner.AssertRunningTaskCount(1); runner.Execute(); runner.AssertRunningTaskCount(0); runner.AssertRunningTaskCount(0); runner.StartTask(TestAsync); runner.AssertRunningTaskCount(1); runner.Execute(); runner.AssertRunningTaskCount(0); } async Task TestAsync() { await Task.Yield(); } async Task <int> TestOfTAsync() { await Task.Yield(); return(42); } }
public void RunnerScopePropagatesToCalledMethods() { var count = 0; using (var runner = new LocalTaskRunner(this.exceptionHandler)) { var t = runner.StartTask(TestAsync); runner.Execute(); Assert.AreEqual(0, count); runner.Execute(); Assert.AreEqual(1, count); runner.Execute(); Assert.AreEqual(1, count); runner.Execute(); Assert.AreEqual(2, count); t.AssertCompletedSuccessfully(); } async Task TestAsync() { count += await SubTestAsync(); count += await SubTestAsync(); } async Task <int> SubTestAsync() { await Task.Yield(); await Task.Yield(); return(1); } }
public void StartTaskThreadingStressTest() { var exHandler = new MockExceptionHandler(); using (var runner = new LocalTaskRunner(exHandler)) { // Start many tasks tasks in parallel. for (int i = 0; i < 100; i++) { ThreadPool.QueueUserWorkItem(r => ((LocalTaskRunner)r).StartTask(TestAsync), runner); } // Wait for tasks to start. Thread.Sleep(millisecondsTimeout: 1000); // Execute a single tick to finish all tasks. runner.Execute(); // Assert that all tasks have finished. runner.AssertRunningTaskCount(0); } async Task TestAsync() { await Task.Yield(); } }
public void CallbackPostThreadingStressTest() { var exHandler = new MockExceptionHandler(); using (var runner = new LocalTaskRunner(exHandler)) { // Start the stress tasks. for (int i = 0; i < 50; i++) { runner.StartTask(StressAsync); } // Execute enough times to finish all tasks. for (int i = 0; i < 99; i++) { runner.Execute(); Thread.Sleep(10); } // Assert that all tasks have finished. runner.AssertRunningTaskCount(0); } async Task StressAsync() { /* This stresses the sync-context by posting callbacks from many different threads. */ for (int i = 0; i < 50; i++) { await Task.Run(() => Thread.Yield()); } } }
public void CancelledTaskExceptionCanBeCaught() { using (var runner1 = new LocalTaskRunner(this.exceptionHandler)) { Task <int> t; using (var runner2 = new LocalTaskRunner(this.exceptionHandler)) t = runner1.StartTask(TestAsync, runner2); runner1.Execute(); Assert.AreEqual(-1, t.Result); } async Task <int> TestAsync(ITaskRunner r) { try { return(await r.StartTask(GetIntAsync)); } catch (TaskCanceledException) { return(-1); } } async Task <int> GetIntAsync() { await Task.Yield(); return(42); } }
public void CancelledExceptionIsReportedWhenAwaitingDisposedRunner() { using (var runner1 = new LocalTaskRunner(this.exceptionHandler)) { using (var runner2 = new LocalTaskRunner(this.exceptionHandler)) { runner1.StartTask(TestAsync, runner2); this.exceptionHandler.AssertNoExceptions(); } runner1.Execute(); this.exceptionHandler.AssertPop <TaskCanceledException>(); } async Task TestAsync(ITaskRunner r) { await r.StartTask(GetIntAsync); } async Task <int> GetIntAsync() { await Task.Yield(); return(42); } }
public void YieldWaitsForNextExecute() { const int iterations = 25; var count = 0; using (var runner = new LocalTaskRunner(this.exceptionHandler)) { runner.StartTask(WaitAndIncrementAsync); for (int i = 0; i < iterations; i++) { Assert.AreEqual(i, count); runner.Execute(); } } async Task WaitAndIncrementAsync() { for (int i = 0; i < iterations; i++) { await Task.Yield(); count++; } } }
public void DoesNotAllowExecuteAfterDispose() { var exHandler = new MockExceptionHandler(); var runner = new LocalTaskRunner(exHandler); runner.Dispose(); Assert.Throws <ObjectDisposedException>(() => runner.Execute()); }
public void TaskIsResumedWhenDependencyIsDone() { var count = 0; using (var runner = new LocalTaskRunner(this.exceptionHandler)) using (var dependencyRunner = new LocalTaskRunner(this.exceptionHandler)) { var dep = dependencyRunner.StartTask(DependencyAsync); var t = runner.StartTask(TestAsync, dep); // Task does not complete on its own. runner.Execute(); Assert.AreEqual(0, count); // But when completing dependency. dependencyRunner.Execute(); Assert.AreEqual(0, count); // And then executing the original running the task is completed. runner.Execute(); t.AssertCompletedSuccessfully(); Assert.AreEqual(1, count); } async Task TestAsync(Task dependency) { await dependency; count++; } async Task DependencyAsync() { await Task.Yield(); } }
public void ExceptionsAreReportedInAsyncMethod() { using (var runner = new LocalTaskRunner(this.exceptionHandler)) { runner.StartTask(TestAsync); this.exceptionHandler.AssertNoExceptions(); runner.Execute(); this.exceptionHandler.AssertPop <TestException>(); } async Task TestAsync() { await Task.Yield(); throw new TestException(); } }
public void ResetsPreviousSynchronizationContextAfterExecute() { // Set custom sync-context. var syncContext = new MockSynchronizationContext(); SynchronizationContext.SetSynchronizationContext(syncContext); var exHandler = new MockExceptionHandler(); using (var runner = new LocalTaskRunner(exHandler)) { runner.Execute(); } // Verify that its again active. Assert.True(SynchronizationContext.Current == syncContext); }