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.WriteLength(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.WriteLength(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]); }
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.WriteLength(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.WriteLength(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.WriteLength(4); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key3); output.WriteTag(2, WireFormat.WireType.Varint); output.WriteInt32(value3); output.Flush(); MessageParsingHelpers.AssertReadingMessage( TestMap.Parser, memoryStream.ToArray(), parsed => { var expected = new TestMap { MapInt32Int32 = { { key1, value1 }, { key3, value3 } }, MapStringString = { { key2, value2 } } }; Assert.AreEqual(expected, parsed); }); }
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.WriteLength(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]); }
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.WriteLength(4); output.WriteTag(2, WireFormat.WireType.Varint); output.WriteInt32(value); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key); output.Flush(); MessageParsingHelpers.AssertReadingMessage( TestMap.Parser, memoryStream.ToArray(), parsed => { Assert.AreEqual(value, parsed.MapInt32Int32[key]); }); }
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.WriteLength(2 + nestedMessage.CalculateSize()); output.WriteTag(2, WireFormat.WireType.LengthDelimited); output.WriteMessage(nestedMessage); output.Flush(); MessageParsingHelpers.AssertReadingMessage( TestMap.Parser, memoryStream.ToArray(), parsed => { Assert.AreEqual(nestedMessage, parsed.MapInt32ForeignMessage[0]); }); }
/// <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.WriteLength(message.CalculateSize()); message.WriteTo(codedOutput); codedOutput.Flush(); }
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 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 void MapWithOnlyKey_MessageValue() { // Hand-craft the stream to contain a single entry with just a key. var memoryStream = new MemoryStream(); var output = new CodedOutputStream(memoryStream); output.WriteTag(TestMap.MapInt32ForeignMessageFieldNumber, WireFormat.WireType.LengthDelimited); int key = 10; output.WriteLength(1 + CodedOutputStream.ComputeInt32Size(key)); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key); output.Flush(); var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray()); Assert.AreEqual(new ForeignMessage(), parsed.MapInt32ForeignMessage[key]); }
public void MapWithOnlyKey_PrimitiveValue() { // Hand-craft the stream to contain a single entry with just a key. var memoryStream = new MemoryStream(); var output = new CodedOutputStream(memoryStream); output.WriteTag(TestMap.MapInt32DoubleFieldNumber, WireFormat.WireType.LengthDelimited); int key = 10; output.WriteLength(1 + CodedOutputStream.ComputeInt32Size(key)); output.WriteTag(1, WireFormat.WireType.Varint); output.WriteInt32(key); output.Flush(); MessageParsingHelpers.AssertReadingMessage( TestMap.Parser, memoryStream.ToArray(), parsed => { Assert.AreEqual(0.0, parsed.MapInt32Double[key]); }); }
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.WriteLength(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 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.WriteLength(2 + nestedMessage.CalculateSize()); output.WriteTag(2, WireFormat.WireType.LengthDelimited); output.WriteMessage(nestedMessage); output.Flush(); var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray()); Assert.AreEqual(nestedMessage, parsed.MapInt32ForeignMessage[0]); }
internal static void Write <T>(CodedOutputStream output, T value, FieldCodec <T> codec) { output.WriteLength(codec.CalculateSizeWithTag(value)); codec.WriteTagAndValue(output, value); }
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.WriteLength(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.WriteLength(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.WriteLength(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); }
/// <summary> /// Writes the binary representation to the specified <see cref="CodedOutputStream"/>. /// </summary> /// <param name="stream"> /// The <see cref="CodedOutputStream"/> to write to. /// </param> /// <remarks> /// The binary representation is a 1-byte <see cref="HashingAlgorithm.Code"/>, /// 1-byte <see cref="HashingAlgorithm.DigestSize"/> followed by the <see cref="Digest"/>. /// </remarks> public void Write(CodedOutputStream stream) { if (stream == null) throw new ArgumentNullException("stream"); stream.WriteRawTag(Algorithm.Code); stream.WriteLength(Algorithm.DigestSize); stream.WriteSomeBytes(Digest); }