public void WriteContext_WritesWithFlushes() { TestAllTypes message = SampleMessages.CreateFullTestAllTypes(); MemoryStream expectedOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(expectedOutput); output.WriteMessage(message); output.Flush(); byte[] expectedBytes1 = expectedOutput.ToArray(); output.WriteMessage(message); output.Flush(); byte[] expectedBytes2 = expectedOutput.ToArray(); var bufferWriter = new TestArrayBufferWriter <byte>(); WriteContext.Initialize(bufferWriter, out WriteContext ctx); ctx.WriteMessage(message); ctx.Flush(); Assert.AreEqual(expectedBytes1, bufferWriter.WrittenSpan.ToArray()); ctx.WriteMessage(message); ctx.Flush(); Assert.AreEqual(expectedBytes2, bufferWriter.WrittenSpan.ToArray()); }
/// <summary> /// Parses the given bytes using WriteRawLittleEndian64() and checks /// that the result matches the given value. /// </summary> private static void AssertWriteLittleEndian64(byte[] data, ulong value) { { var rawOutput = new MemoryStream(); var output = new CodedOutputStream(rawOutput); output.WriteRawLittleEndian64(value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); var bufferWriter = new TestArrayBufferWriter <byte>(); WriteContext.Initialize(bufferWriter, out WriteContext ctx); ctx.WriteFixed64(value); ctx.Flush(); Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray()); } // Try different block sizes. for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { var rawOutput = new MemoryStream(); var output = new CodedOutputStream(rawOutput, blockSize); output.WriteRawLittleEndian64(value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); var bufferWriter = new TestArrayBufferWriter <byte> { MaxGrowBy = blockSize }; WriteContext.Initialize(bufferWriter, out WriteContext ctx); ctx.WriteFixed64(value); ctx.Flush(); Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray()); } }
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); }
public void WriteWholeMessage_VaryingBlockSizes() { TestAllTypes message = SampleMessages.CreateFullTestAllTypes(); byte[] rawBytes = message.ToByteArray(); // Try different block sizes. for (int blockSize = 1; blockSize < 256; blockSize *= 2) { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput, blockSize); message.WriteTo(output); output.Flush(); Assert.AreEqual(rawBytes, rawOutput.ToArray()); var bufferWriter = new TestArrayBufferWriter <byte>(); bufferWriter.MaxGrowBy = blockSize; message.WriteTo(bufferWriter); Assert.AreEqual(rawBytes, bufferWriter.WrittenSpan.ToArray()); } }
public static void AssertWritingMessage(IMessage message) { // serialize using CodedOutputStream var bytes = message.ToByteArray(); int messageSize = message.CalculateSize(); Assert.AreEqual(message.CalculateSize(), bytes.Length); // serialize using IBufferWriter and check it leads to the same output var bufferWriter = new TestArrayBufferWriter <byte>(); message.WriteTo(bufferWriter); Assert.AreEqual(bytes, bufferWriter.WrittenSpan.ToArray()); // serialize into a single span and check it leads to the same output var singleSpan = new Span <byte>(new byte[messageSize]); message.WriteTo(singleSpan); Assert.AreEqual(bytes, singleSpan.ToArray()); // test for different IBufferWriter.GetSpan() segment sizes for (int blockSize = 1; blockSize < 256; blockSize *= 2) { var segmentedBufferWriter = new TestArrayBufferWriter <byte> { MaxGrowBy = blockSize }; message.WriteTo(segmentedBufferWriter); Assert.AreEqual(bytes, segmentedBufferWriter.WrittenSpan.ToArray()); } // if the full message is small enough, try serializing directly into stack-allocated buffer if (bytes.Length <= 256) { Span <byte> stackAllocBuffer = stackalloc byte[bytes.Length]; message.WriteTo(stackAllocBuffer); Assert.AreEqual(bytes, stackAllocBuffer.ToArray()); } }
/// <summary> /// Writes the given value using WriteRawVarint32() and WriteRawVarint64() and /// checks that the result matches the given bytes /// </summary> private static void AssertWriteVarint(byte[] data, ulong value) { // Only do 32-bit write if the value fits in 32 bits. if ((value >> 32) == 0) { // CodedOutputStream MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput); output.WriteRawVarint32((uint)value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); // IBufferWriter var bufferWriter = new TestArrayBufferWriter <byte>(); WriteContext.Initialize(bufferWriter, out WriteContext ctx); ctx.WriteUInt32((uint)value); ctx.Flush(); Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray()); // Also try computing size. Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint)value)); } { // CodedOutputStream MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput); output.WriteRawVarint64(value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); // IBufferWriter var bufferWriter = new TestArrayBufferWriter <byte>(); WriteContext.Initialize(bufferWriter, out WriteContext ctx); ctx.WriteUInt64(value); ctx.Flush(); Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray()); // Also try computing size. Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value)); } // Try different buffer sizes. for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { // Only do 32-bit write if the value fits in 32 bits. if ((value >> 32) == 0) { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput, bufferSize); output.WriteRawVarint32((uint)value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); var bufferWriter = new TestArrayBufferWriter <byte> { MaxGrowBy = bufferSize }; WriteContext.Initialize(bufferWriter, out WriteContext ctx); ctx.WriteUInt32((uint)value); ctx.Flush(); Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray()); } { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput, bufferSize); output.WriteRawVarint64(value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); var bufferWriter = new TestArrayBufferWriter <byte> { MaxGrowBy = bufferSize }; WriteContext.Initialize(bufferWriter, out WriteContext ctx); ctx.WriteUInt64(value); ctx.Flush(); Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray()); } } }