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