public async Task Wait_Unset_IsNotCompleted() { var mre = new AsyncManualResetEvent(); var task = Task.Run(() => mre.Wait()); await AsyncAssert.NeverCompletesAsync(task); }
public async Task ReadLocked_PreventsWriterLock() { var rwl = new AsyncReaderWriterLock(); await rwl.ReaderLockAsync(); var task = rwl.WriterLockAsync().AsTask(); await AsyncAssert.NeverCompletesAsync(task); }
public async Task WaitAsync_Cancelled_ThrowsException() { var are = new AsyncAutoResetEvent(); var cts = new CancellationTokenSource(); cts.Cancel(); var task = are.WaitAsync(cts.Token); await AsyncAssert.ThrowsAsync <OperationCanceledException>(task); }
public async Task Cancelled_WhenInQueue_CancelsTask() { IAsyncWaitQueue <object> queue = new DefaultAsyncWaitQueue <object>() as IAsyncWaitQueue <object>; CancellationTokenSource cts = new CancellationTokenSource(); Task <object> task = queue.Enqueue(new object(), cts.Token); cts.Cancel(); await AsyncAssert.ThrowsAsync <OperationCanceledException>(task).ConfigureAwait(false); }
public async Task CompletedDeferralFollowedByIncompleteDeferral_PreventsCompletion() { DeferralManager dm = new DeferralManager(); dm.DeferralSource.GetDeferral().Dispose(); IDisposable deferral = dm.DeferralSource.GetDeferral(); Task task = dm.WaitForDeferralsAsync(); await AsyncAssert.NeverCompletesAsync(task).ConfigureAwait(false); }
public async Task WaitAsync_Cancelled_ThrowsException() { AsyncAutoResetEvent are = new AsyncAutoResetEvent(); CancellationTokenSource cts = new CancellationTokenSource(); cts.Cancel(); Task task = are.WaitAsync(cts.Token); await AsyncAssert.ThrowsAsync <OperationCanceledException>(task).ConfigureAwait(false); }
public async Task Cancelled_WhenInQueue_CancelsTask() { var queue = new DefaultAsyncWaitQueue <object>() as IAsyncWaitQueue <object>; var cts = new CancellationTokenSource(); var task = queue.Enqueue(new object(), cts.Token); cts.Cancel(); await AsyncAssert.ThrowsAsync <OperationCanceledException>(task); }
public async Task CompletedDeferralFollowedByIncompleteDeferral_PreventsCompletion() { var dm = new DeferralManager(); dm.DeferralSource.GetDeferral().Dispose(); var deferral = dm.DeferralSource.GetDeferral(); var task = dm.WaitForDeferralsAsync(); await AsyncAssert.NeverCompletesAsync(task); }
public void WaitAndUnwrapExceptionWithCT_CancellationTokenCancelled_Cancels() { TaskCompletionSource <object> tcs = new TaskCompletionSource <object>(); Task task = tcs.Task; CancellationTokenSource cts = new CancellationTokenSource(); cts.Cancel(); AsyncAssert.Throws <OperationCanceledException>(() => task.WaitAndUnwrapException(cts.Token)); }
public async Task ThrowsAsync_SynchronousDelegateThrowsDerivedException_ReturnsException() { var expectedException = new TaskCanceledException(); var result = await AsyncAssert.ThrowsAsync <OperationCanceledException>(() => { throw expectedException; }); Assert.Same(expectedException, result); }
public async Task ThrowsAsync_SynchronousDelegateThrowsWrongException_Fails() { await Assert.ThrowsAsync <Exception>(async() => { await AsyncAssert.ThrowsAsync <NotImplementedException>(() => { throw new InvalidOperationException(); }); }); }
public async Task CancelsAsync_TaskDoesNotCancel_Fails() { await Assert.ThrowsAsync <Exception>(async() => { var tcs = new TaskCompletionSource <object>(); var testTask = AsyncAssert.CancelsAsync(tcs.Task); tcs.SetResult(null); await testTask; }); }
public async Task ThrowsAsync_TaskThrowsWrongException_Fails() { await Assert.ThrowsAsync <Exception>(async() => { var tcs = new TaskCompletionSource <object>(); var testTask = AsyncAssert.ThrowsAsync <NotImplementedException>(tcs.Task); tcs.SetException(new InvalidOperationException()); await testTask; }); }
public void SynchronizationContextPost_PropagatesException() { Action test = () => AsyncContext.Run(async() => { SynchronizationContext.Current.Post(_ => throw new NotImplementedException(), null); await Task.Yield(); }); AsyncAssert.Throws <NotImplementedException>(test, allowDerivedTypes: false); }
public async Task MultipleDeferralsWithOneIncomplete_PreventsCompletion() { var dm = new DeferralManager(); var deferral1 = dm.DeferralSource.GetDeferral(); var deferral2 = dm.DeferralSource.GetDeferral(); var task = dm.WaitForDeferralsAsync(); deferral1.Dispose(); await AsyncAssert.NeverCompletesAsync(task); }
public async Task Wait_AfterReset_IsNotCompleted() { AsyncManualResetEvent mre = new AsyncManualResetEvent(); mre.Set(); mre.Reset(); Task task = Task.Run(() => mre.Wait()); await AsyncAssert.NeverCompletesAsync(task).ConfigureAwait(false); }
public async Task Dequeue_WithTwoItems_OnlyCompletesFirstItem() { IAsyncWaitQueue <object> queue = new DefaultAsyncWaitQueue <object>() as IAsyncWaitQueue <object>; Task <object> task1 = queue.Enqueue(); Task <object> task2 = queue.Enqueue(); queue.Dequeue(); Assert.True(task1.IsCompleted); await AsyncAssert.NeverCompletesAsync(task2).ConfigureAwait(false); }
public async Task ThrowsAsync_SynchronousDelegateThrowsBaseException_Fails() { await Assert.ThrowsAsync <Exception>(async() => { await AsyncAssert.ThrowsAsync <TaskCanceledException>(() => { throw new OperationCanceledException(); }); }); }
public async Task ThrowsAsync_ExpectingSpecificException_SynchronousDelegateThrowsDerivedException_Fails() { await Assert.ThrowsAsync <Exception>(async() => { await AsyncAssert.ThrowsAsync <OperationCanceledException>(() => { throw new TaskCanceledException(); }, false); }); }
public async Task ThrowsAsync_ExpectingSpecificException_TaskThrowsDerivedException_Fails() { await Assert.ThrowsAsync <Exception>(async() => { var tcs = new TaskCompletionSource <object>(); var testTask = AsyncAssert.ThrowsAsync <OperationCanceledException>(tcs.Task, false); tcs.SetException(new TaskCanceledException()); await testTask; }); }
public async Task CancelsAsync_TaskThrowsBaseException_Fails() { await Assert.ThrowsAsync <Exception>(async() => { var tcs = new TaskCompletionSource <object>(); var testTask = AsyncAssert.CancelsAsync(tcs.Task); tcs.SetException(new Exception()); await testTask; }); }
public async Task WaitAsync_NoSlotsAvailable_IsNotCompleted() { var semaphore = new AsyncSemaphore(0); Assert.Equal(0, semaphore.CurrentCount); var task = semaphore.WaitAsync(); Assert.Equal(0, semaphore.CurrentCount); await AsyncAssert.NeverCompletesAsync(task); }
public async Task MultipleWaitAsync_Set_OnlyOneIsCompleted() { AsyncAutoResetEvent are = new AsyncAutoResetEvent(true); Task task1 = are.WaitAsync(); Task task2 = are.WaitAsync(); Assert.True(task1.IsCompleted); await AsyncAssert.NeverCompletesAsync(task2).ConfigureAwait(false); }
public async Task EnqueueAsync_Cancelled_Throws() { var queue = new AsyncProducerConsumerQueue <int>(new[] { 13 }, 1); var cts = new CancellationTokenSource(); var task = queue.EnqueueAsync(7, cts.Token); cts.Cancel(); await AsyncAssert.ThrowsAsync <OperationCanceledException>(() => task); }
public async Task Dequeue_WithTwoItems_OnlyCompletesFirstItem() { var queue = new DefaultAsyncWaitQueue <object>() as IAsyncWaitQueue <object>; var task1 = queue.Enqueue(); var task2 = queue.Enqueue(); queue.Dequeue(); Assert.True(task1.IsCompleted); await AsyncAssert.NeverCompletesAsync(task2); }
public async Task ThrowsAsync_DelegateDoesNotThrow_Fails() { await Assert.ThrowsAsync <Exception>(async() => { await AsyncAssert.ThrowsAsync(async() => { await Task.Yield(); }); }); }
public async Task DequeueAsync_Cancelled_Throws() { AsyncProducerConsumerQueue <int> queue = new AsyncProducerConsumerQueue <int>(); CancellationTokenSource cts = new CancellationTokenSource(); Task <int> task = queue.DequeueAsync(cts.Token); cts.Cancel(); await AsyncAssert.ThrowsAsync <OperationCanceledException>(() => task).ConfigureAwait(false); }
public async Task MultipleWaitAsync_Set_OnlyOneIsCompleted() { var are = new AsyncAutoResetEvent(true); var task1 = are.WaitAsync(); var task2 = are.WaitAsync(); Assert.True(task1.IsCompleted); await AsyncAssert.NeverCompletesAsync(task2); }
public async Task WaitAsync_NoSlotsAvailable_IsNotCompleted() { AsyncSemaphore semaphore = new AsyncSemaphore(0); Assert.Equal(0, semaphore.CurrentCount); Task task = semaphore.WaitAsync(); Assert.Equal(0, semaphore.CurrentCount); await AsyncAssert.NeverCompletesAsync(task).ConfigureAwait(false); }
public async Task ThrowsAsync_SynchronousDelegateThrows_ReturnsException() { var expectedException = new InvalidOperationException(); var result = await AsyncAssert.ThrowsAsync(() => { throw expectedException; }); Assert.Same(expectedException, result); }