/// <summary> /// Parses the given bytes using ReadRawLittleEndian64() and checks /// that the result matches the given value. /// </summary> private static void AssertReadLittleEndian64(byte[] data, ulong value) { CodedInputStream input = new CodedInputStream(data); Assert.AreEqual(value, input.ReadRawLittleEndian64()); Assert.IsTrue(input.IsAtEnd); AssertReadFromParseContext(new ReadOnlySequence <byte>(data), (ref ParseContext ctx) => { Assert.AreEqual(value, ctx.ReadFixed64()); }, true); // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { input = new CodedInputStream( new SmallBlockInputStream(data, blockSize)); Assert.AreEqual(value, input.ReadRawLittleEndian64()); Assert.IsTrue(input.IsAtEnd); AssertReadFromParseContext(ReadOnlySequenceFactory.CreateWithContent(data, blockSize), (ref ParseContext ctx) => { Assert.AreEqual(value, ctx.ReadFixed64()); }, true); } }
public static void AssertRoundtrip <T>(MessageParser <T> parser, T message, Action <T> additionalAssert = null) where T : IMessage <T> { var bytes = message.ToByteArray(); // also serialize using IBufferWriter and check it leads to the same data var bufferWriter = new TestArrayBufferWriter <byte>(); message.WriteTo(bufferWriter); Assert.AreEqual(bytes, bufferWriter.WrittenSpan.ToArray(), "Both serialization approaches need to result in the same data."); var parsedMsg = parser.ParseFrom(bytes); Assert.AreEqual(message, parsedMsg); additionalAssert?.Invoke(parsedMsg); // Load content as single segment parsedMsg = parser.ParseFrom(new ReadOnlySequence <byte>(bytes)); Assert.AreEqual(message, parsedMsg); additionalAssert?.Invoke(parsedMsg); // Load content as multiple segments parsedMsg = parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(bytes)); Assert.AreEqual(message, parsedMsg); additionalAssert?.Invoke(parsedMsg); // Load content as ReadOnlySpan parsedMsg = parser.ParseFrom(new ReadOnlySpan <byte>(bytes)); Assert.AreEqual(message, parsedMsg); additionalAssert?.Invoke(parsedMsg); }
/// <summary> /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() /// </summary> private static void AssertReadVarint(byte[] data, ulong value) { CodedInputStream input = new CodedInputStream(data); Assert.AreEqual((uint)value, input.ReadRawVarint32()); Assert.IsTrue(input.IsAtEnd); input = new CodedInputStream(data); Assert.AreEqual(value, input.ReadRawVarint64()); Assert.IsTrue(input.IsAtEnd); AssertReadFromParseContext(new ReadOnlySequence <byte>(data), (ref ParseContext ctx) => { Assert.AreEqual((uint)value, ctx.ReadUInt32()); }, true); AssertReadFromParseContext(new ReadOnlySequence <byte>(data), (ref ParseContext ctx) => { Assert.AreEqual(value, ctx.ReadUInt64()); }, true); // Try different block sizes. for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { input = new CodedInputStream(new SmallBlockInputStream(data, bufferSize)); Assert.AreEqual((uint)value, input.ReadRawVarint32()); input = new CodedInputStream(new SmallBlockInputStream(data, bufferSize)); Assert.AreEqual(value, input.ReadRawVarint64()); Assert.IsTrue(input.IsAtEnd); AssertReadFromParseContext(ReadOnlySequenceFactory.CreateWithContent(data, bufferSize), (ref ParseContext ctx) => { Assert.AreEqual((uint)value, ctx.ReadUInt32()); }, true); AssertReadFromParseContext(ReadOnlySequenceFactory.CreateWithContent(data, bufferSize), (ref ParseContext ctx) => { Assert.AreEqual(value, ctx.ReadUInt64()); }, true); } // Try reading directly from a MemoryStream. We want to verify that it // doesn't read past the end of the input, so write an extra byte - this // lets us test the position at the end. MemoryStream memoryStream = new MemoryStream(); memoryStream.Write(data, 0, data.Length); memoryStream.WriteByte(0); memoryStream.Position = 0; Assert.AreEqual((uint)value, CodedInputStream.ReadRawVarint32(memoryStream)); Assert.AreEqual(data.Length, memoryStream.Position); }
public static void AssertReadingMessage(MessageParser parser, byte[] bytes, Action <IMessage> assert) { var parsedStream = parser.ParseFrom(bytes); // Load content as single segment var parsedBuffer = parser.ParseFrom(new ReadOnlySequence <byte>(bytes)); assert(parsedBuffer); // Load content as multiple segments parsedBuffer = parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(bytes)); assert(parsedBuffer); assert(parsedStream); }
public void ReadInt32Wrapper_VariableBlockSizes() { byte[] rawBytes = new byte[] { 202, 1, 11, 8, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1 }; for (int blockSize = 1; blockSize <= rawBytes.Length; blockSize++) { ReadOnlySequence <byte> data = ReadOnlySequenceFactory.CreateWithContent(rawBytes, blockSize); AssertReadFromParseContext(data, (ref ParseContext ctx) => { ctx.ReadTag(); var value = ParsingPrimitivesWrappers.ReadInt32Wrapper(ref ctx); Assert.AreEqual(-2, value); }, true); } }
public void ReadWholeMessage_VaryingBlockSizes_FromSequence() { TestAllTypes message = SampleMessages.CreateFullTestAllTypes(); byte[] rawBytes = message.ToByteArray(); Assert.AreEqual(rawBytes.Length, message.CalculateSize()); TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(rawBytes); Assert.AreEqual(message, message2); // Try different block sizes. for (int blockSize = 1; blockSize < 256; blockSize *= 2) { message2 = TestAllTypes.Parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(rawBytes, blockSize)); Assert.AreEqual(message, message2); } }
public static void AssertReadingMessage <T>(MessageParser <T> parser, byte[] bytes, Action <T> assert) where T : IMessage <T> { var parsedMsg = parser.ParseFrom(bytes); assert(parsedMsg); // Load content as single segment parsedMsg = parser.ParseFrom(new ReadOnlySequence <byte>(bytes)); assert(parsedMsg); // Load content as multiple segments parsedMsg = parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(bytes)); assert(parsedMsg); // Load content as ReadOnlySpan parsedMsg = parser.ParseFrom(new ReadOnlySpan <byte>(bytes)); assert(parsedMsg); }
public static void AssertRoundtrip <T>(MessageParser <T> parser, T message, Action <T> additionalAssert = null) where T : IMessage <T> { var bytes = message.ToByteArray(); // Load content as single segment var parsedBuffer = parser.ParseFrom(new ReadOnlySequence <byte>(bytes)); Assert.AreEqual(message, parsedBuffer); additionalAssert?.Invoke(parsedBuffer); // Load content as multiple segments parsedBuffer = parser.ParseFrom(ReadOnlySequenceFactory.CreateWithContent(bytes)); Assert.AreEqual(message, parsedBuffer); additionalAssert?.Invoke(parsedBuffer); var parsedStream = parser.ParseFrom(bytes); Assert.AreEqual(message, parsedStream); additionalAssert?.Invoke(parsedStream); }