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