[Fact] // Bizarre behavior when using the built-in Pipe class: https://github.com/dotnet/corefx/issues/31696 public async Task CancelPendingRead() { var stream = new HalfDuplexStream(); var reader = this.CreatePipeReader(stream, sizeHint: 50); ValueTask <ReadResult> readTask = reader.ReadAsync(this.TimeoutToken); reader.CancelPendingRead(); var readResult = await readTask.AsTask().WithCancellation(this.TimeoutToken); Assert.True(readResult.IsCanceled); ////reader.AdvanceTo(readResult.Buffer.End); // Verify we can read after that without cancellation. readTask = reader.ReadAsync(this.TimeoutToken); stream.Write(new byte[] { 1, 2, 3 }, 0, 3); await stream.FlushAsync(this.TimeoutToken); readResult = await readTask; Assert.False(readResult.IsCanceled); Assert.Equal(3, readResult.Buffer.Length); reader.AdvanceTo(readResult.Buffer.End); // Now cancel again readTask = reader.ReadAsync(this.TimeoutToken); reader.CancelPendingRead(); readResult = await readTask; Assert.True(readResult.IsCanceled); }
public async Task Complete_CausesWriterCompletion() { var stream = new HalfDuplexStream(); var reader = this.CreatePipeReader(stream); Task writerCompletion = reader.WaitForWriterCompletionAsync(); reader.Complete(); await writerCompletion.WithCancellation(this.TimeoutToken); }
public async Task UsePipe_Stream_Disposal() { var ms = new HalfDuplexStream(); IDuplexPipe pipe = ms.UsePipe(cancellationToken: this.TimeoutToken); pipe.Output.Complete(); pipe.Input.Complete(); await this.AssertStreamClosesAsync(ms); }
public async Task UsePipe_Stream() { var ms = new HalfDuplexStream(); IDuplexPipe pipe = ms.UsePipe(cancellationToken: this.TimeoutToken); await pipe.Output.WriteAsync(new byte[] { 1, 2, 3 }, this.TimeoutToken); var readResult = await pipe.Input.ReadAsync(this.TimeoutToken); Assert.Equal(3, readResult.Buffer.Length); pipe.Input.AdvanceTo(readResult.Buffer.End); }
public async Task CancelPendingRead_WithCancellationToken() { var stream = new HalfDuplexStream(); var reader = this.CreatePipeReader(stream, sizeHint: 50); var cts = new CancellationTokenSource(); ValueTask <ReadResult> readTask = reader.ReadAsync(cts.Token); cts.Cancel(); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => readTask.AsTask()); }
public async Task Complete_CausesWriterCompletion() { var stream = new HalfDuplexStream(); var reader = this.CreatePipeReader(stream); #pragma warning disable CS0618 // Type or member is obsolete Task writerCompletion = reader.WaitForWriterCompletionAsync(); #pragma warning restore CS0618 // Type or member is obsolete reader.Complete(); await writerCompletion.WithCancellation(this.TimeoutToken); }
public async Task UsePipe_Stream_Disposal() { var ms = new HalfDuplexStream(); IDuplexPipe pipe = ms.UsePipe(cancellationToken: this.TimeoutToken); pipe.Output.Complete(); pipe.Input.Complete(); while (!ms.IsDisposed && !this.TimeoutToken.IsCancellationRequested) { await Task.Yield(); } Assert.True(ms.IsDisposed); }
public async Task Complete_DoesNotCauseStreamDisposal() { var stream = new HalfDuplexStream(); var reader = this.CreatePipeReader(stream); reader.Complete(); var timeout = ExpectedTimeoutToken; while (!stream.IsDisposed && !timeout.IsCancellationRequested) { await Task.Yield(); } Assert.False(stream.IsDisposed); }
public async Task ReadAsyncAfterExamining() { byte[] expectedBuffer = this.GetRandomBuffer(2048); var stream = new HalfDuplexStream(); stream.Write(expectedBuffer, 0, 50); await stream.FlushAsync(this.TimeoutToken); var reader = this.CreatePipeReader(stream, sizeHint: 50); byte[] actualBuffer = new byte[expectedBuffer.Length]; ReadResult result = await reader.ReadAsync(this.TimeoutToken); reader.AdvanceTo(result.Buffer.Start, result.Buffer.GetPosition(1)); // Since we didn't examine all the bytes already in the buffer, the next read should be synchronous, // and shouldn't give us any more buffer. ValueTask <ReadResult> resultTask = reader.ReadAsync(this.TimeoutToken); Assert.True(resultTask.IsCompleted); Assert.Equal(result.Buffer.Length, resultTask.Result.Buffer.Length); // Now examine everything, but don't consume it. We should get more. reader.AdvanceTo(resultTask.Result.Buffer.Start, resultTask.Result.Buffer.End); ValueTask <ReadResult> resultTask2 = reader.ReadAsync(this.TimeoutToken); Assert.False(resultTask2.IsCompleted); stream.Write(expectedBuffer, 50, 50); await stream.FlushAsync(this.TimeoutToken); var result2 = await resultTask2; Assert.True(result2.Buffer.Length > result.Buffer.Length); // Now consume everything and get even more. reader.AdvanceTo(result2.Buffer.End); stream.Write(expectedBuffer, 100, expectedBuffer.Length - 100); await stream.FlushAsync(this.TimeoutToken); ReadResult result3 = await reader.ReadAsync(this.TimeoutToken); Assert.True(result3.Buffer.Length > 0); }
public async Task UsePipe_Stream_OneDirectionDoesNotDispose(bool completeOutput) { var ms = new HalfDuplexStream(); IDuplexPipe pipe = ms.UsePipe(cancellationToken: this.TimeoutToken); if (completeOutput) { pipe.Output.Complete(); } else { pipe.Input.Complete(); } var timeout = ExpectedTimeoutToken; while (!ms.IsDisposed && !timeout.IsCancellationRequested) { await Task.Yield(); } Assert.False(ms.IsDisposed); }
public void DefaultCtor() { var stream = new HalfDuplexStream(); stream.Dispose(); }