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