public A GetResult()
{
var result = awaiter.GetResult();
return(result.IsSucc
? result.Value
: throw new AffException(result.Error));
}
public void ReadAsyncCompletedAfterPreCancellation()
{
Reader.CancelPendingRead();
Write(new byte[] { 1, 2, 3 });
ValueTaskAwaiter <ReadResult> awaitable = Reader.ReadAsync().GetAwaiter();
Assert.True(awaitable.IsCompleted);
ReadResult result = awaitable.GetResult();
Assert.True(result.IsCanceled);
awaitable = Reader.ReadAsync().GetAwaiter();
Assert.True(awaitable.IsCompleted);
Reader.AdvanceTo(awaitable.GetResult().Buffer.End);
}
void ContinuationWithCapture(ValueTaskAwaiter awaiter)
{
try
{
awaiter.GetResult();
}
catch (Exception ex)
{
exception = ExceptionDispatchInfo.Capture(ex);
TryInvokeContinuation();
return;
}
TryInvokeContinuationWithIncrement();
}
public void ReadAsyncReturnsIsCancelOnCancelPendingReadBeforeGetResult()
{
ValueTaskAwaiter <ReadResult> awaitable = Pipe.Reader.ReadAsync().GetAwaiter();
Assert.False(awaitable.IsCompleted);
awaitable.OnCompleted(() => { });
Pipe.Writer.WriteAsync(new byte[] { });
Pipe.Reader.CancelPendingRead();
Assert.True(awaitable.IsCompleted);
ReadResult result = awaitable.GetResult();
Assert.True(result.IsCanceled);
}
void RegisterContinuation(ValueTaskAwaiter awaiter, int index)
{
awaiter.UnsafeOnCompleted(() =>
{
try
{
awaiter.GetResult();
}
catch (Exception ex)
{
exception = ExceptionDispatchInfo.Capture(ex);
TryInvokeContinuation();
return;
}
TryInvokeContinuationWithIncrement();
});
}
public void FlushAsyncReturnsIsCancelOnCancelPendingFlushBeforeGetResult()
{
PipeWriter writableBuffer = Pipe.Writer.WriteEmpty(MaximumSizeHigh);
ValueTaskAwaiter <FlushResult> awaitable = writableBuffer.FlushAsync().GetAwaiter();
Assert.False(awaitable.IsCompleted);
awaitable.OnCompleted(() => { });
Pipe.Reader.AdvanceTo(Pipe.Reader.ReadAsync().GetAwaiter().GetResult().Buffer.End);
Pipe.Writer.CancelPendingFlush();
Assert.True(awaitable.IsCompleted);
FlushResult result = awaitable.GetResult();
Assert.True(result.IsCanceled);
}
public void ValueTask_GetResultWhenNotCompleted_Throws()
{
ValueTaskAwaiter <int> readVt = CreateChannel().Reader.ReadAsync().GetAwaiter();
Assert.Throws <InvalidOperationException>(() => readVt.GetResult());
ValueTaskAwaiter <bool> waitReadVt = CreateChannel().Reader.WaitToReadAsync().GetAwaiter();
Assert.Throws <InvalidOperationException>(() => waitReadVt.GetResult());
if (CreateFullChannel() != null)
{
ValueTaskAwaiter writeVt = CreateFullChannel().Writer.WriteAsync(42).GetAwaiter();
Assert.Throws <InvalidOperationException>(() => writeVt.GetResult());
ValueTaskAwaiter <bool> waitWriteVt = CreateFullChannel().Writer.WaitToWriteAsync().GetAwaiter();
Assert.Throws <InvalidOperationException>(() => waitWriteVt.GetResult());
}
}
public void GetResultThrowsIfReadAsyncCanceledBeforeOnCompleted()
{
var onCompletedCalled = false;
var cancellationTokenSource = new CancellationTokenSource();
ValueTaskAwaiter <ReadResult> awaiter = Pipe.Reader.ReadAsync(cancellationTokenSource.Token).GetAwaiter();
bool awaiterIsCompleted = awaiter.IsCompleted;
cancellationTokenSource.Cancel();
awaiter.OnCompleted(
() => {
onCompletedCalled = true;
Assert.Throws <OperationCanceledException>(() => awaiter.GetResult());
});
Assert.False(awaiterIsCompleted);
Assert.True(onCompletedCalled);
}
public void GetResultThrowsIfFlushAsyncCanceledBeforeOnCompleted()
{
var onCompletedCalled = false;
var cancellationTokenSource = new CancellationTokenSource();
PipeWriter buffer = Pipe.Writer.WriteEmpty(MaximumSizeHigh);
ValueTaskAwaiter <FlushResult> awaiter = buffer.FlushAsync(cancellationTokenSource.Token).GetAwaiter();
bool awaiterIsCompleted = awaiter.IsCompleted;
cancellationTokenSource.Cancel();
awaiter.OnCompleted(
() => {
onCompletedCalled = true;
Assert.Throws <OperationCanceledException>(() => awaiter.GetResult());
});
Assert.False(awaiterIsCompleted);
Assert.True(onCompletedCalled);
}
public void ReadAsyncNotCompletedAfterCancellationTokenCanceled()
{
var onCompletedCalled = false;
var cts = new CancellationTokenSource();
ValueTaskAwaiter <ReadResult> awaitable = Pipe.Reader.ReadAsync(cts.Token).GetAwaiter();
Assert.False(awaitable.IsCompleted);
awaitable.OnCompleted(
() => {
onCompletedCalled = true;
Assert.True(awaitable.IsCompleted);
Assert.Throws <OperationCanceledException>(() => awaitable.GetResult());
awaitable = Pipe.Reader.ReadAsync().GetAwaiter();
Assert.False(awaitable.IsCompleted);
});
cts.Cancel();
Assert.True(onCompletedCalled);
}
public void ReadAsyncNotCompletedAfterCancellation()
{
var onCompletedCalled = false;
ValueTaskAwaiter <ReadResult> awaitable = Pipe.Reader.ReadAsync().GetAwaiter();
Assert.False(awaitable.IsCompleted);
awaitable.OnCompleted(
() => {
onCompletedCalled = true;
Assert.True(awaitable.IsCompleted);
ReadResult readResult = awaitable.GetResult();
Assert.True(readResult.IsCanceled);
awaitable = Pipe.Reader.ReadAsync().GetAwaiter();
Assert.False(awaitable.IsCompleted);
});
Pipe.Reader.CancelPendingRead();
Assert.True(onCompletedCalled);
}
public async Task ReadAsyncReturnsDataAfterItWasWrittenDuringCancelledRead()
{
ValueTask <ReadResult> readTask = Pipe.Reader.ReadAsync();
ValueTaskAwaiter <ReadResult> awaiter = readTask.GetAwaiter();
ReadResult result = default;
awaiter.OnCompleted(
() =>
{
Pipe.Writer.WriteAsync(new byte[] { 1 }).AsTask().Wait();
result = awaiter.GetResult();
});
Pipe.Reader.CancelPendingRead();
Assert.True(result.IsCanceled);
result = await Pipe.Reader.ReadAsync();
Assert.False(result.IsCanceled);
Assert.Equal(new byte[] { 1 }, result.Buffer.ToArray());
}
public void FlushAsyncNotCompletedAfterCancellationTokenCanceled()
{
var onCompletedCalled = false;
var cts = new CancellationTokenSource();
PipeWriter writableBuffer = Pipe.Writer.WriteEmpty(MaximumSizeHigh);
ValueTaskAwaiter <FlushResult> awaitable = writableBuffer.FlushAsync(cts.Token).GetAwaiter();
Assert.False(awaitable.IsCompleted);
awaitable.OnCompleted(
() => {
onCompletedCalled = true;
Assert.True(awaitable.IsCompleted);
Assert.Throws <OperationCanceledException>(() => awaitable.GetResult());
awaitable = writableBuffer.FlushAsync().GetAwaiter();
Assert.False(awaitable.IsCompleted);
});
cts.Cancel();
Assert.True(onCompletedCalled);
}
public void FlushAsyncNotCompletedAfterCancellation()
{
var onCompletedCalled = false;
PipeWriter writableBuffer = Pipe.Writer.WriteEmpty(MaximumSizeHigh);
ValueTaskAwaiter <FlushResult> awaitable = writableBuffer.FlushAsync().GetAwaiter();
Assert.False(awaitable.IsCompleted);
awaitable.OnCompleted(
() => {
onCompletedCalled = true;
Assert.True(awaitable.IsCompleted);
FlushResult flushResult = awaitable.GetResult();
Assert.True(flushResult.IsCanceled);
awaitable = writableBuffer.FlushAsync().GetAwaiter();
Assert.False(awaitable.IsCompleted);
});
Pipe.Writer.CancelPendingFlush();
Assert.True(onCompletedCalled);
}