public void SetCompleted_ThrowsIfOperationIsCompleted(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act/Assert
Assert.Throws <InvalidOperationException>(() => op.SetCompleted());
Assert.True(op.CompletedSynchronously);
}
public void TryAddContinuation_ExecutesWhenOperationCompletes()
{
// Arrange
var op = new AsyncCompletionSource();
var continuation = Substitute.For <IAsyncContinuation>();
op.TryAddCompletionCallback(continuation);
// Act
op.SetCompleted();
// Assert
continuation.Received(1).Invoke(op);
}
public async Task Await_CollbackIsTriggered()
{
// Arrange
var op = new AsyncCompletionSource();
var task = Task.Run(() =>
{
Thread.Sleep(10);
op.SetCompleted();
});
// Act
await op;
// Assert
AssertCompleted(op);
}
public async Task TryAddCompletionCallback_IsThreadSafe()
{
// Arrange
var op = new AsyncCompletionSource();
var counter = 0;
var d = new Action <IAsyncOperation>(CompletionCallback);
void CompletionCallback(IAsyncOperation o)
{
Interlocked.Increment(ref counter);
}
void TestMethod()
{
for (var i = 0; i < 10000; ++i)
{
op.TryAddCompletionCallback(d);
}
}
void TestMethod2()
{
for (var i = 0; i < 10000; ++i)
{
op.RemoveCompletionCallback(d);
}
}
TestMethod();
// Act
await Task.WhenAll(
Task.Run(new Action(TestMethod)),
Task.Run(new Action(TestMethod)),
Task.Run(new Action(TestMethod2)),
Task.Run(new Action(TestMethod)));
// Assert
op.SetCompleted();
Assert.Equal(30000, counter);
}
public async Task TryAddCompletionCallback_ContinuationsAreRunOnCorrectSynchronozationContext()
{
// Arrange
var op = new AsyncCompletionSource();
var op2 = new AsyncCompletionSource();
var sc = Substitute.For <SynchronizationContext>();
var tid = 0;
var tidActual = 0;
op.TryAddCompletionCallback(_ => { }, sc);
op2.TryAddCompletionCallback(_ => tidActual = Thread.CurrentThread.ManagedThreadId, null);
// Act
await Task.Run(() => op.SetCompleted());
await Task.Run(() => { tid = Thread.CurrentThread.ManagedThreadId; op2.SetCompleted(); });
// Assert
sc.Received(1).Post(Arg.Any <SendOrPostCallback>(), Arg.Any <object>());
Assert.Equal(tid, tidActual);
}
public void SetCompleted_RaisesProgressChanged()
{
// Arrange
var asyncCallbackCalled = false;
var asyncCallbackCalled2 = false;
var progress = 0;
var progress2 = 0f;
var op = new AsyncCompletionSource();
var pc = Substitute.For <IProgress <float> >();
op.ProgressChanged += (sender, args) =>
{
asyncCallbackCalled = true;
progress = args.ProgressPercentage;
};
op.AddProgressCallback(
p =>
{
asyncCallbackCalled2 = true;
progress2 = p;
},
null);
op.AddProgressCallback(pc, null);
// Act
op.SetCompleted();
// Assert
Assert.True(asyncCallbackCalled);
Assert.True(asyncCallbackCalled2);
Assert.Equal(100, progress);
Assert.Equal(1, progress2);
pc.Received(1).Report(1);
}
