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