public void SignalAndWaitAsync_Underflow_ThrowsException()
{
var tcs = new TaskCompletionSource();
var barrier = new AsyncBarrier(1, async _ => { await tcs.Task; });
barrier.SignalAndWaitAsync();
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.SignalAndWaitAsync());
tcs.SetResult();
}
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 PostPhaseAction_ExecutedAtEndOfEachPhase()
{
AsyncContext.Run(async() =>
{
int executed = 0;
var barrier = new AsyncBarrier(1, _ => { Interlocked.Increment(ref executed); });
await barrier.SignalAndWaitAsync();
Assert.AreEqual(1, Interlocked.CompareExchange(ref executed, 0, 0));
await barrier.SignalAndWaitAsync();
Assert.AreEqual(2, Interlocked.CompareExchange(ref executed, 0, 0));
});
}
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 RemoveParticipantsAsync_Underflow_ThrowsException()
{
var barrier = new AsyncBarrier(2);
barrier.SignalAndWaitAsync();
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.RemoveParticipantsAsync(2));
}
public void PostPhaseAction_PropagatesExceptions()
{
AsyncContext.Run(async() =>
{
var barrier = new AsyncBarrier(1, _ => { throw new NotImplementedException(); });
await AssertEx.ThrowsExceptionAsync <NotImplementedException>(barrier.SignalAndWaitAsync(), allowDerivedTypes: false);
});
}
public void WhenBarrierIsNonSignaled_ClientsShouldBeWaitedWithTimeout()
{
var clientCount = 2;
var sut = new AsyncBarrier(clientCount);
var task = sut.SignalAndWaitAsync(TimeSpan.FromMilliseconds(300));
Assert.ThrowsExceptionAsync <TimeoutException>(() => task);
}
public void SignalAndWaitAsync_NoParticipants_ThrowsException()
{
var barrier = new AsyncBarrier(0);
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(0, barrier.ParticipantCount);
Assert.AreEqual(0, barrier.ParticipantsRemaining);
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.SignalAndWaitAsync());
}
public void SignalAndWaitAsync_MultipleParticipants_CompleteTogether()
{
AsyncContext.Run(async() =>
{
var barrier = new AsyncBarrier(2);
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(2, barrier.ParticipantCount);
Assert.AreEqual(2, barrier.ParticipantsRemaining);
var task1 = barrier.SignalAndWaitAsync();
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(2, barrier.ParticipantCount);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
var task2 = barrier.SignalAndWaitAsync();
Assert.AreSame(task1, task2);
await task1;
Assert.AreEqual(1, barrier.CurrentPhaseNumber);
Assert.AreEqual(2, barrier.ParticipantCount);
Assert.AreEqual(2, barrier.ParticipantsRemaining);
});
}
public void SignalZero_DoesNothing()
{
AsyncContext.Run(async() =>
{
var barrier = new AsyncBarrier(1);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
var task = barrier.SignalAndWaitAsync(0);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
await AssertEx.NeverCompletesAsync(task);
});
}
public void AsyncPostPhaseAction_PropagatesExceptions()
{
Test.Async(async() =>
{
var barrier = new AsyncBarrier(1, async _ =>
{
await TaskShim.Yield();
throw new NotImplementedException();
});
await AssertEx.ThrowsExceptionAsync <NotImplementedException>(barrier.SignalAndWaitAsync(), allowDerivedTypes: false);
});
}
public void SignalAndWaitAsync_LastParticipant_CompletesPhase()
{
AsyncContext.Run(async() =>
{
var barrier = new AsyncBarrier(1);
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(1, barrier.ParticipantCount);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
await barrier.SignalAndWaitAsync();
Assert.AreEqual(1, barrier.CurrentPhaseNumber);
Assert.AreEqual(1, barrier.ParticipantCount);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
});
}
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);
}
