public void PeekWorkesWithEmptySegments()
{
var buffer = Factory.CreateWithContent(new byte[] { 1 });
var reader = new ReadOnlyBufferReader(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 SkipSingleBufferSkipsBytes()
{
var reader = new ReadOnlyBufferReader(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, bool end)
{
var readableBuffer = Factory.CreateWithContent(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
var reader = new ReadOnlyBufferReader(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 PeekTraversesSegments()
{
var buffer = Factory.CreateWithContent(new byte[] { 1, 2 });
var reader = new ReadOnlyBufferReader(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 ReadOnlyBufferReader(Factory.CreateWithContent(new byte[] { 1, 2, 3, 4, 5 }));
try
{
reader.Skip(6);
Assert.True(false);
}
catch (Exception ex)
{
Assert.True(ex is ArgumentOutOfRangeException);
}
}
public void SkipThrowsPastLengthMultipleSegments()
{
var buffer = Factory.CreateWithContent(new byte[] { 1, 2, 3 });
var reader = new ReadOnlyBufferReader(buffer);
try
{
reader.Skip(4);
Assert.True(false);
}
catch (Exception ex)
{
Assert.True(ex is ArgumentOutOfRangeException);
}
}
static void ParseInt32ReadableBufferReader()
{
foreach (var iteration in Benchmark.Iterations)
{
var buffer = new ReadOnlyBuffer(s_data);
var reader = new ReadOnlyBufferReader(buffer);
using (iteration.StartMeasurement())
{
while (Utf8Parser.TryParse(reader.Span.Slice(reader.ConsumedBytes), out int value, out int consumed))
{
reader.Skip(consumed + 1);
}
}
}
}
public void ReaderIndexIsCorrect()
{
var buffer = Factory.CreateWithContent(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
var reader = new ReadOnlyBufferReader(buffer);
var counter = 1;
while (!reader.End)
{
var span = reader.Span;
for (int i = reader.Index; i < span.Length; i++)
{
Assert.Equal(counter++, reader.Span[i]);
}
reader.Skip(span.Length);
}
Assert.Equal(buffer.Length, reader.ConsumedBytes);
}
private static void FindAllNewLinesReadableBufferReader(ReadOnlyBuffer buffer)
{
var reader = new ReadOnlyBufferReader(buffer);
var end = buffer.End;
while (!reader.End)
{
var span = reader.Span;
// Trim the start if we have an index
if (reader.Index > 0)
{
span = span.Slice(reader.Index);
}
while (span.Length > 0)
{
var length = span.IndexOf((byte)'\n');
var skip = length;
if (length == -1)
{
var current = reader.Cursor;
if (ReadCursorOperations.Seek(current, end, out var found, (byte)'\n') == -1)
{
// We're done
return;
}
length = span.Length;
skip = (int)buffer.Slice(current, found).Length + 1;
}
else
{
length += 1;
skip = length;
}
span = span.Slice(length);
reader.Skip(skip);
}
}
}
public void CursorIsCorrectWithEmptyLastBlock()
{
var last = new BufferSegment();
last.SetMemory(new OwnedArray <byte>(new byte[4]), 0, 4);
var first = new BufferSegment();
first.SetMemory(new OwnedArray <byte>(new byte[] { 1, 2 }), 0, 2);
first.SetNext(last);
var start = new Position(first, first.Start);
var end = new Position(last, last.Start);
var reader = new ReadOnlyBufferReader(new ReadOnlyBuffer(start, end));
reader.Take();
reader.Take();
reader.Take();
Assert.Same(last, reader.Cursor.Segment);
Assert.Equal(0, reader.Cursor.Index);
Assert.True(reader.End);
}
