public async Task Await_ShouldThrowIfCanceled()
{
// Arrange
var op = new AsyncCompletionSource();
var actualException = default(Exception);
var task = Task.Run(() =>
{
Thread.Sleep(10);
op.SetCanceled();
});
// Act
try
{
await op;
}
catch (Exception e)
{
actualException = e;
}
// Assert
Assert.IsType <OperationCanceledException>(actualException);
AssertCanceled(op);
}
public async Task Await_ShouldThrowIfFaulted()
{
// Arrange
var op = new AsyncCompletionSource();
var expectedException = new Exception();
var actualException = default(Exception);
var task = Task.Run(() =>
{
Thread.Sleep(10);
op.SetException(expectedException);
});
// Act
try
{
await op;
}
catch (Exception e)
{
actualException = e;
}
// Assert
Assert.Equal(expectedException, actualException);
AssertFaulted(op);
}
public void SetRunning_ThrowsIfOperationIsNotCreatedOrScheduled(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act/Assert
Assert.Throws <InvalidOperationException>(() => op.SetRunning());
}
public void TrySetException_ThrowsIfExceptionIsNull()
{
// Arrange
var op = new AsyncCompletionSource();
// Act/Assert
Assert.Throws <ArgumentNullException>(() => op.TrySetException(null));
}
public void SetProgress_ThrowsIfOperationIsNotRunning(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act/Assert
Assert.Throws <InvalidOperationException>(() => op.SetProgress(0.1f));
}
public void Id_ShouldReturnNonZeroValue()
{
// Arrange
var op = new AsyncCompletionSource();
// Act/Assert
Assert.NotEqual(0, op.Id);
}
public void SetResult_ThrowsIfOperationIsCompleted(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource <int>(status);
// Act/Assert
Assert.Throws <InvalidOperationException>(() => op.SetResult(10));
Assert.True(op.CompletedSynchronously);
}
public void TrySetResult_ThrowsIfOperationIsDisposed()
{
// Arrange
var op = new AsyncCompletionSource <int>(AsyncOperationStatus.Canceled);
op.Dispose();
// Act/Assert
Assert.Throws <ObjectDisposedException>(() => op.TrySetResult(15));
}
public void SetRunning_ThrowsIfOperationIsDisposed()
{
// Arrange
var op = new AsyncCompletionSource(AsyncOperationStatus.RanToCompletion);
op.Dispose();
// Act/Assert
Assert.Throws <ObjectDisposedException>(() => op.SetRunning());
}
public void Cancel_CanBeSuppressed(AsyncCreationOptions options, bool expectedCompleted)
{
// Arrange
var op = new AsyncCompletionSource(options);
// Act
op.Cancel();
// Assert
Assert.Equal(expectedCompleted, op.IsCompleted);
}
public void SetScheduled_SetsStatusToScheduled(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act
op.SetScheduled();
// Assert
AssertNotCompleted(op, AsyncOperationStatus.Scheduled);
}
public void TrySetException_ThrowsIfOperationIsDisposed()
{
// Arrange
var e = new Exception();
var op = new AsyncCompletionSource(AsyncOperationStatus.RanToCompletion);
op.Dispose();
// Act/Assert
Assert.Throws <ObjectDisposedException>(() => op.TrySetException(e));
}
public void TrySetProgress_ReturnsCorrentValue(AsyncOperationStatus status, bool expectedResult)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act
var result = op.TrySetProgress(1);
// Assert
Assert.Equal(expectedResult, result);
}
public void SetRunning_SetsStatusToRunning(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act
op.SetRunning();
// Assert
AssertNotCompleted(op, AsyncOperationStatus.Running);
}
public void TrySetCompleted_SetsStatusToRanToCompletion(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act
var result = op.TrySetCompleted();
// Assert
Assert.True(op.IsCompletedSuccessfully);
Assert.True(result);
}
public void TrySetCanceled_SetsStatusToCanceled(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act
var result = op.TrySetCanceled();
// Assert
Assert.True(op.IsCanceled);
Assert.True(result);
}
public void Progress_ReturnsCorrentValue(AsyncOperationStatus status, float expectedValue)
{
// Arrange
var progress = 0.3f;
var op = new AsyncCompletionSource(status);
// Act
op.TrySetProgress(progress);
// Assert
Assert.Equal(expectedValue, op.Progress);
}
public void SetProgress_SetsCorrectValue()
{
// Arrange
var progress = 0.7f;
var op = new AsyncCompletionSource(AsyncOperationStatus.Running);
// Act
op.SetProgress(progress);
// Assert
Assert.Equal(progress, op.Progress);
}
public void TrySetResult_FailsIfOperationIsCompleted()
{
// Arrange
var op = new AsyncCompletionSource <int>(AsyncOperationStatus.Canceled);
// Act
var result = op.TrySetResult(10);
// Assert
Assert.False(result);
Assert.True(op.CompletedSynchronously);
Assert.True(op.IsCanceled);
}
public void ToObservable_OnCompletedIsNotCalledOnError()
{
// Arrange
var op = new AsyncCompletionSource <int>();
var observer = new Observer <int>();
var observable = op.Subscribe(observer);
// Act
op.SetException(new Exception());
// Assert
Assert.Equal(0, observer.OnCompletedCount);
}
public void ToObservable_OnCompletedIsCalledOnCancellation()
{
// Arrange
var op = new AsyncCompletionSource <int>();
var observer = new Observer <int>();
var observable = op.Subscribe(observer);
// Act
op.SetCanceled();
// Assert
Assert.Equal(1, observer.OnErrorCount);
}
public void TrySetCanceled_FailsIfOperationIsCompleted()
{
// Arrange
var op = new AsyncCompletionSource(AsyncOperationStatus.RanToCompletion);
// Act
var result = op.TrySetCanceled();
// Assert
Assert.False(result);
Assert.True(op.CompletedSynchronously);
Assert.True(op.IsCompletedSuccessfully);
}
public void TryAddCompletionCallback_FailsIfOperationIsCompleted()
{
// Arrange
var op = new AsyncCompletionSource();
op.SetCanceled();
// Act
var result = op.TryAddCompletionCallback(_ => { }, null);
// Assert
Assert.False(result);
}
public void ToObservable_OnCompletedIsCalledAfterOnNext()
{
// Arrange
var op = new AsyncCompletionSource <int>();
var observer = new Observer <int>();
var observable = op.Subscribe(observer);
// Act
op.SetResult(10);
// Assert
Assert.Equal(1, observer.OnCompletedCount);
}
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 void TrySetException_SetsStatusToCanceled(AsyncOperationStatus status)
{
// Arrange
var e = new OperationCanceledException();
var op = new AsyncCompletionSource(status);
// Act
var result = op.TrySetException(e);
// Assert
Assert.True(op.IsCanceled);
Assert.True(result);
Assert.Equal(e, op.Exception);
}
public void TrySetResult_SetsStatusToRanToCompletion(AsyncOperationStatus status)
{
// Arrange
var resultValue = new object();
var op = new AsyncCompletionSource <object>(status);
// Act
var result = op.TrySetResult(resultValue);
// Assert
Assert.True(op.IsCompletedSuccessfully);
Assert.Equal(resultValue, op.Result);
Assert.True(result);
}
public void ToObservable_OnErrorIsCalled()
{
// Arrange
var e = new Exception();
var op = new AsyncCompletionSource <int>();
var observer = new Observer <int>();
var observable = op.Subscribe(observer);
// Act
op.SetException(e);
// Assert
Assert.Equal(1, observer.OnErrorCount);
Assert.Equal(e, observer.Exception);
}
public void TrySetCanceled_RaisesCompletionCallbacks()
{
// Arrange
var asyncCallbackCalled1 = false;
var asyncCallbackCalled2 = false;
var op = new AsyncCompletionSource(asyncResult => asyncCallbackCalled1 = true, null);
op.AddCompletionCallback(asyncOp => asyncCallbackCalled2 = true, null);
// Act
op.TrySetCanceled();
// Assert
Assert.True(asyncCallbackCalled1);
Assert.True(asyncCallbackCalled2);
}
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);
}
