public void WhenLazyValueCreatedWithTaskFactoryIsNotReady_WeShouldWait()
{
var tcs = new TaskCompletionSource <int>();
var sut = new AsyncLazy <int>(() => tcs.Task);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(sut.Value);
}
public void WhenClientHasGotLockAsync_OtherClientsShouldWait()
{
var sut = new AsyncLock();
var @lock = sut.LockAsync().Result;
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(Task.WhenAny(sut.LockAsync(), sut.LockAsync()));
}
public void WhenClientsCountIsGreaterThen_SemaphoreShouldMakeClientsWaitedAsync()
{
var sut = new AsyncSemaphore(2);
Task.WhenAll(sut.WaitAsync(), sut.WaitAsync()).Wait();
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(sut.WaitAsync());
}
public void WhenLauncherHasQueuedDelegate_ItShouldCompleted()
{
var sut = new SingleRunningDelegateLauncher();
var tcs = new AsyncTaskCompletionSource();
sut.Launch(ct => { tcs.SetResult(); }, t => { });
ConcurrentAssert.EnsureThatTaskIsCompleted(tcs.Task);
}
public void WhenEventIsDefault_ItShouldBeNonSignaled()
{
var sut = new AsyncManualResetEvent();
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(sut.WaitAsync());
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(sut.WaitAsync());
ConcurrentAssert.EnsureThatActionIsNeverCompleted(sut.Wait);
ConcurrentAssert.EnsureThatActionIsNeverCompleted(sut.Wait);
}
public void WhenEventIsSignaled_ItShouldNotMakeClientsWaitedAsync()
{
var sut = new AsyncManualResetEvent();
sut.Set();
ConcurrentAssert.EnsureThatTaskIsCompleted(sut.WaitAsync());
ConcurrentAssert.EnsureThatTaskIsCompleted(sut.WaitAsync());
}
public void WhenEventIsSignaled_ItShouldNotMakeWaitedOnlySingleClient()
{
var sut = new AsyncAutoResetEvent();
sut.Set();
ConcurrentAssert.EnsureThatActionIsCompleted(sut.Wait);
ConcurrentAssert.EnsureThatActionIsNeverCompleted(sut.Wait);
}
public void WhenSignaledClientCountLessThenNecessary_BarrierShouldBeNonSignaled()
{
var clientCount = 3;
var sut = new AsyncBarrier(clientCount);
var task1 = sut.SignalAndWaitAsync();
var task2 = sut.SignalAndWaitAsync();
var tasks = Task.WhenAny(task1, task2);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(tasks);
}
public void WhenLazyValueIsNotReady_WeShouldWait()
{
var mre = new ManualResetEvent(false);
var sut = new AsyncLazy <int>(
() =>
{
mre.WaitOne();
return(42);
});
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(sut.Value);
}
public void WhenClientRelease_SemaphoreShouldNotMakeOneMoreClientWaitedAsync()
{
var sut = new AsyncSemaphore(1);
sut.Wait();
var task = sut.WaitAsync();
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(task);
sut.Release();
ConcurrentAssert.EnsureThatTaskIsCompleted(task);
}
public void WhenSignaledClientCountEqualToNecessary_BarrierShouldBecomeSignaled()
{
var clientCount = 3;
var sut = new AsyncBarrier(clientCount);
var task1 = sut.SignalAndWaitAsync();
var task2 = sut.SignalAndWaitAsync();
var task3 = sut.SignalAndWaitAsync();
var allTasks = Task.WhenAll(task1, task2, task3);
ConcurrentAssert.EnsureThatTaskIsCompleted(allTasks);
}
public void WhenLockIsAlreadyGot_WaitedAsyncClientShouldBeStopWaitingWithTimeout()
{
var sut = new AsyncLock();
var @lock = sut.LockAsync().Result;
var task1 = sut.LockAsync(TimeSpan.FromMilliseconds(300));
var task2 = sut.LockAsync();
ConcurrentAssert.EnsureThatTaskIsCompleted(task1, TimeSpan.FromMilliseconds(600));
Assert.ThrowsExceptionAsync <TimeoutException>(() => task1);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(task2);
}
public void WhenLauncherHasQueuedDelegate_TheOnFinishedActionShouldBeCalledIf()
{
var sut = new SingleRunningDelegateLauncher();
var tcs = new AsyncTaskCompletionSource();
Task task = null;
sut.Launch(ct => { }, t => { tcs.SetResult(); task = t; });
ConcurrentAssert.EnsureThatTaskIsCompleted(tcs.Task);
Assert.IsNotNull(task);
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
}
public void WhenClientHasDisposedLock_SingleClientShouldGetLockWithFIFO()
{
var sut = new AsyncLock();
var @lock = sut.LockAsync().Result;
var task1 = sut.LockAsync();
var task2 = sut.LockAsync();
@lock.Dispose();
ConcurrentAssert.EnsureThatTaskIsCompleted(task1);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(task2);
}
public void WhenEventIsReset_ItShouldMakeClientsWaited()
{
var sut = new AsyncManualResetEvent();
sut.Set();
ConcurrentAssert.EnsureThatActionIsCompleted(sut.Wait);
ConcurrentAssert.EnsureThatActionIsCompleted(sut.Wait);
sut.Reset();
ConcurrentAssert.EnsureThatActionIsNeverCompleted(sut.Wait);
ConcurrentAssert.EnsureThatActionIsNeverCompleted(sut.Wait);
}
public void WhenEventIsNonSignaled_ItShouldMakeClientsWaitedAsyncWithCancel()
{
var sut = new AsyncManualResetEvent();
sut.Reset();
var ct = new CancellationTokenSource();
var task = sut.WaitAsync(ct.Token);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(task);
ct.Cancel();
ConcurrentAssert.EnsureThatTaskIsCompleted(task);
Assert.ThrowsExceptionAsync <TaskCanceledException>(() => task);
}
public void WhenBarrierIsNonSignaled_ClientsShouldBeWaitedWithCancel()
{
var clientCount = 2;
var sut = new AsyncBarrier(clientCount);
var cts = new CancellationTokenSource();
var task = sut.SignalAndWaitAsync(cts.Token);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(task);
cts.Cancel();
ConcurrentAssert.EnsureThatTaskIsCompleted(task);
Assert.ThrowsExceptionAsync <TaskCanceledException>(() => task);
}
public void WhenClientsCountIsGreaterThen_SemaphoreShouldMakeClientsWaitedAsyncWithCancel()
{
var sut = new AsyncSemaphore(2);
Task.WhenAll(sut.WaitAsync(), sut.WaitAsync()).Wait();
var cts = new CancellationTokenSource();
var task = sut.WaitAsync(cts.Token);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(task);
cts.Cancel();
ConcurrentAssert.EnsureThatTaskIsCompleted(task);
Assert.ThrowsExceptionAsync <TaskCanceledException>(() => task);
}
public void WhenLauncherHasQueuedDelegate_TheOnFinishedActionShouldBeCalledAfterDelegateHasFinished()
{
var sut = new SingleRunningDelegateLauncher();
var tcs = new AsyncTaskCompletionSource();
var tcs2 = new AsyncTaskCompletionSource();
Task task = null;
sut.Launch(ct => { tcs.Task.Wait(); }, t => { tcs2.SetResult(); task = t; });
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(tcs2.Task);
tcs.SetResult();
ConcurrentAssert.EnsureThatTaskIsCompleted(tcs2.Task);
}
public void WhenEventIsNonSignaled_ItShouldMakeClientsWaitedAsyncWithTimeoutAndCancel()
{
var sut = new AsyncManualResetEvent();
sut.Reset();
var ct = new CancellationTokenSource();
var task = sut.WaitAsync(TimeSpan.FromMilliseconds(1000), ct.Token);
ConcurrentAssert.EnsureThatTaskIsNotCompletedIn(task, TimeSpan.FromMilliseconds(500));
ct.Cancel();
ConcurrentAssert.EnsureThatTaskIsCompleted(task);
Assert.ThrowsExceptionAsync <TaskCanceledException>(() => task);
}
public void WhenLockIsAlreadyGot_WaitedAsyncClientShouldBeAbleToCancelWaiting()
{
var sut = new AsyncLock();
var @lock = sut.LockAsync().Result;
var cts = new CancellationTokenSource();
var task1 = sut.LockAsync(cts.Token);
var task2 = sut.LockAsync();
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(Task.WhenAny(task1, task2));
cts.Cancel();
ConcurrentAssert.EnsureThatTaskIsCompleted(task1);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(task2);
Assert.ThrowsExceptionAsync <TaskCanceledException>(() => task1);
}
public void WhenClientsCountIsLessThen_SemaphoreShouldNotMakeClientsWaitedAsync()
{
var sut = new AsyncSemaphore(3);
ConcurrentAssert.EnsureThatTaskIsCompleted(Task.WhenAll(sut.WaitAsync(), sut.WaitAsync()));
}
