public void ReadStringGreaterThanCurrentLimit() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(4); output.WriteRawBytes(new byte[4]); // Pad with a few random bytes. output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms.ToArray()); Assert.AreEqual(tag, input.ReadTag()); // Specify limit smaller than data length input.PushLimit(3); Assert.Throws <InvalidProtocolBufferException>(() => input.ReadString()); AssertReadFromParseContext(new ReadOnlySequence <byte>(ms.ToArray()), (ref ParseContext ctx) => { Assert.AreEqual(tag, ctx.ReadTag()); SegmentedBufferHelper.PushLimit(ref ctx.state, 3); try { ctx.ReadString(); Assert.Fail(); } catch (InvalidProtocolBufferException) { } }, true); }
public void ReadMaliciouslyLargeBlob() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(0x7FFFFFFF); output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); Assert.Throws <InvalidProtocolBufferException>(() => input.ReadBytes()); }
/// <summary> /// Writes the length and then data of the given message to a stream. /// </summary> /// <param name="message">The message to write.</param> /// <param name="output">The output stream to write to.</param> public static void WriteDelimitedTo(this IMessage message, Stream output) { ProtoPreconditions.CheckNotNull(message, "message"); ProtoPreconditions.CheckNotNull(output, "output"); CodedOutputStream codedOutput = new CodedOutputStream(output); codedOutput.WriteRawVarint32((uint)message.CalculateSize()); message.WriteTo(codedOutput); codedOutput.Flush(); }
public void ReadInvalidUtf8() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(1); output.WriteRawBytes(new byte[] { 0x80 }); output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); string text = input.ReadString(); Assert.AreEqual('\ufffd', text[0]); }
public void ReadMaliciouslyLargeBlob() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = CodedOutputStream.CreateInstance(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(0x7FFFFFFF); output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. output.Flush(); ms.Position = 0; CodedInputStream input = CodedInputStream.CreateInstance(ms); uint testtag; Assert.IsTrue(input.ReadTag(out testtag)); Assert.AreEqual(tag, testtag); // TODO(jonskeet): Should this be ArgumentNullException instead? Assert.Throws <InvalidProtocolBufferException>(() => input.ReadBytes()); }
/// <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) { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput); output.WriteRawVarint32((uint) value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); // Also try computing size. Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value)); } { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput); output.WriteRawVarint64(value); output.Flush(); Assert.AreEqual(data, rawOutput.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()); } { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput, bufferSize); output.WriteRawVarint64(value); output.Flush(); Assert.AreEqual(data, rawOutput.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) { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput); output.WriteRawVarint32((uint)value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); // Also try computing size. Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint)value)); } { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput); output.WriteRawVarint64(value); output.Flush(); Assert.AreEqual(data, rawOutput.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()); } { MemoryStream rawOutput = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(rawOutput, bufferSize); output.WriteRawVarint64(value); output.Flush(); Assert.AreEqual(data, rawOutput.ToArray()); } } }
public void ReadNegativeSizedBytesThrowsInvalidProtocolBufferException() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteLength(-1); output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); Assert.Throws <InvalidProtocolBufferException>(() => input.ReadBytes()); }
public void MaximumFieldNumber() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); int fieldNumber = 0x1FFFFFFF; uint tag = WireFormat.MakeTag(fieldNumber, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteString("field 1"); output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); Assert.AreEqual(fieldNumber, WireFormat.GetTagFieldNumber(tag)); }
public void TestReadInvalidWireTypeThrowsInvalidProtocolBufferException() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, (WireFormat.WireType) 6); output.WriteRawVarint32(tag); output.WriteLength(-1); output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); Assert.Throws <InvalidProtocolBufferException>(() => UnknownFieldSet.MergeFieldFrom(null, input)); }
public static void WriteDelimitedTo(this IMessage message, Stream output) { Preconditions.CheckNotNull <IMessage>(message, Module.smethod_37 <string>(1018619835u)); while (true) { IL_97: uint arg_77_0 = 836366938u; while (true) { uint num; switch ((num = (arg_77_0 ^ 1222686458u)) % 5u) { case 0u: goto IL_97; case 1u: { Preconditions.CheckNotNull <Stream>(output, Module.smethod_36 <string>(1367025601u)); CodedOutputStream codedOutputStream = new CodedOutputStream(output); arg_77_0 = (num * 2302164566u ^ 2110158721u); continue; } case 2u: { CodedOutputStream codedOutputStream; codedOutputStream.WriteRawVarint32((uint)message.CalculateSize()); arg_77_0 = (num * 762481410u ^ 1229542845u); continue; } case 4u: { CodedOutputStream codedOutputStream; message.WriteTo(codedOutputStream); codedOutputStream.Flush(); arg_77_0 = (num * 187669686u ^ 2466296953u); continue; } } return; } } }
public void MapWithOnlyValue() { // Hand-craft the stream to contain a single entry with just a value. var memoryStream = new MemoryStream(); var output = new CodedOutputStream(memoryStream); output.WriteTag(TestMap.MapInt32ForeignMessageFieldNumber, WireFormat.WireType.LengthDelimited); var nestedMessage = new ForeignMessage { C = 20 }; // Size of the entry (tag, size written by WriteMessage, data written by WriteMessage) output.WriteRawVarint32((uint)(nestedMessage.CalculateSize() + 3)); output.WriteTag(2, WireFormat.WireType.LengthDelimited); output.WriteMessage(nestedMessage); output.Flush(); var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray()); Assert.AreEqual(nestedMessage, parsed.MapInt32ForeignMessage[0]); }
public void MapFieldOrderIsIrrelevant() { var memoryStream = new MemoryStream(); var output = new CodedOutputStream(memoryStream); output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited); var key = 10; var value = 20; // Each field can be represented in a single byte, with a single byte tag. // Total message size: 4 bytes. output.WriteRawVarint32(4); output.WriteTag(2, WireFormat.WireType.Varint); output.WriteInt32(value); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key); output.Flush(); var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray()); Assert.AreEqual(value, parsed.MapInt32Int32[key]); }
public void MapNonContiguousEntries() { var memoryStream = new MemoryStream(); var output = new CodedOutputStream(memoryStream); // Message structure: // Entry for MapInt32Int32 // Entry for MapStringString // Entry for MapInt32Int32 // First entry var key1 = 10; var value1 = 20; output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(4); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key1); output.WriteTag(2, WireFormat.WireType.Varint); output.WriteInt32(value1); // Second entry var key2 = "a"; var value2 = "b"; output.WriteTag(TestMap.MapStringStringFieldNumber, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(6); // 3 bytes per entry: tag, size, character output.WriteTag(1, WireFormat.WireType.LengthDelimited); output.WriteString(key2); output.WriteTag(2, WireFormat.WireType.LengthDelimited); output.WriteString(value2); // Third entry var key3 = 15; var value3 = 25; output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(4); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key3); output.WriteTag(2, WireFormat.WireType.Varint); output.WriteInt32(value3); output.Flush(); var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray()); var expected = new TestMap { MapInt32Int32 = { { key1, value1 }, { key3, value3 } }, MapStringString = { { key2, value2 } } }; Assert.AreEqual(expected, parsed); }
public void DuplicateKeys_LastEntryWins() { var memoryStream = new MemoryStream(); var output = new CodedOutputStream(memoryStream); var key = 10; var value1 = 20; var value2 = 30; // First entry output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(4); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key); output.WriteTag(2, WireFormat.WireType.Varint); output.WriteInt32(value1); // Second entry - same key, different value output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(4); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key); output.WriteTag(2, WireFormat.WireType.Varint); output.WriteInt32(value2); output.Flush(); var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray()); Assert.AreEqual(value2, parsed.MapInt32Int32[key]); }
/// <summary> /// Writes the length and then data of the given message to a stream. /// </summary> /// <param name="message">The message to write.</param> /// <param name="output">The output stream to write to.</param> public static void WriteDelimitedTo(this IMessage message, Stream output) { ProtoPreconditions.CheckNotNull(message, "message"); ProtoPreconditions.CheckNotNull(output, "output"); CodedOutputStream codedOutput = new CodedOutputStream(output); codedOutput.WriteRawVarint32((uint)message.CalculateSize()); message.WriteTo(codedOutput); codedOutput.Flush(); }
/// <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()); } } }
public void ReadMaliciouslyLargeBlob() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(0x7FFFFFFF); output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); Assert.Throws<InvalidProtocolBufferException>(() => input.ReadBytes()); }
public void ReadInvalidUtf8() { MemoryStream ms = new MemoryStream(); CodedOutputStream output = new CodedOutputStream(ms); uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); output.WriteRawVarint32(tag); output.WriteRawVarint32(1); output.WriteRawBytes(new byte[] {0x80}); output.Flush(); ms.Position = 0; CodedInputStream input = new CodedInputStream(ms); Assert.AreEqual(tag, input.ReadTag()); string text = input.ReadString(); Assert.AreEqual('\ufffd', text[0]); }
public void MapIgnoresExtraFieldsWithinEntryMessages() { // Hand-craft the stream to contain a single entry with three fields var memoryStream = new MemoryStream(); var output = new CodedOutputStream(memoryStream); output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited); var key = 10; // Field 1 var value = 20; // Field 2 var extra = 30; // Field 3 // Each field can be represented in a single byte, with a single byte tag. // Total message size: 6 bytes. output.WriteRawVarint32(6); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key); output.WriteTag(2, WireFormat.WireType.Varint); output.WriteInt32(value); output.WriteTag(3, WireFormat.WireType.Varint); output.WriteInt32(extra); output.Flush(); var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray()); Assert.AreEqual(value, parsed.MapInt32Int32[key]); }