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_Released_ReturnsCompletedTask() { using (var lck = new Lock()) { using (TaskAssert.Completed(lck.WaitAsync())) { } } }
public void WaitAsync_NotEmpty_WaitsForTurn() { using (var queue = new Queue()) { var t1 = queue.WaitAsync(); var t2 = queue.WaitAsync(); var t3 = queue.WaitAsync(); using (TaskAssert.Completed(t1)) { TaskAssert.DoesNotEnd(t2); TaskAssert.DoesNotEnd(t3); } using (TaskAssert.Completed(t2)) { TaskAssert.DoesNotEnd(t3); } using (TaskAssert.Completed(t3)) { Assert.That(!queue.IsEmpty); } Assert.That(queue.IsEmpty); } }
public void WaitAsync_Set_ReturnsCompletedTask() { using (var cond = Condition.True()) { TaskAssert.Completed(cond.WaitAsync()); } }
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 WaitAsync_Exceeded_WaitsForTurn() { using (var quota = new Quota(1L)) { var t1 = quota.WaitAsync(); var t2 = quota.WaitAsync(); var t3 = quota.WaitAsync(); Assert.That(quota.Balance, Is.EqualTo(-2L)); using (TaskAssert.Completed(t1)) { TaskAssert.DoesNotEnd(t2); TaskAssert.DoesNotEnd(t3); } Assert.That(quota.Balance, Is.EqualTo(-1L)); using (TaskAssert.Completed(t2)) { TaskAssert.DoesNotEnd(t3); } Assert.That(quota.Balance, Is.EqualTo(0L)); using (TaskAssert.Completed(t3)) { } Assert.That(quota.Balance, Is.EqualTo(1L)); } }
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_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 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 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_Ended_ReturnsCompletedTask() { using (var era = Era.Ended()) { TaskAssert.Completed(era.WaitAsync()); } }
public void WaitAsync_Empty_ReturnsCompletedTask() { using (var queue = new Queue()) { using (TaskAssert.Completed(queue.WaitAsync())) { } } }
public void WaitAsync_NotEmpty_WaitsForTurn() { using (var turnstile = new Turnstile()) { var t1 = turnstile.WaitAsync(); var t2 = turnstile.WaitAsync(); var t3 = turnstile.WaitAsync(); Assert.That(turnstile.HasWaiting); TaskAssert.DoesNotEnd(t1); TaskAssert.DoesNotEnd(t2); TaskAssert.DoesNotEnd(t3); Assert.That(turnstile.Turn()); TaskAssert.Completed(t1); TaskAssert.DoesNotEnd(t2); TaskAssert.DoesNotEnd(t3); Assert.That(turnstile.Turn()); TaskAssert.Completed(t2); TaskAssert.DoesNotEnd(t3); Assert.That(turnstile.Turn()); TaskAssert.Completed(t3); Assert.That(!turnstile.HasWaiting); Assert.That(!turnstile.Turn()); } }
public void WaitAsync_Exists_ReturnsCompletedTask() { using (var future = Future.Of(1)) { Assert.That( TaskAssert.Completed(future.WaitAsync()), Is.EqualTo(1) ); } }
public void IsAcquiredHere_Get() { using (var lck = new Lock()) { Assert.That(!lck.IsAcquiredHere); using (TaskAssert.Completed(lck.WaitAsync())) { Assert.That(lck.IsAcquiredHere); } } }
public void WaitAsync_Reset_WaitsForSet() { using (var cond = Condition.False()) { var awaiter = cond.WaitAsync(); TaskAssert.DoesNotEnd(awaiter); cond.Set(); TaskAssert.Completed(awaiter); } }
public void WaitAsync_NotEnded_WaitsForEnd() { using (var era = new Era()) { var awaiter = era.WaitAsync(); TaskAssert.DoesNotEnd(awaiter); era.End(); TaskAssert.Completed(awaiter); } }
public void WaitAsync_WaitsForFire() { using (var trigger = new Trigger()) { var awaiter = trigger.WaitAsync(); TaskAssert.DoesNotEnd(awaiter); trigger.Fire(); TaskAssert.Completed(awaiter); } }
public void OrCanceledBy_NotCanceled_PropagatesResult() { using (var cts = new CancellationTokenSource()) { var tcs = new TaskCompletionSource <int>(); var cont = tcs.Task.OrCanceledBy(cts.Token); TaskAssert.DoesNotEnd(cont); tcs.TrySetResult(1); Assert.That(TaskAssert.Completed(cont), Is.EqualTo(1)); } }
public void Fire_Barrier() { using (var trigger = new Trigger()) { var before = trigger.WaitAsync(); trigger.Fire(); var after = trigger.WaitAsync(); TaskAssert.Completed(before); TaskAssert.DoesNotEnd(after); } }
public void WaitAsync_DoesNotExist_WaitsForEnd() { using (var future = new Future <int>()) { var awaiter = future.WaitAsync(); TaskAssert.DoesNotEnd(awaiter); future.Post(1); Assert.That( TaskAssert.Completed(awaiter), Is.EqualTo(1) ); } }
public void WaitAsync_WaitsForPost() { using (var evt = new Event <int>()) { var awaiter = evt.WaitAsync(); TaskAssert.DoesNotEnd(awaiter); evt.Post(1); Assert.That( TaskAssert.Completed(awaiter), Is.EqualTo(1) ); } }
public void TrySkip_NotEmpty_ReturnsFalse() { using (var queue = new Queue()) { var t1 = queue.WaitAsync(); using (TaskAssert.Completed(t1)) { Assert.That(!queue.TrySkip(out _)); } Assert.That(queue.IsEmpty); } }
public void WaitAsync_Acquired_WaitsForTurn() { using (var lck = new Lock()) { var t1 = TaskAssert.Detach(lck.WaitAsync); var t2 = TaskAssert.Detach(lck.WaitAsync); using (TaskAssert.Completed(t1)) { TaskAssert.DoesNotEnd(t2); } using (TaskAssert.Completed(t2)) { } } }
public void WaitAsync_Acquired_Reenters() { using (var lck = new Lock()) { var h1 = TaskAssert.Completed(lck.WaitAsync()); var t1 = TaskAssert.Detach(lck.WaitAsync); var h2 = TaskAssert.Completed(lck.WaitAsync()); TaskAssert.DoesNotEnd(t1); h1.Dispose(); TaskAssert.DoesNotEnd(t1); h2.Dispose(); using (TaskAssert.Completed(t1)) { } } }
public void TrySkip_Empty_ReturnsTrueAndSkips() { using (var queue = new Queue()) { Assert.That(queue.TrySkip(out var handle)); var t1 = queue.WaitAsync(); using (handle) { TaskAssert.DoesNotEnd(t1); } using (TaskAssert.Completed(t1)) { } Assert.That(queue.IsEmpty); } }
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_Synchronizes() { using (var barrier = new Barrier(3)) { var t1 = barrier.WaitAsync(); TaskAssert.DoesNotEnd(t1); Assert.That(barrier.WaitingFor, Is.EqualTo(2)); var t2 = barrier.WaitAsync(); TaskAssert.DoesNotEnd(t2); Assert.That(barrier.WaitingFor, Is.EqualTo(1)); var t3 = barrier.WaitAsync(); TaskAssert.Completed(t1); TaskAssert.Completed(t2); TaskAssert.Completed(t3); } }
public void WaitAsync_Available_ReturnsCompletedTask() { using (var quota = new Quota(3L)) { var release = new IDisposable[3]; for (var I = 0; I <= 2; ++I) { Assert.That(quota.Active, Is.EqualTo(I)); release[I] = TaskAssert.Completed(quota.WaitAsync()); } for (var I = 2; I >= 0; --I) { release[I].Dispose(); Assert.That(quota.Active, Is.EqualTo(I)); } } }
public void Post_Barrier() { using (var evt = new Event <int>()) { var before = evt.WaitAsync(); evt.Post(1); var after = evt.WaitAsync(); evt.Post(2); Assert.That( TaskAssert.Completed(before), Is.EqualTo(1) ); Assert.That( TaskAssert.Completed(after), Is.EqualTo(2) ); } }