public async Task TryCompleteFromCompletedTask_PropagatesCancellation()
{
TaskCompletionSource <int> tcs = new TaskCompletionSource <int>();
tcs.TryCompleteFromCompletedTask(TaskConstants.Canceled, () => - 1);
await AsyncAssert.ThrowsAsync <OperationCanceledException>(() => tcs.Task).ConfigureAwait(false);
}
public async Task ThrowsAsync_SynchronousTaskDoesNotThrow_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await AsyncAssert.ThrowsAsync(Task.FromResult(0));
});
}
public async Task TryCompleteFromCompletedTask_PropagatesException()
{
TaskCompletionSource <int> tcs = new TaskCompletionSource <int>();
tcs.TryCompleteFromCompletedTask(Task.FromException(new NotImplementedException()), () => - 1);
await AsyncAssert.ThrowsAsync <NotImplementedException>(() => tcs.Task).ConfigureAwait(false);
}
public async Task ThrowsAsync_SynchronousTaskThrowsExpectedException_ReturnsException()
{
var expectedException = new InvalidOperationException();
var result = await AsyncAssert.ThrowsAsync <InvalidOperationException>(Task.FromException(expectedException));
Assert.Same(expectedException, result);
}
public async Task ThrowsAsync_SynchronousTaskThrowsWrongException_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await AsyncAssert.ThrowsAsync <NotImplementedException>(Task.FromException(new InvalidOperationException()));
});
}
public async Task ThrowsAsync_SynchronousTaskThrowsBaseException_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await AsyncAssert.ThrowsAsync <TaskCanceledException>(Task.FromException(new OperationCanceledException()));
});
}
public async Task ThrowsAsync_SynchronousTaskThrowsDerivedException_ReturnsException()
{
var expectedException = new TaskCanceledException();
var result = await AsyncAssert.ThrowsAsync <OperationCanceledException>(Task.FromException(expectedException));
Assert.Same(expectedException, result);
}
public async Task ThrowsAsync_ExpectingSpecificException_SynchronousTaskThrowsDerivedException_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await AsyncAssert.ThrowsAsync <OperationCanceledException>(Task.FromException(new TaskCanceledException()), false);
});
}
public async Task AsyncLock_CancelledLock_LeavesLockUnlocked()
{
AsyncLock mutex = new AsyncLock();
CancellationTokenSource cts = new CancellationTokenSource();
TaskCompletionSource <object> taskReady = TaskCompletionSourceExtensions.CreateAsyncTaskSource <object>();
IDisposable unlock = await mutex.LockAsync();
Task task = Task.Run(async() =>
{
AwaitableDisposable <IDisposable> lockTask = mutex.LockAsync(cts.Token);
taskReady.SetResult(null);
await lockTask;
});
await taskReady.Task;
cts.Cancel();
await AsyncAssert.ThrowsAsync <OperationCanceledException>(task).ConfigureAwait(false);
Assert.True(task.IsCanceled);
unlock.Dispose();
AwaitableDisposable <IDisposable> finalLockTask = mutex.LockAsync();
await finalLockTask;
}
public async Task ThrowsCorrectExceptionOnCustomerCancellationTokens(Type initial, Type translated)
{
// not supported on sync
if (!IsAsync)
{
Assert.Ignore();
}
var stream1 = new MockReadStream(100, throwAfter: 25, canSeek: true, exceptionType: initial);
MockTransport mockTransport = CreateMockTransport(
new MockResponse(200)
{
ContentStream = stream1
});
var pipeline = new HttpPipeline(mockTransport);
Stream reliableStream = await CreateAsync(
offset => SendTestRequest(pipeline, offset),
offset => SendTestRequestAsync(pipeline, offset),
ResponseClassifier.Shared,
maxRetries : 5);
Assert.AreEqual(25, await ReadAsync(reliableStream, _buffer, 0, 25));
Assert.AreEqual(100, reliableStream.Length);
Assert.AreEqual(25, reliableStream.Position);
var exception = await AsyncAssert.ThrowsAsync <Exception>(
async() => await ReadAsync(reliableStream, _buffer, 25, 25, new CancellationToken(true)));
Assert.IsInstanceOf(translated, exception);
AssertReads(_buffer, 25);
}
public async Task AsyncLock_CancelledLock_LeavesLockUnlocked()
{
var mutex = new AsyncLock();
var cts = new CancellationTokenSource();
var taskReady = new TaskCompletionSource <object>();
var unlock = await mutex.LockAsync();
var task = Task.Run(async() =>
{
var lockTask = mutex.LockAsync(cts.Token);
taskReady.SetResult(null);
await lockTask;
});
await taskReady.Task;
cts.Cancel();
await AsyncAssert.ThrowsAsync <OperationCanceledException>(task);
Assert.True(task.IsCanceled);
unlock.Dispose();
var finalLockTask = mutex.LockAsync();
await finalLockTask;
}
public async Task TryCompleteFromCompletedTaskTResult_PropagatesCancellation()
{
var tcs = new TaskCompletionSource <int>();
tcs.TryCompleteFromCompletedTask(TaskConstants <int> .Canceled);
await AsyncAssert.ThrowsAsync <OperationCanceledException>(() => tcs.Task);
}
public async Task DequeueAsync_EmptyAndComplete_ThrowsException()
{
var queue = new AsyncProducerConsumerQueue <int>();
queue.CompleteAdding();
await AsyncAssert.ThrowsAsync <InvalidOperationException>(() => queue.DequeueAsync());
}
public async Task EnqueueAsync_CompleteAdding_ThrowsException()
{
AsyncProducerConsumerQueue <int> queue = new AsyncProducerConsumerQueue <int>();
queue.CompleteAdding();
await AsyncAssert.ThrowsAsync <InvalidOperationException>(() => queue.EnqueueAsync(3)).ConfigureAwait(false);
}
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 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 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 ThrowsAsync_SynchronousDelegateThrowsBaseException_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await AsyncAssert.ThrowsAsync <TaskCanceledException>(() =>
{
throw new OperationCanceledException();
});
});
}
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 ThrowsAsync_DelegateDoesNotThrow_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await AsyncAssert.ThrowsAsync(async() =>
{
await Task.Yield();
});
});
}
public async Task ThrowsAsync_TaskDoesNotThrow_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
var tcs = new TaskCompletionSource <object>();
var testTask = AsyncAssert.ThrowsAsync(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 async Task ThrowsAsync_TaskThrowsBaseException_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
var tcs = new TaskCompletionSource <object>();
var testTask = AsyncAssert.ThrowsAsync <TaskCanceledException>(tcs.Task);
tcs.SetException(new OperationCanceledException());
await testTask;
});
}
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 ThrowsAsync_ExpectingSpecificException_SynchronousDelegateThrowsDerivedException_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await AsyncAssert.ThrowsAsync <OperationCanceledException>(() =>
{
throw new TaskCanceledException();
}, false);
});
}
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 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 ThrowsAsync_SynchronousDelegateThrows_ReturnsException()
{
var expectedException = new InvalidOperationException();
var result = await AsyncAssert.ThrowsAsync(() =>
{
throw expectedException;
});
Assert.Same(expectedException, result);
}
public async Task ThrowsAsync_SynchronousDelegateThrowsWrongException_Fails()
{
await Assert.ThrowsAsync <Exception>(async() =>
{
await AsyncAssert.ThrowsAsync <NotImplementedException>(() =>
{
throw new InvalidOperationException();
});
});
}