public void Rewind_ByOne() { ReadOnlySequence <byte> bytes = BufferFactory.Create(new byte[][] { new byte[] { 0 }, new byte[] { 1, 2 }, new byte[] { 3, 4 }, new byte[] { 5, 6, 7, 8 } }); BufferReader <byte> reader = new BufferReader <byte>(bytes); reader.Advance(1); BufferReader <byte> copy = reader; for (int i = 1; i < bytes.Length; i++) { reader.Advance(i); for (int j = 0; j < i; j++) { reader.Rewind(1); Assert.False(reader.End); } Assert.Equal(copy.Position, reader.Position); Assert.Equal(copy.Consumed, reader.Consumed); Assert.Equal(copy.CurrentSpanIndex, reader.CurrentSpanIndex); Assert.Equal(copy.End, reader.End); Assert.True(copy.CurrentSpan.SequenceEqual(reader.CurrentSpan)); } }
public void AdvanceSingleBufferSkipsBytes() { var reader = new BufferReader(Factory.CreateWithContent(new byte[] { 1, 2, 3, 4, 5 })); reader.Advance(2); Assert.Equal(2, reader.CurrentSegmentIndex); Assert.Equal(3, reader.CurrentSegment[reader.CurrentSegmentIndex]); Assert.Equal(3, reader.Peek()); reader.Advance(2); Assert.Equal(5, reader.Peek()); Assert.Equal(4, reader.CurrentSegmentIndex); Assert.Equal(5, reader.CurrentSegment[reader.CurrentSegmentIndex]); }
public void AdvanceSingleBufferSkipsBytes() { var reader = new BufferReader(BufferUtilities.CreateBuffer(new byte[] { 1, 2, 3, 4, 5 })); reader.Advance(2); Assert.Equal(2, reader.CurrentSpanIndex); Assert.Equal(3, reader.CurrentSpan[reader.CurrentSpanIndex]); Assert.Equal(3, reader.Peek()); reader.Advance(2); Assert.Equal(5, reader.Peek()); Assert.Equal(4, reader.CurrentSpanIndex); Assert.Equal(5, reader.CurrentSpan[reader.CurrentSpanIndex]); }
public void AdvanceSingleBufferSkipsBytes() { var reader = new BufferReader<T>(BufferUtilities.CreateBuffer(GetInputData(5))); reader.Advance(2); Assert.Equal(2, reader.CurrentSpanIndex); Assert.Equal(InputData[2], reader.CurrentSpan[reader.CurrentSpanIndex]); Assert.True(reader.TryPeek(out T value)); Assert.Equal(InputData[2], value); reader.Advance(2); Assert.True(reader.TryPeek(out value)); Assert.Equal(InputData[4], value); Assert.Equal(4, reader.CurrentSpanIndex); Assert.Equal(InputData[4], reader.CurrentSpan[reader.CurrentSpanIndex]); }
public void AdvanceToEndThenPeekReturnsMinusOne() { var reader = new BufferReader(Factory.CreateWithContent(new byte[] { 1, 2, 3, 4, 5 })); reader.Advance(5); Assert.True(reader.End); Assert.Equal(-1, reader.Peek()); }
public void ParseInt32BufferReaderRaw() { BufferReader <byte> reader = new BufferReader <byte>(s_ros); while (Utf8Parser.TryParse(reader.CurrentSpan.Slice((int)reader.Consumed), out int value, out int consumed)) { reader.Advance(consumed + 1); } }
public void AdvanceTraversesSegments() { var buffer = Factory.CreateWithContent(new byte[] { 1, 2, 3 }); var reader = new BufferReader(buffer); reader.Advance(2); Assert.Equal(3, reader.CurrentSegment[reader.CurrentSegmentIndex]); Assert.Equal(3, reader.Read()); }
public void EmptySegmentsAreSkippedOnMoveNext() { var buffer = Factory.CreateWithContent(new byte[] { 1, 2 }); var reader = new BufferReader(buffer); Assert.Equal(1, reader.Peek()); reader.Advance(1); Assert.Equal(2, reader.Peek()); }
public void ParseInt32BufferReader() { BufferReader <byte> reader = new BufferReader <byte>(s_ros); while (reader.TryParse(out int value)) { reader.Advance(1); // advance past the delimiter } }
public void TryParseRos() { var reader = new BufferReader <byte>(s_ros); while (reader.TryParse(out int value)) { reader.Advance(1); // advance past the delimiter Assert.Equal(1234, value); } }
public void TryReadTo_NotFound_Sequence(bool advancePastDelimiter) { ReadOnlySequence <byte> bytes = BufferFactory.Create(new byte[][] { new byte[] { 1 }, new byte[] { 2, 3, 255 } }); BufferReader <byte> reader = new BufferReader <byte>(bytes); reader.Advance(4); Assert.False(reader.TryReadTo(out ReadOnlySequence <byte> span, 255, 0, advancePastDelimiter)); }
public void AdvancingPastLengthThrows() { var reader = new BufferReader(Factory.CreateWithContent(new byte[] { 1, 2, 3, 4, 5 })); try { reader.Advance(6); Assert.True(false); } catch (Exception ex) { Assert.True(ex is ArgumentOutOfRangeException); } }
static bool TryReadAddress(ref BufferReader <byte> reader, out IPAddress address) { Span <byte> addressBuffer = stackalloc byte[ADDRESS_SIZE]; if (reader.TryCopyTo(addressBuffer)) { reader.Advance(ADDRESS_SIZE); address = new IPAddress(addressBuffer); return(true); } address = null !; return(false); }
public void AdvanceThrowsPastLengthMultipleSegments() { var buffer = Factory.CreateWithContent(new byte[] { 1, 2, 3 }); var reader = new BufferReader(buffer); try { reader.Advance(4); Assert.True(false); } catch (Exception ex) { Assert.True(ex is ArgumentOutOfRangeException); } }
static bool TryReadCommandString(ref BufferReader <byte> reader, out string command) { Span <byte> commandBytes = stackalloc byte[CommandSize]; if (reader.TryCopyTo(commandBytes)) { reader.Advance(CommandSize); var index = commandBytes.IndexOf((byte)0); command = index == -1 ? Encoding.ASCII.GetString(commandBytes) : Encoding.ASCII.GetString(commandBytes.Slice(0, index)); return(true); } command = null !; return(false); }
public void ReaderIndexIsCorrect() { var buffer = Factory.CreateWithContent(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); var reader = new BufferReader(buffer); var counter = 1; while (!reader.End) { var span = reader.CurrentSegment; for (int i = reader.CurrentSegmentIndex; i < span.Length; i++) { Assert.Equal(counter++, reader.CurrentSegment[i]); } reader.Advance(span.Length); } Assert.Equal(buffer.Length, reader.ConsumedBytes); }
// StorageKey.Key uses an atypical storage pattern relative to other models in Neo. // The byte array is written in blocks of BLOCK_SIZE (aka 16) bytes followed by a byte // indicating how many bytes of the previous block were padding. Only the last block is // allowed to have padding. Read blocks of BLOCK_SIZE + 1 until padding indication byte // is greater than zero. public static bool TryRead(ref BufferReader <byte> reader, out StorageKey value) { const int READ_BLOCK_SIZE = BLOCK_SIZE + 1; if (UInt160.TryRead(ref reader, out var scriptHash)) { using var bufferOwner = MemoryPool <byte> .Shared.Rent(READ_BLOCK_SIZE); var buffer = bufferOwner.Memory.Slice(0, READ_BLOCK_SIZE).Span; var writer = new ArrayBufferWriter <byte>(); while (true) { if (!reader.TryCopyTo(buffer)) { value = default; return(false); } reader.Advance(READ_BLOCK_SIZE); var dataSize = BLOCK_SIZE - buffer[BLOCK_SIZE]; buffer.Slice(0, dataSize).CopyTo(writer.GetSpan(dataSize)); writer.Advance(dataSize); if (dataSize < BLOCK_SIZE) { break; } } // unfortunately, since we don't know a priori how many blocks there will be // or how much padding the last block will have, we have to make another copy // of the key array. However, we can use Unsafe.As to cast the mutable key array // into an ImmutableArray var keyArray = writer.WrittenSpan.ToArray(); value = new StorageKey(scriptHash, Unsafe.As <byte[], ImmutableArray <byte> >(ref keyArray)); return(true); } value = default; return(false); }
public void AdvancePastEmptySegments() { ReadOnlySequence <byte> bytes = BufferFactory.Create(new byte[][] { new byte[] { 0 }, new byte[] { }, new byte[] { }, new byte[] { } }); var reader = new BufferReader <byte>(bytes); reader.Advance(1); Assert.Equal(0, reader.CurrentSpanIndex); Assert.Equal(0, reader.CurrentSpan.Length); Assert.False(reader.TryPeek(out byte value)); ReadOnlySequence <byte> sequence = reader.Sequence.Slice(reader.Position); Assert.Equal(0, sequence.Length); }
public void CopyToSmallerBufferWorks() { var content = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; Span <byte> buffer = new byte[content.Length]; var reader = new BufferReader(Factory.CreateWithContent(content)); // this loop skips more and more items in the reader for (int i = 0; i < content.Length; i++) { // this loop makes the destination buffer smaller and smaller for (int j = 0; j < buffer.Length - i; j++) { Span <byte> bufferSlice = buffer.Slice(0, j); bufferSlice.Clear(); ReadOnlySpan <byte> peeked = reader.Peek(bufferSlice); Assert.Equal(Math.Min(bufferSlice.Length, content.Length - i), peeked.Length); Assert.True(peeked.SequenceEqual(content.AsSpan(i, j))); } reader.Advance(1); } }
private static void BytesReaderBenchmarkBaseline() { int sections = 10; StringBuilder sb = new StringBuilder(); for (int i = 0; i < sections; i++) { sb.Append("1234 "); } var data = Encoding.UTF8.GetBytes(sb.ToString()); var readOnlyBytes = new ReadOnlySequence <byte>(data); var bytesRange = new ReadOnlySequence <byte>(data); var robReader = new BufferReader <byte>(readOnlyBytes); long robSum = 0; while (robReader.TryParse(out int value)) { robSum += value; robReader.Advance(1); } var brReader = new BufferReader <byte>(bytesRange); long brSum = 0; while (brReader.TryParse(out int value)) { brSum += value; brReader.Advance(1); } Assert.Equal(robSum, brSum); Assert.NotEqual(brSum, 0); }
public void CopyToLargerBufferWorks() { var content = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; Span <byte> buffer = new byte[content.Length + 1]; var reader = new BufferReader(Factory.CreateWithContent(content)); // this loop skips more and more items in the reader for (int i = 0; i < content.Length; i++) { int copied = reader.Peek(buffer).Length; Assert.Equal(content.Length - i, copied); Assert.True(buffer.Slice(0, copied).SequenceEqual(content.AsSpan(i))); // make sure that nothing more got written, i.e. tail is empty for (int r = copied; r < buffer.Length; r++) { Assert.Equal(0, buffer[r]); } reader.Advance(1); buffer.Clear(); } }