/// <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);
}
