public void TryReadAfterCompleteThrows()
{
var reader = new MessagePipeReader(PipeReader.Create(Stream.Null), new TestProtocol());
reader.Complete();
Assert.Throws <InvalidOperationException>(() => reader.TryRead(out _));
}
public async Task CompleteReaderWithoutAdvanceDoesNotThrow()
{
var reader = new MessagePipeReader(PipeReader.Create(Stream.Null), new TestProtocol());
await reader.ReadAsync();
reader.Complete();
}
public async Task ThrowsOnReadAfterCompleteReader()
{
var reader = new MessagePipeReader(PipeReader.Create(Stream.Null), new TestProtocol());
reader.Complete();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await reader.ReadAsync());
}
public async Task BufferingDataPastEndOfStreamCanBeReadAgain()
{
var protocol = new TestProtocol();
var stream = new ThrowAfterZeroByteReadStream();
var writer = PipeWriter.Create(stream);
var reader = new MessagePipeReader(PipeReader.Create(stream), protocol);
protocol.WriteMessage(Encoding.ASCII.GetBytes("Hello World"), writer);
await writer.FlushAsync().ConfigureAwait(false);
stream.Position = 0;
var readResult = await reader.ReadAsync();
var buffer = readResult.Buffer;
reader.AdvanceTo(buffer.Start, buffer.End);
// Make sure IsCompleted is true
readResult = await reader.ReadAsync();
buffer = readResult.Buffer;
reader.AdvanceTo(buffer.Start, buffer.End);
Assert.True(readResult.IsCompleted);
var value = await ReadFromPipeAsString(reader);
Assert.Equal("Hello World", value);
reader.Complete();
}
private void OnMessageRead(MessagePipeReader sender, Message message)
{
if (EventOccured != null)
{
EventOccured.Invoke(this, new GenericEventArgs <Message>(message));
}
}
public async Task ConsumePartialBufferWorks()
{
var protocol = new TestProtocol();
var pipe = new Pipe();
var reader = new MessagePipeReader(PipeReader.Create(pipe.Reader.AsStream()), protocol);
pipe.Writer.WriteEmpty(protocol, 10);
await pipe.Writer.FlushAsync();
var readResult = await reader.ReadAsync();
Assert.Equal(10, readResult.Buffer.Length);
reader.AdvanceTo(readResult.Buffer.GetPosition(4), readResult.Buffer.End);
pipe.Writer.WriteEmpty(protocol, 2);
await pipe.Writer.FlushAsync();
readResult = await reader.ReadAsync();
// 6 bytes left over plus 2 newly written bytes
Assert.Equal(8, readResult.Buffer.Length);
reader.AdvanceTo(readResult.Buffer.End);
reader.Complete();
pipe.Writer.Complete();
pipe.Reader.Complete();
}
private void OnPipeReaderCreated(PipeManager sender, MessagePipeReader pipeReader)
{
pipeReader.MessageRead += OnMessageRead;
pipeReader.ConnectionClosed += OnConnectionClosed;
pipeReader.Start();
_pipeReaders[pipeReader.PipeName] = pipeReader;
}
public async Task CanReadMultipleTimes()
{
// This needs to run inline to synchronize the reader and writer
TaskCompletionSource <object> waitForRead = null;
var protocol = new TestProtocol();
async Task DoAsyncRead(PipeReader reader, int[] bufferSizes)
{
var index = 0;
while (true)
{
var readResult = await reader.ReadAsync().ConfigureAwait(false);
if (readResult.IsCompleted)
{
break;
}
Assert.Equal(bufferSizes[index], readResult.Buffer.Length);
reader.AdvanceTo(readResult.Buffer.End);
index++;
waitForRead?.TrySetResult(null);
}
reader.Complete();
}
async Task DoAsyncWrites(PipeWriter writer, int[] bufferSizes)
{
for (var i = 0; i < bufferSizes.Length; i++)
{
writer.WriteEmpty(protocol, bufferSizes[i]);
waitForRead = new TaskCompletionSource <object>();
await writer.FlushAsync().ConfigureAwait(false);
await waitForRead.Task;
}
writer.Complete();
}
// We're using the pipe here as a way to pump bytes into the reader asynchronously
var pipe = new Pipe();
var options = new StreamPipeReaderOptions(bufferSize: 4096);
var reader = new MessagePipeReader(PipeReader.Create(pipe.Reader.AsStream(), options), protocol);
var writes = new[] { 4096, 1024, 123, 4096, 100 };
var readingTask = DoAsyncRead(reader, writes);
var writingTask = DoAsyncWrites(pipe.Writer, writes);
await readingTask;
await writingTask;
pipe.Reader.Complete();
}
public void OnWriterCompletedNoops()
{
var fired = false;
var reader = new MessagePipeReader(PipeReader.Create(Stream.Null), new TestProtocol());
#pragma warning disable CS0618 // Type or member is obsolete
reader.OnWriterCompleted((_, __) => { fired = true; }, null);
#pragma warning restore CS0618 // Type or member is obsolete
reader.Complete();
Assert.False(fired);
}
public void TryReadAfterCancelPendingReadReturnsTrue()
{
var reader = new MessagePipeReader(PipeReader.Create(Stream.Null), new TestProtocol());
reader.CancelPendingRead();
Assert.True(reader.TryRead(out var result));
Assert.True(result.IsCanceled);
reader.AdvanceTo(result.Buffer.End);
reader.Complete();
}
public async Task ReadCanBeCanceledViaCancelPendingReadWhenReadIsAsync()
{
var stream = new CancelledReadsStream();
PipeReader reader = new MessagePipeReader(PipeReader.Create(stream), new TestProtocol());
var task = reader.ReadAsync();
reader.CancelPendingRead();
stream.WaitForReadTask.TrySetResult(null);
var readResult = await task;
Assert.True(readResult.IsCanceled);
reader.Complete();
}
public async ValueTask MessagePipeReaderConsumeNoneEachTime()
{
var reader = new MessagePipeReader(pipe.Reader, testProtocol);
var writer = pipe.Writer;
for (var i = 0; i < NumIterations; i++)
{
testProtocol.WriteMessage(data, writer);
await writer.FlushAsync().ConfigureAwait(false);
var result = await reader.ReadAsync();
reader.AdvanceTo(result.Buffer.Start);
}
reader.Complete();
}
public async Task ReadAsyncAfterReceivingCompletedReadResultDoesNotThrow()
{
var stream = new ThrowAfterZeroByteReadStream();
var reader = new MessagePipeReader(PipeReader.Create(stream), new TestProtocol());
var readResult = await reader.ReadAsync();
Assert.True(readResult.Buffer.IsEmpty);
Assert.True(readResult.IsCompleted);
reader.AdvanceTo(readResult.Buffer.End);
readResult = await reader.ReadAsync();
Assert.True(readResult.Buffer.IsEmpty);
Assert.True(readResult.IsCompleted);
reader.AdvanceTo(readResult.Buffer.End);
reader.Complete();
}
public async Task ReadCanBeCancelledViaProvidedCancellationToken()
{
var stream = new CancelledReadsStream();
PipeReader reader = new MessagePipeReader(PipeReader.Create(stream), new TestProtocol());
var cts = new CancellationTokenSource();
var task = reader.ReadAsync(cts.Token);
Assert.False(task.IsCompleted);
cts.Cancel();
stream.WaitForReadTask.TrySetResult(null);
await Assert.ThrowsAsync <OperationCanceledException>(async() => await task);
reader.Complete();
}
public async Task InvalidCursorThrows()
{
var protocol = new TestProtocol();
var pipe = new Pipe();
pipe.Writer.WriteEmpty(protocol, 10);
await pipe.Writer.FlushAsync();
var readResult = await pipe.Reader.ReadAsync();
var buffer = readResult.Buffer;
var reader = new MessagePipeReader(PipeReader.Create(Stream.Null), new TestProtocol());
Assert.Throws <ArgumentOutOfRangeException>(() => reader.AdvanceTo(buffer.Start, buffer.End));
pipe.Reader.Complete();
pipe.Writer.Complete();
reader.Complete();
}
private static MessagePipeReader CreateReader(out Func <byte[], Task> writeFunc)
{
var protocol = new TestProtocol();
var stream = new MemoryStream();
var writer = PipeWriter.Create(stream);
var reader = new MessagePipeReader(PipeReader.Create(stream), protocol);
long written = 0;
writeFunc = async bytes =>
{
var position = stream.Position;
stream.Position = written;
protocol.WriteMessage(bytes, writer);
await writer.FlushAsync().ConfigureAwait(false);
written = stream.Position;
stream.Position = position;
};
return(reader);
}
public async Task CanUseMultipleMessageReadersOnSameUnderlyingReader()
{
var protocol = new TestProtocol();
var pipe = new Pipe();
var underlyingReader = PipeReader.Create(pipe.Reader.AsStream());
var reader = new MessagePipeReader(underlyingReader, protocol);
protocol.WriteMessage(Encoding.ASCII.GetBytes("Hello"), pipe.Writer);
protocol.WriteMessage(Encoding.ASCII.GetBytes("World"), pipe.Writer);
await pipe.Writer.FlushAsync();
var readResult = await reader.ReadAsync();
Assert.Equal("Hello", Encoding.ASCII.GetString(readResult.Buffer.ToArray()));
reader.Complete();
reader = new MessagePipeReader(underlyingReader, protocol);
readResult = await reader.ReadAsync();
Assert.Equal("World", Encoding.ASCII.GetString(readResult.Buffer.ToArray()));
reader.Complete();
}
public async Task DoesNotReturnCompletedIfUnderlyingReaderIsCompletedIfThereAreMoreMessagesToParse()
{
var protocol = new TestProtocol();
var bufferWriter = new ArrayBufferWriter <byte>();
protocol.WriteMessage(new byte[100], bufferWriter);
protocol.WriteMessage(new byte[100], bufferWriter);
var reader = new MessagePipeReader(
new CompletingPipeReader(new ReadOnlySequence <byte>(bufferWriter.WrittenMemory)),
protocol);
var readResult = await reader.ReadAsync();
var buffer = readResult.Buffer;
Assert.Equal(100, buffer.Length);
Assert.False(readResult.IsCompleted);
reader.AdvanceTo(buffer.Start);
readResult = await reader.ReadAsync();
buffer = readResult.Buffer;
Assert.Equal(200, buffer.Length);
Assert.False(readResult.IsCompleted);
reader.AdvanceTo(buffer.Start);
readResult = await reader.ReadAsync();
buffer = readResult.Buffer;
Assert.Equal(200, buffer.Length);
Assert.True(readResult.IsCompleted);
reader.Complete();
}
