public async Task ReadAsyncAfterReceivingCompletedReadResultDoesNotThrow()
{
Stream = new ThrowAfterZeroByteReadStream();
Reader = new StreamPipeReader(Stream);
var readResult = await Reader.ReadAsync();
readResult = await Reader.ReadAsync();
Assert.True(readResult.Buffer.IsEmpty);
Assert.True(readResult.IsCompleted);
}
public async Task AdvancePastMinReadSizeReadAsyncReturnsMoreData()
{
Reader = new StreamPipeReader(MemoryStream, 16, new TestMemoryPool());
Write(new byte[32]);
var result = await Reader.ReadAsync();
Assert.Equal(16, result.Buffer.Length);
Reader.AdvanceTo(result.Buffer.GetPosition(12), result.Buffer.End);
result = await Reader.ReadAsync();
Assert.Equal(20, result.Buffer.Length);
}
public async Task ReadWithAdvanceSmallSegments()
{
Reader = new StreamPipeReader(MemoryStream, 16, new TestMemoryPool());
Write(new byte[128]);
var readResult = await Reader.ReadAsync();
Reader.AdvanceTo(readResult.Buffer.End);
readResult = await Reader.ReadAsync();
Assert.Equal(16, readResult.Buffer.Length);
Assert.True(readResult.Buffer.IsSingleSegment);
}
public async Task ReadWithAdvanceDifferentSegmentSize()
{
Reader = new StreamPipeReader(MemoryStream, 4095, new TestMemoryPool());
Write(new byte[10000]);
var readResult = await Reader.ReadAsync();
Reader.AdvanceTo(readResult.Buffer.End);
readResult = await Reader.ReadAsync();
Assert.Equal(4095, readResult.Buffer.Length);
Assert.True(readResult.Buffer.IsSingleSegment);
}
public async Task ConsumePartialBufferWorks()
{
Reader = new StreamPipeReader(MemoryStream, 16, new TestMemoryPool());
Write(Encoding.ASCII.GetBytes(new string('a', 8)));
var readResult = await Reader.ReadAsync();
Reader.AdvanceTo(readResult.Buffer.GetPosition(4), readResult.Buffer.End);
MemoryStream.Position = 0;
readResult = await Reader.ReadAsync();
var resultString = Encoding.ASCII.GetString(readResult.Buffer.ToArray());
Assert.Equal(new string('a', 12), resultString);
Reader.AdvanceTo(readResult.Buffer.End);
}
public async Task ReadCanBeCancelledViaProvidedCancellationToken()
{
var pipeReader = new StreamPipeReader(new HangingStream());
var cts = new CancellationTokenSource(1);
await Task.Delay(1);
await Assert.ThrowsAsync <TaskCanceledException>(async() => await pipeReader.ReadAsync(cts.Token));
}
public async Task AsyncReadWorks()
{
MemoryStream = new AsyncStream();
Reader = new StreamPipeReader(MemoryStream, 16, new TestMemoryPool());
Write(Encoding.ASCII.GetBytes(new string('a', 10000)));
for (var i = 0; i < 99; i++)
{
var readResult = await Reader.ReadAsync();
Reader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End);
}
var result = await Reader.ReadAsync();
Assert.Equal(1600, result.Buffer.Length);
Reader.AdvanceTo(result.Buffer.End);
}
public async Task AdvanceMultipleSegments()
{
Reader = new StreamPipeReader(MemoryStream, 16, new TestMemoryPool());
Write(new byte[128]);
var result = await Reader.ReadAsync();
Assert.Equal(16, result.Buffer.Length);
Reader.AdvanceTo(result.Buffer.Start, result.Buffer.End);
var result2 = await Reader.ReadAsync();
Assert.Equal(32, result2.Buffer.Length);
Reader.AdvanceTo(result.Buffer.End, result2.Buffer.End);
var result3 = await Reader.ReadAsync();
Assert.Equal(32, result3.Buffer.Length);
}
public async Task ReadBetweenBlocks()
{
var blockSize = 16;
Reader = new StreamPipeReader(MemoryStream, blockSize, new TestMemoryPool());
WriteWithoutPosition(Enumerable.Repeat((byte)'a', blockSize - 5).ToArray());
Write(Encoding.ASCII.GetBytes("Hello World"));
// ReadAsync will only return one chunk at a time, so Advance/ReadAsync to get two chunks
var result = await Reader.ReadAsync();
Reader.AdvanceTo(result.Buffer.Start, result.Buffer.End);
result = await Reader.ReadAsync();
var buffer = result.Buffer;
Assert.False(buffer.IsSingleSegment);
var helloBuffer = buffer.Slice(blockSize - 5);
Assert.False(helloBuffer.IsSingleSegment);
var memory = new List <ReadOnlyMemory <byte> >();
foreach (var m in helloBuffer)
{
memory.Add(m);
}
var spans = memory;
Reader.AdvanceTo(buffer.Start, buffer.Start);
Assert.Equal(2, memory.Count);
var helloBytes = new byte[spans[0].Length];
spans[0].Span.CopyTo(helloBytes);
var worldBytes = new byte[spans[1].Length];
spans[1].Span.CopyTo(worldBytes);
Assert.Equal("Hello", Encoding.ASCII.GetString(helloBytes));
Assert.Equal(" World", Encoding.ASCII.GetString(worldBytes));
}
public async Task ReadMultipleTimesAdvanceFreesAppropriately()
{
var blockSize = 16;
var pool = new TestMemoryPool();
Reader = new StreamPipeReader(MemoryStream, blockSize, pool);
Write(Encoding.ASCII.GetBytes(new string('a', 10000)));
for (var i = 0; i < 99; i++)
{
var readResult = await Reader.ReadAsync();
Reader.AdvanceTo(readResult.Buffer.Start, readResult.Buffer.End);
}
var result = await Reader.ReadAsync();
Reader.AdvanceTo(result.Buffer.End);
Assert.Equal(1, pool.GetRentCount());
}
public async Task CheckBasicReadPipeApi()
{
var pipe = new Pipe();
var readStream = new ReadOnlyPipeStream(pipe.Reader);
var pipeReader = new StreamPipeReader(readStream);
await pipe.Writer.WriteAsync(new byte[10]);
var res = await pipeReader.ReadAsync();
Assert.Equal(new byte[10], res.Buffer.ToArray());
}
public async Task CheckNestedPipeApi()
{
var pipe = new Pipe();
var reader = pipe.Reader;
for (var i = 0; i < 3; i++)
{
var readStream = new ReadOnlyPipeStream(reader);
reader = new StreamPipeReader(readStream);
}
await pipe.Writer.WriteAsync(new byte[10]);
var res = await reader.ReadAsync();
Assert.Equal(new byte[10], res.Buffer.ToArray());
}
public async Task ReadCanBeCanceledViaCancelPendingReadWhenReadIsAsync()
{
var pipeReader = new StreamPipeReader(new HangingStream());
var result = new ReadResult();
var tcs = new TaskCompletionSource <int>(TaskCreationOptions.RunContinuationsAsynchronously);
var task = Task.Run(async() =>
{
var readingTask = pipeReader.ReadAsync();
tcs.SetResult(0);
result = await readingTask;
});
await tcs.Task;
pipeReader.CancelPendingRead();
await task;
Assert.True(result.IsCanceled);
}
public async Task ArrayPoolUsedByDefault()
{
WriteByteArray(20);
var reader = new StreamPipeReader(Stream);
var result = await reader.ReadAsync();
SequenceMarshal.TryGetReadOnlySequenceSegment(
result.Buffer,
out var startSegment,
out var startIndex,
out var endSegment,
out var endIndex);
var start = (BufferSegment)startSegment;
var end = (BufferSegment)endSegment;
Assert.Same(start, end);
Assert.IsType <byte[]>(start.MemoryOwner);
reader.AdvanceTo(result.Buffer.End);
reader.Complete();
}