public void ExecuteThreadingStressTest()
{
var exHandler = new MockExceptionHandler();
using (var runner = new LocalTaskRunner(exHandler))
{
// Start many tasks tasks.
for (int i = 0; i < 100; i++)
{
runner.StartTask(TestAsync);
}
for (int interation = 0; interation < 11; interation++)
{
// Execute from many different threads in parallel.
for (int thread = 0; thread < 100; thread++)
{
ThreadPool.QueueUserWorkItem(r => ((LocalTaskRunner)r).Execute(), runner);
}
Thread.Sleep(millisecondsTimeout: 100);
}
// Assert that all tasks have finished.
runner.AssertRunningTaskCount(0);
}
async Task TestAsync()
{
for (int i = 0; i < 10; i++)
{
await Task.Yield();
}
}
}
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 Setup()
{
MockExceptionHandler.Clear();
handlerData = new CustomHandlerData();
handlerData.Attributes["foo"] = "bar";
}
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 Setup()
{
MockExceptionHandler.Clear();
handlerData = new CustomHandlerData("custom", "an invalid type name");
handlerData.Attributes["foo"] = "bar";
}
public void Setup()
{
MockExceptionHandler.Clear();
handlerData = new CustomHandlerData("custom", typeof(TestHandlerWithMissingConstructor));
handlerData.Attributes["foo"] = "bar";
}
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 CanBeDisposedMultipleTimes()
{
var exHandler = new MockExceptionHandler();
var runner = new LocalTaskRunner(exHandler);
runner.Dispose();
runner.Dispose();
}
public void DoesNotAllowExecuteAfterDispose()
{
var exHandler = new MockExceptionHandler();
var runner = new LocalTaskRunner(exHandler);
runner.Dispose();
Assert.Throws <ObjectDisposedException>(() => runner.Execute());
}
public void DoesNotAllowStartingTaskAfterDispose()
{
var exHandler = new MockExceptionHandler();
var runner = new LocalTaskRunner(exHandler);
runner.Dispose();
Assert.Throws <ObjectDisposedException>(() => runner.StartTask(() => Task.CompletedTask));
Assert.Throws <ObjectDisposedException>(() => runner.StartTask(() => Task.FromResult <int>(42)));
}
public AzureBlobApplicationInstanceIdRenterTests()
{
this.ExceptionHandler = new MockExceptionHandler();
var hostBuilder = new HostBuilder();
hostBuilder.ConfigureServices(services => services.AddSingleton <IExceptionHandler>(this.ExceptionHandler));
this.Host = hostBuilder.Build();
this.Repo = new MockBlobContainerRepo();
this.Renter = new AzureBlobApplicationInstanceIdRenter(this.Host.Services, this.Repo);
}
public void ThrowsForTaskCreatorsThatReturnsNull()
{
var exHandler = new MockExceptionHandler();
using (var runner = new LocalTaskRunner(exHandler))
{
Assert.Throws <TaskCreatorReturnedNullException>(() => runner.StartTask(TaskReturnNull));
Assert.Throws <TaskCreatorReturnedNullException>(() => runner.StartTask(TaskOfTReturnNull));
}
Task TaskReturnNull() => null;
Task <int> TaskOfTReturnNull() => null;
}
public void ThrowWhenTaskChangesSyncronizationContextInSyncronousPart()
{
var exHandler = new MockExceptionHandler();
using (var runner = new LocalTaskRunner(exHandler))
{
Assert.Throws <ContextChangedException>(() => runner.StartTask(TaskThatChangesSyncContext));
}
Task TaskThatChangesSyncContext()
{
SynchronizationContext.SetSynchronizationContext(new MockSynchronizationContext());
return(Task.CompletedTask);
}
}
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);
}
public void ResetsPreviousSynchronizationContextWhenTaskCreatorThrows()
{
// Set custom sync-context.
var syncContext = new MockSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(syncContext);
var exHandler = new MockExceptionHandler();
using (var runner = new LocalTaskRunner(exHandler))
{
Assert.Throws <TestException>(() => runner.StartTask(() => throw new TestException()));
}
// Verify that its again active.
Assert.True(SynchronizationContext.Current == syncContext);
}
public void StartingCompletedTaskIsReturnedDirectly()
{
var tcs = new TaskCompletionSource <int>();
tcs.SetResult(42);
Task <int> completedTaskOfInt = tcs.Task;
Task completedTask = tcs.Task;
var exHandler = new MockExceptionHandler();
using (var runner = new LocalTaskRunner(exHandler))
{
var taskOfInt = runner.StartTask(taskCreator: () => completedTaskOfInt);
Assert.True(object.ReferenceEquals(completedTaskOfInt, taskOfInt));
var task = runner.StartTask(taskCreator: () => completedTask);
Assert.True(object.ReferenceEquals(completedTask, task));
}
}
public void StartingFaultedTaskIsReturnedDirectlyAndErrorIsReported()
{
var tcs = new TaskCompletionSource <int>();
tcs.SetException(new TestException());
Task <int> faultedTaskOfInt = tcs.Task;
Task faultedTask = tcs.Task;
var exHandler = new MockExceptionHandler();
using (var runner = new LocalTaskRunner(exHandler))
{
var taskOfInt = runner.StartTask(taskCreator: () => faultedTaskOfInt);
Assert.True(object.ReferenceEquals(faultedTaskOfInt, taskOfInt));
exHandler.AssertPop <TestException>();
var task = runner.StartTask(taskCreator: () => faultedTask);
Assert.True(object.ReferenceEquals(faultedTask, task));
exHandler.AssertPop <TestException>();
}
}
public void Setup()
{
this.exceptionHandler = new MockExceptionHandler();
}
