public void TakeReturnsByteAndMoves()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2 }, 0, 2));
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Take());
}
public void PeekReturnsMinuOneByteInTheEnd()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2 }, 0, 2));
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Peek());
}
public void PeekReturnsMinuOneByteInTheEnd()
{
var reader = new ReadableBufferReader(Factory.CreateWithContent(new byte[] { 1, 2 }));
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Peek());
}
public void PeekGoesToEndIfAllEmptySegments()
{
var buffer = BufferUtilities.CreateBuffer(new[] { new byte[] { }, new byte[] { }, new byte[] { }, new byte[] { } });
var reader = new ReadableBufferReader(buffer);
Assert.Equal(-1, reader.Peek());
Assert.True(reader.End);
}
public void SkipToEndThenPeekReturnsMinusOne()
{
var reader = new ReadableBufferReader(Factory.CreateWithContent(new byte[] { 1, 2, 3, 4, 5 }));
reader.Skip(5);
Assert.True(reader.End);
Assert.Equal(-1, reader.Peek());
}
public void TakeReturnsByteAndMoves()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2 }, 0, 2));
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Take());
}
public void PeekReturnsMinuOneByteInTheEnd()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2 }, 0, 2));
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Peek());
}
public void CursorIsCorrectAtEnd()
{
var reader = new ReadableBufferReader(Factory.CreateWithContent(new byte[] { 1, 2 }));
reader.Take();
reader.Take();
Assert.True(reader.End);
}
public void SkipTraversesSegments()
{
var buffer = BufferUtilities.CreateBuffer(new[] { new byte[] { 1 }, new byte[] { 2 }, new byte[] { 3 } });
var reader = new ReadableBufferReader(buffer);
reader.Skip(2);
Assert.Equal(3, reader.Take());
}
public void SkipSingleBufferSkipsBytes()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2, 3, 4, 5 }, 0, 5));
reader.Skip(2);
Assert.Equal(3, reader.Peek());
reader.Skip(2);
Assert.Equal(5, reader.Peek());
}
public void SkipToEndThenPeekReturnsMinusOne()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2, 3, 4, 5 }, 0, 5));
reader.Skip(5);
Assert.True(reader.End);
Assert.Equal(-1, reader.Peek());
Assert.True(reader.Cursor.IsEnd);
}
public void EmptySegmentsAreSkippedOnMoveNext()
{
var buffer = BufferUtilities.CreateBuffer(new[] { new byte[] { 1 }, new byte[] { }, new byte[] { }, new byte[] { 2 } });
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Peek());
reader.Skip(1);
Assert.Equal(2, reader.Peek());
}
public void WorkesWithEmptyBuffer()
{
var reader = new ReadableBufferReader(Factory.CreateWithContent(new byte[] { }));
Assert.Equal(0, reader.Index);
Assert.Equal(0, reader.Span.Length);
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
public void SkipTraversesSegments()
{
var buffer = Factory.CreateWithContent(new byte[] { 1, 2, 3 });
var reader = new ReadableBufferReader(buffer);
reader.Skip(2);
Assert.Equal(3, reader.Span[reader.Index]);
Assert.Equal(3, reader.Take());
}
public void CursorIsCorrectAtEnd()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2 }, 0, 2));
reader.Take();
reader.Take();
Assert.True(reader.End);
Assert.True(reader.Cursor.IsEnd);
}
public void WorkesWithEmptyBuffer()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 0 }, 0, 0));
Assert.Equal(0, reader.Index);
Assert.Equal(0, reader.Span.Length);
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
public void EmptySegmentsAreSkippedOnMoveNext()
{
var buffer = Factory.CreateWithContent(new byte[] { 1, 2 });
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Peek());
reader.Skip(1);
Assert.Equal(2, reader.Peek());
}
private void ParseChunkedPrefix(ReadableBuffer buffer, out ReadCursor consumed, out ReadCursor examined)
{
consumed = buffer.Start;
examined = buffer.Start;
var reader = new ReadableBufferReader(buffer);
var ch1 = reader.Take();
var ch2 = reader.Take();
if (ch1 == -1 || ch2 == -1)
{
examined = reader.Cursor;
return;
}
var chunkSize = CalculateChunkSize(ch1, 0);
ch1 = ch2;
while (reader.ConsumedBytes < MaxChunkPrefixBytes)
{
if (ch1 == ';')
{
consumed = reader.Cursor;
examined = reader.Cursor;
AddAndCheckConsumedBytes(reader.ConsumedBytes);
_inputLength = chunkSize;
_mode = Mode.Extension;
return;
}
ch2 = reader.Take();
if (ch2 == -1)
{
examined = reader.Cursor;
return;
}
if (ch1 == '\r' && ch2 == '\n')
{
consumed = reader.Cursor;
examined = reader.Cursor;
AddAndCheckConsumedBytes(reader.ConsumedBytes);
_inputLength = chunkSize;
_mode = chunkSize > 0 ? Mode.Data : Mode.Trailer;
return;
}
chunkSize = CalculateChunkSize(ch1, chunkSize);
ch1 = ch2;
}
// At this point, 10 bytes have been consumed which is enough to parse the max value "7FFFFFFF\r\n".
_context.ThrowRequestRejected(RequestRejectionReason.BadChunkSizeData);
}
public void TakeTraversesSegments()
{
var buffer = Factory.CreateWithContent(new byte[] { 1, 2, 3 });
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Take());
Assert.Equal(3, reader.Take());
Assert.Equal(-1, reader.Take());
}
public void PeekWorkesWithEmptySegments()
{
var buffer = BufferUtilities.CreateBuffer(new[] { new byte[] { }, new byte[] { 1 } });
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Peek());
Assert.Equal(1, reader.Take());
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
public void SlicingBufferReturnsCorrectCursor()
{
var buffer = ReadableBuffer.Create(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 0, 10);
var sliced = buffer.Slice(2);
var reader = new ReadableBufferReader(sliced);
Assert.Equal(sliced.Start, reader.Cursor);
Assert.Equal(2, reader.Peek());
}
public void PeekTraversesSegments()
{
var buffer = BufferUtilities.CreateBuffer(new[] { new byte[] { 1 }, new byte[] { 2 } });
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Peek());
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
public void SlicingBufferReturnsCorrectCursor()
{
var buffer = Factory.CreateWithContent(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
var sliced = buffer.Slice(2);
var reader = new ReadableBufferReader(sliced);
Assert.Equal(sliced.ToArray(), buffer.Slice(reader.Cursor).ToArray());
Assert.Equal(2, reader.Peek());
Assert.Equal(0, reader.Index);
}
public void PeekWorkesWithEmptySegments()
{
var buffer = Factory.CreateWithContent(new byte[] { 1 });
var reader = new ReadableBufferReader(buffer);
Assert.Equal(0, reader.Index);
Assert.Equal(1, reader.Span.Length);
Assert.Equal(1, reader.Peek());
Assert.Equal(1, reader.Take());
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
public void TakeReturnsByteAndMoves()
{
var reader = new ReadableBufferReader(Factory.CreateWithContent(new byte[] { 1, 2 }));
Assert.Equal(0, reader.Index);
Assert.Equal(1, reader.Span[reader.Index]);
Assert.Equal(1, reader.Take());
Assert.Equal(1, reader.Index);
Assert.Equal(2, reader.Span[reader.Index]);
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Take());
}
public void SkipSingleBufferSkipsBytes()
{
var reader = new ReadableBufferReader(BufferUtilities.CreateBuffer(new byte[] { 1, 2, 3, 4, 5 }));
reader.Skip(2);
Assert.Equal(2, reader.Index);
Assert.Equal(3, reader.Span[reader.Index]);
Assert.Equal(3, reader.Peek());
reader.Skip(2);
Assert.Equal(5, reader.Peek());
Assert.Equal(4, reader.Index);
Assert.Equal(5, reader.Span[reader.Index]);
}
public void ReturnsCorrectCursor(int takes, int slice)
{
var readableBuffer = ReadableBuffer.Create(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 0, 10);
var reader = new ReadableBufferReader(readableBuffer);
for (int i = 0; i < takes; i++)
{
reader.Take();
}
var expected = slice == int.MaxValue ? readableBuffer.End : readableBuffer.Slice(slice).Start;
Assert.Equal(expected, reader.Cursor);
}
public void PeekTraversesSegments()
{
var buffer = Factory.CreateWithContent(new byte[] { 1, 2 });
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Span[reader.Index]);
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Span[reader.Index]);
Assert.Equal(2, reader.Peek());
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
public void SkippingPastLengthThrows()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2, 3, 4, 5 }, 0, 5));
try
{
reader.Skip(6);
Assert.True(false);
}
catch (Exception ex)
{
Assert.True(ex is ArgumentOutOfRangeException);
}
}
public void ReturnsCorrectCursor(int takes, bool end)
{
var readableBuffer = Factory.CreateWithContent(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
var reader = new ReadableBufferReader(readableBuffer);
for (int i = 0; i < takes; i++)
{
reader.Take();
}
var expected = end ? new byte[] {} : readableBuffer.Slice(takes).ToArray();
Assert.Equal(expected, readableBuffer.Slice(reader.Cursor).ToArray());
}
public void SkipThrowsPastLengthMultipleSegments()
{
var buffer = Factory.CreateWithContent(new byte[] { 1, 2, 3 });
var reader = new ReadableBufferReader(buffer);
try
{
reader.Skip(4);
Assert.True(false);
}
catch (Exception ex)
{
Assert.True(ex is ArgumentOutOfRangeException);
}
}
public void SkipThrowsPastLengthMultipleSegments()
{
var buffer = BufferUtilities.CreateBuffer(new[] { new byte[] { 1 }, new byte[] { 2 }, new byte[] { 3 } });
var reader = new ReadableBufferReader(buffer);
try
{
reader.Skip(4);
Assert.True(false);
}
catch (Exception ex)
{
Assert.True(ex is ArgumentOutOfRangeException);
}
}
public async Task PeekTraversesSegments()
{
using (var factory = new PipelineFactory())
{
var readerWriter = factory.Create();
var w = readerWriter.Alloc();
w.Append(ReadableBuffer.Create(new byte[] { 1 }, 0, 1));
w.Append(ReadableBuffer.Create(new byte[] { 2 }, 0, 1));
await w.FlushAsync();
var result = await readerWriter.ReadAsync();
var buffer = result.Buffer;
var reader = new ReadableBufferReader(buffer);
Assert.Equal(1, reader.Take());
Assert.Equal(2, reader.Peek());
Assert.Equal(2, reader.Take());
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
}
public void PeekReturnsByteWithoutMoving()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 1, 2 }, 0, 2));
Assert.Equal(1, reader.Peek());
Assert.Equal(1, reader.Peek());
}
public void WorkesWithEmptyBuffer()
{
var reader = new ReadableBufferReader(ReadableBuffer.Create(new byte[] { 0 }, 0, 0));
Assert.Equal(-1, reader.Peek());
Assert.Equal(-1, reader.Take());
}
