public async Task Enqueue_Action_Should_Cancel_Task_When_On_Disposed_Queue()
{
MonoThreadedQueue queue = null;
//arrange
using (queue = new MonoThreadedQueue())
{
var task = queue.Enqueue(() => TaskFactory());
}
bool Done = false;
Task newesttask = queue.Enqueue(() => { Done = true; });
TaskCanceledException error = null;
try
{
await newesttask;
}
catch (TaskCanceledException e)
{
error = e;
}
newesttask.IsCanceled.Should().BeTrue();
error.Should().NotBeNull();
Done.Should().BeFalse();
}
public async Task Enqueue_Func_T_Should_Cancel_Task_When_On_Disposed_Queue()
{
MonoThreadedQueue queue = null;
//arrange
using (queue = new MonoThreadedQueue())
{
var task = queue.Enqueue(() => TaskFactory());
}
Func <int> func = () => { return(25); };
Task newesttask = queue.Enqueue(func);
TaskCanceledException error = null;
try
{
await newesttask;
}
catch (TaskCanceledException e)
{
error = e;
}
newesttask.IsCanceled.Should().BeTrue();
error.Should().NotBeNull();
}
internal async Task <Tuple <T, MonoThreadedQueue> > InternalBuildAsync <T>(Func <T> concrete) where T : class
{
var queue = new MonoThreadedQueue(_OnCreate);
var actor = await queue.Enqueue(() => Build <T>(concrete(), queue)).ConfigureAwait(false);
return(new Tuple <T, MonoThreadedQueue>(actor, queue));
}
public async Task Enqueue_Action_Should_Cancel_Not_Started_Task_When_OnDispose()
{
Task newTask = null, notstarted = null;
bool Done = false;
//arrange
using (var target = new MonoThreadedQueue(t => t.Priority = ThreadPriority.Highest))
{
newTask = target.Enqueue(() => TaskFactory(3));
while (_RunningThread == null)
{
Thread.Sleep(100);
}
notstarted = target.Enqueue(() => { Done = true; });
}
await newTask;
TaskCanceledException error = null;
try
{
await notstarted;
}
catch (TaskCanceledException e)
{
error = e;
}
notstarted.IsCanceled.Should().BeTrue();
error.Should().NotBeNull();
Done.Should().BeFalse();
}
private T Build <T>(T concrete, MonoThreadedQueue queue) where T : class
{
var asyncDisposable = concrete as IAsyncDisposable;
return(CreateIActorLifeCycle(concrete, queue, TypeHelper.IActorCompleteLifeCycleType,
new ActorCompleteLifeCycleInterceptor(queue, asyncDisposable),
new ActorLifeCycleInterceptor(queue, asyncDisposable)));
}
public MonoThreadedQueueSynchronizationContext(MonoThreadedQueue dispatcher)
{
if (dispatcher == null)
throw new ArgumentNullException("dispatcher");
_dispatcher = dispatcher;
SetWaitNotificationRequired();
}
public async Task Enqueue_Should_Run_OnSeparatedThread()
{
Thread current = Thread.CurrentThread;
//arrange
using (var target = new MonoThreadedQueue())
{
//act
await target.Enqueue(() => TaskFactory());
//assert
_RunningThread.Should().NotBeNull();
_RunningThread.Should().NotBe(current);
}
}
public async Task Enqueue_Should_Work_With_Result()
{
Thread current = Thread.CurrentThread;
//arrange
using (var target = new MonoThreadedQueue())
{
//act
var res = await target.Enqueue(() => TaskFactory <int>(25));
//assert
res.Should().Be(25);
_RunningThread.Should().NotBeNull();
_RunningThread.Should().NotBe(current);
}
}
public async Task Enqueue_Should_Run_OnSameThread()
{
Thread current = Thread.CurrentThread;
//arrange
using (var target = new MonoThreadedQueue())
{
//act
await target.Enqueue(() => TaskFactory());
var first = _RunningThread;
await target.Enqueue(() => TaskFactory());
//assert
_RunningThread.Should().Be(first);
}
}
public async Task Enqueue_Should_Work_OnAction()
{
Thread current = Thread.CurrentThread;
//arrange
using (var target = new MonoThreadedQueue())
{
bool done = false;
Action act = () => done = true;
//act
await target.Enqueue(act);
//assert
done.Should().BeTrue();
}
}
public async Task Enqueue_Func_T_Should_Work_AsExpected_With_Result()
{
Thread current = Thread.CurrentThread;
//arrange
using (var target = new MonoThreadedQueue())
{
Func <int> func = () => { _RunningThread = Thread.CurrentThread; return(25); };
//act
var res = await target.Enqueue(func);
//assert
res.Should().Be(25);
_RunningThread.Should().NotBeNull();
_RunningThread.Should().NotBe(current);
}
}
public async Task Dispose_Running_Task_Should_Continue_After_Stoping_Queue()
{
//arrange
MonoThreadedQueue queue = new MonoThreadedQueue();
var task = queue.Enqueue(() => TaskFactory(3));
while (_RunningThread == null)
{
Thread.Sleep(100);
}
//act
queue.Dispose();
await task;
//assert
task.IsCompleted.Should().BeTrue();
}
public async Task Enqueue_Exception_Should_Not_Kill_MainThead()
{
Thread current = Thread.CurrentThread;
//arrange
using (var target = new MonoThreadedQueue())
{
//act
try
{
await target.Enqueue(() => Throw());
}
catch
{
}
await target.Enqueue(() => TaskFactory());
}
}
public async Task Enqueue_Should_DispatchException_With_Result()
{
//arrange
using (var target = new MonoThreadedQueue())
{
Exception error = null;
//act
try
{
await target.Enqueue(() => Throw <string>());
}
catch (Exception e)
{
error = e;
}
//assert
error.Should().NotBeNull();
}
}
public async Task Enqueue_Should_Not_Cancel_Already_Runing_Task_OnDispose()
{
Task newTask = null;
//arrange
using (var target = new MonoThreadedQueue(t => t.Priority = ThreadPriority.Highest))
{
newTask = target.Enqueue(() => TaskFactory(3));
while (_RunningThread == null)
{
Thread.Sleep(100);
}
}
await newTask;
_RunningThread.Should().NotBeNull();
newTask.IsCanceled.Should().BeFalse();
}
public async Task Dispose_Enqueued_Task_Should_Continue_After_Stoping_Queue()
{
//arrange
MonoThreadedQueue queue = new MonoThreadedQueue();
Task task = queue.Enqueue(() => TaskFactory(3)), enqueuedtask = null;
while (_RunningThread == null)
{
Thread.Sleep(100);
}
enqueuedtask = queue.Enqueue(() => TaskFactory(3));
//act
await queue.Stop(() => TaskBuilder.Completed);
await enqueuedtask;
//assert
task.IsCompleted.Should().BeTrue();
enqueuedtask.IsCompleted.Should().BeTrue();
}
public async Task Enqueue_Exception_Should_Not_Kill_MainThead_With_Result()
{
Thread current = Thread.CurrentThread;
//arrange
using (var target = new MonoThreadedQueue())
{
//act
try
{
await target.Enqueue(() => Throw <int>());
}
catch
{
}
var res = await target.Enqueue(() => TaskFactory <int>(25));
//assert
res.Should().Be(25);
}
}
public async Task Enqueue_Should_DispatchException()
{
Thread current = Thread.CurrentThread;
//arrange
using (var target = new MonoThreadedQueue())
{
Exception error = null;
//act
try
{
await target.Enqueue(() => Throw());
}
catch (Exception e)
{
error = e;
}
//assert
error.Should().NotBeNull();
}
}
public async Task Dispose_Enqueue_Items_Should_Return_Canceled_Task_After_Stoping_Queue()
{
//arrange
MonoThreadedQueue queue = new MonoThreadedQueue();
queue.Dispose();
bool Done = false;
TaskCanceledException error = null;
try
{
await queue.Enqueue(() => { Done = true; });
}
catch (TaskCanceledException e)
{
error = e;
}
error.Should().NotBeNull();
Done.Should().BeFalse();
}
public DispatcherSynchronizationContextTest()
{
_Queue = new MonoThreadedQueue(t => t.Priority = ThreadPriority.Highest);
_Dispatcher = new MonoThreadedQueueSynchronizationContext(_Queue);
}
public Task <T> BuildAsync <T>(Func <T> concrete) where T : class
{
var queue = new MonoThreadedQueue(_OnCreate);
return(queue.Enqueue(() => Build <T>(concrete(), queue)));
}
public DispatcherSynchronizationContextTest()
{
_Queue = new MonoThreadedQueue(t => t.Priority = ThreadPriority.Highest);
_Dispatcher = new MonoThreadedQueueSynchronizationContext(_Queue);
}
