public void WaitAsync_Exceeded_CanCedeTurn() { using (var cts = new CancellationTokenSource()) using (var quota = new Quota(1L)) { var t1 = quota.WaitAsync(); var t2 = quota.WaitAsync(cts.Token); var t3 = quota.WaitAsync(); Assert.That(quota.Balance, Is.EqualTo(-2L)); cts.Cancel(); Assert.That(quota.Balance, Is.EqualTo(-1L)); using (TaskAssert.Completed(t1)) { TaskAssert.Cancelled(t2); TaskAssert.DoesNotEnd(t3); } Assert.That(quota.Balance, Is.EqualTo(0L)); using (TaskAssert.Completed(t3)) { } Assert.That(quota.Balance, Is.EqualTo(1L)); } }
public void Dispose_FaultsAwaiters() { var lck = new Lock(); using (var cts = new CancellationTokenSource()) { var awaiters = new[] { TaskAssert.Detach(lck.WaitAsync), TaskAssert.Detach(() => lck.WaitAsync(cts.Token)), TaskAssert.Detach(lck.WaitAsync), TaskAssert.Detach(lck.WaitAsync) }; cts.Cancel(); lck.Dispose(); using (TaskAssert.Completed(awaiters[0])) { } TaskAssert.Cancelled(awaiters[1]); foreach (var awaiter in awaiters.Skip(2)) { TaskAssert.Faulted <ObjectDisposedException>(awaiter); } } }
public void Dispose_FaultsAwaiters() { var quota = new Quota(1L); using (var cts = new CancellationTokenSource()) { var awaiters = new[] { quota.WaitAsync(), quota.WaitAsync(cts.Token), quota.WaitAsync(), quota.WaitAsync() }; cts.Cancel(); quota.Dispose(); using (TaskAssert.Completed(awaiters[0])) { } TaskAssert.Cancelled(awaiters[1]); foreach (var awaiter in awaiters.Skip(2)) { TaskAssert.Faulted <ObjectDisposedException>(awaiter); } } }
public void Dispose_FaultsAwaiters() { var turnstile = new Turnstile(); using (var cts = new CancellationTokenSource()) { var awaiters = new[] { turnstile.WaitAsync(), turnstile.WaitAsync(cts.Token), turnstile.WaitAsync(), turnstile.WaitAsync() }; cts.Cancel(); turnstile.Dispose(); TaskAssert.Faulted <ObjectDisposedException>(awaiters[0]); TaskAssert.Cancelled(awaiters[1]); foreach (var awaiter in awaiters.Skip(2)) { TaskAssert.Faulted <ObjectDisposedException>(awaiter); } } }
public void OrCanceledBy_NotCanceled_Propagates(TaskStatus AStatus) { using (var cts = new CancellationTokenSource()) { var tcs = new TaskCompletionSource <Void>(); var cont = tcs.Task.OrCanceledBy(cts.Token); Assume.That(cont.Wait(10), Is.False); switch (AStatus) { case TaskStatus.RanToCompletion: tcs.TrySetResult(default); TaskAssert.Completed(cont); break; case TaskStatus.Canceled: tcs.TrySetCanceled(_FCanceled.Token); TaskAssert.Cancelled(cont); break; case TaskStatus.Faulted: tcs.TrySetException(_FFaulted); Assert.That( TaskAssert.Faulted <Exception>(cont), Is.SameAs(_FFaulted) ); break; default: throw new NotImplementedException(); } } }
public void WaitAsync_NotEmpty_CanCedeTurn() { using (var cts = new CancellationTokenSource()) using (var turnstile = new Turnstile()) { var t1 = turnstile.WaitAsync(); var t2 = turnstile.WaitAsync(cts.Token); var t3 = turnstile.WaitAsync(); Assert.That(turnstile.HasWaiting); TaskAssert.DoesNotEnd(t1); TaskAssert.DoesNotEnd(t2); TaskAssert.DoesNotEnd(t3); cts.Cancel(); Assert.That(turnstile.Turn()); TaskAssert.Completed(t1); TaskAssert.Cancelled(t2); TaskAssert.DoesNotEnd(t3); Assert.That(turnstile.Turn()); TaskAssert.Completed(t3); Assert.That(!turnstile.HasWaiting); Assert.That(!turnstile.Turn()); } }
public void WaitAsync_NotEmpty_CanCedeTurn() { using (var cts = new CancellationTokenSource()) using (var queue = new Queue()) { var t1 = queue.WaitAsync(); var t2 = queue.WaitAsync(cts.Token); var t3 = queue.WaitAsync(); using (TaskAssert.Completed(t1)) { TaskAssert.DoesNotEnd(t2); TaskAssert.DoesNotEnd(t3); cts.Cancel(); TaskAssert.Cancelled(t2); TaskAssert.DoesNotEnd(t3); } using (TaskAssert.Completed(t3)) { Assert.That(!queue.IsEmpty); } Assert.That(queue.IsEmpty); } }
public void WaitAsync_DoesNotExist_Cancelable() { using (var cts = new CancellationTokenSource()) using (var future = new Future <int>()) { var awaiter = future.WaitAsync(cts.Token); TaskAssert.DoesNotEnd(awaiter); cts.Cancel(); TaskAssert.Cancelled(awaiter); } }
public void WaitAsync_Cancelable() { using (var cts = new CancellationTokenSource()) using (var evt = new Event <int>()) { var awaiter = evt.WaitAsync(cts.Token); TaskAssert.DoesNotEnd(awaiter); cts.Cancel(); TaskAssert.Cancelled(awaiter); } }
public void OrCanceledBy_Cancelable_CanBeCanceled() { using (var cts = new CancellationTokenSource()) { var task = MakeUnendingTask(); var cont = task.OrCanceledBy(cts.Token); cts.Cancel(); TaskAssert.Cancelled(cont); } }
public void WaitAsync_Reset_Cancelable() { using (var cts = new CancellationTokenSource()) using (var cond = Condition.False()) { var awaiter = cond.WaitAsync(cts.Token); TaskAssert.DoesNotEnd(awaiter); cts.Cancel(); TaskAssert.Cancelled(awaiter); } }
public void WaitAsync_NotEnded_Cancelable() { using (var cts = new CancellationTokenSource()) using (var era = new Era()) { var awaiter = era.WaitAsync(cts.Token); TaskAssert.DoesNotEnd(awaiter); cts.Cancel(); TaskAssert.Cancelled(awaiter); } }
public void WaitAsync_Cancelable() { using (var cts = new CancellationTokenSource()) using (var trigger = new Trigger()) { var awaiter = trigger.WaitAsync(cts.Token); TaskAssert.DoesNotEnd(awaiter); cts.Cancel(); TaskAssert.Cancelled(awaiter); } }
public void HasWaiting_DetectsCeded() { using (var cts = new CancellationTokenSource()) using (var turnstile = new Turnstile()) { var awaiter = turnstile.WaitAsync(cts.Token); TaskAssert.DoesNotEnd(awaiter); Assert.That(turnstile.HasWaiting); cts.Cancel(); TaskAssert.Cancelled(awaiter); Assert.That(!turnstile.HasWaiting); } }
public void WaitAsync_Waiting_CanRetract() { using (var cts = new CancellationTokenSource()) using (var barrier = new Barrier(3)) { var t1 = barrier.WaitAsync(); TaskAssert.DoesNotEnd(t1); Assert.That(barrier.WaitingFor, Is.EqualTo(2)); var t2 = barrier.WaitAsync(cts.Token); TaskAssert.DoesNotEnd(t2); Assert.That(barrier.WaitingFor, Is.EqualTo(1)); cts.Cancel(); TaskAssert.Cancelled(t2); Assert.That(barrier.WaitingFor, Is.EqualTo(2)); } }
public void IsEmpty_DetectsCeded() { using (var cts = new CancellationTokenSource()) using (var queue = new Queue()) { var block = queue.WaitAsync(); var awaiter = queue.WaitAsync(cts.Token); TaskAssert.DoesNotEnd(awaiter); Assert.That(!queue.IsEmpty); cts.Cancel(); using (TaskAssert.Completed(block)) { } TaskAssert.Cancelled(awaiter); Assert.That(queue.IsEmpty); } }
public void WaitAsync_Acquired_CanCedeTurn() { using (var cts = new CancellationTokenSource()) using (var lck = new Lock()) { var t1 = TaskAssert.Detach(lck.WaitAsync); var t2 = TaskAssert.Detach(() => lck.WaitAsync(cts.Token)); var t3 = TaskAssert.Detach(lck.WaitAsync); TaskAssert.DoesNotEnd(t2); TaskAssert.DoesNotEnd(t3); cts.Cancel(); TaskAssert.Cancelled(t2); TaskAssert.DoesNotEnd(t3); using (TaskAssert.Completed(t1)) { } using (TaskAssert.Completed(t3)) { } } }