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