static ByteString EncodeObject (object value, Type type, MemoryStream buffer, CodedOutputStream stream)
{
buffer.SetLength (0);
if (value != null && !type.IsInstanceOfType (value))
throw new ArgumentException ("Value of type " + value.GetType () + " cannot be encoded to type " + type);
if (value == null && !type.IsSubclassOf (typeof(RemoteObject)) && !IsACollectionType (type))
throw new ArgumentException ("null cannot be encoded to type " + type);
if (value == null)
stream.WriteUInt64 (0);
else if (value is Enum)
stream.WriteInt32 ((int)value);
else {
switch (Type.GetTypeCode (type)) {
case TypeCode.Int32:
stream.WriteInt32 ((int)value);
break;
case TypeCode.Int64:
stream.WriteInt64 ((long)value);
break;
case TypeCode.UInt32:
stream.WriteUInt32 ((uint)value);
break;
case TypeCode.UInt64:
stream.WriteUInt64 ((ulong)value);
break;
case TypeCode.Single:
stream.WriteFloat ((float)value);
break;
case TypeCode.Double:
stream.WriteDouble ((double)value);
break;
case TypeCode.Boolean:
stream.WriteBool ((bool)value);
break;
case TypeCode.String:
stream.WriteString ((string)value);
break;
default:
if (type.Equals (typeof(byte[])))
stream.WriteBytes (ByteString.CopyFrom ((byte[])value));
else if (IsAClassType (type))
stream.WriteUInt64 (((RemoteObject)value).id);
else if (IsAMessageType (type))
((IMessage)value).WriteTo (buffer);
else if (IsAListType (type))
WriteList (value, type, buffer);
else if (IsADictionaryType (type))
WriteDictionary (value, type, buffer);
else if (IsASetType (type))
WriteSet (value, type, buffer);
else if (IsATupleType (type))
WriteTuple (value, type, buffer);
else
throw new ArgumentException (type + " is not a serializable type");
break;
}
}
stream.Flush ();
return ByteString.CopyFrom (buffer.GetBuffer (), 0, (int)buffer.Length);
}
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 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 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 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);
});
}
static ByteString EncodeObject (object value, MemoryStream buffer, CodedOutputStream stream)
{
buffer.SetLength (0);
if (value == null) {
stream.WriteUInt64 (0);
} else if (value is Enum) {
stream.WriteInt32 ((int)value);
} else {
Type type = value.GetType ();
switch (Type.GetTypeCode (type)) {
case TypeCode.Int32:
stream.WriteInt32 ((int)value);
break;
case TypeCode.Int64:
stream.WriteInt64 ((long)value);
break;
case TypeCode.UInt32:
stream.WriteUInt32 ((uint)value);
break;
case TypeCode.UInt64:
stream.WriteUInt64 ((ulong)value);
break;
case TypeCode.Single:
stream.WriteFloat ((float)value);
break;
case TypeCode.Double:
stream.WriteDouble ((double)value);
break;
case TypeCode.Boolean:
stream.WriteBool ((bool)value);
break;
case TypeCode.String:
stream.WriteString ((string)value);
break;
default:
if (type == typeof(byte[]))
stream.WriteBytes (ByteString.CopyFrom ((byte[])value));
else if (TypeUtils.IsAClassType (type))
stream.WriteUInt64 (ObjectStore.Instance.AddInstance (value));
else if (TypeUtils.IsAMessageType (type))
WriteMessage (value, stream);
else if (TypeUtils.IsAListCollectionType (type))
WriteList (value, stream);
else if (TypeUtils.IsADictionaryCollectionType (type))
WriteDictionary (value, stream);
else if (TypeUtils.IsASetCollectionType (type))
WriteSet (value, stream);
else if (TypeUtils.IsATupleCollectionType (type))
WriteTuple (value, stream);
else
throw new ArgumentException (type + " is not a serializable type");
break;
}
}
stream.Flush ();
return ByteString.CopyFrom (buffer.GetBuffer (), 0, (int)buffer.Length);
}
public void WriteTo(CodedOutputStream output)
{
if (this.Start != 0)
{
goto IL_4C;
}
goto IL_BE;
uint arg_87_0;
while (true)
{
IL_82:
uint num;
switch ((num = (arg_87_0 ^ 2558673973u)) % 7u)
{
case 0u:
output.WriteInt32(this.End);
arg_87_0 = (num * 1078497601u ^ 1175681491u);
continue;
case 1u:
output.WriteRawTag(8);
arg_87_0 = (num * 4244478541u ^ 2774833388u);
continue;
case 2u:
goto IL_4C;
case 3u:
output.WriteInt32(this.Start);
arg_87_0 = (num * 4044301929u ^ 1626924624u);
continue;
case 4u:
goto IL_BE;
case 5u:
output.WriteRawTag(16);
arg_87_0 = (num * 3296568415u ^ 3865425179u);
continue;
}
break;
}
return;
IL_4C:
arg_87_0 = 3640988978u;
goto IL_82;
IL_BE:
arg_87_0 = ((this.End == 0) ? 4091317099u : 2946072095u);
goto IL_82;
}
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 SetUp ()
{
// Create a request object and get the binary representation of it
expectedRequest = new Request ("TestService", "ProcedureNoArgsNoReturn");
using (var stream = new MemoryStream ()) {
var codedStream = new CodedOutputStream (stream, true);
codedStream.WriteInt32 (expectedRequest.ToProtobufMessage ().CalculateSize ());
expectedRequest.ToProtobufMessage ().WriteTo (codedStream);
codedStream.Flush ();
requestBytes = stream.ToArray ();
}
// Create a response object and get the binary representation of it
expectedResponse = new Response ();
expectedResponse.Error = "SomeErrorMessage";
expectedResponse.Time = 42;
using (var stream = new MemoryStream ()) {
var codedStream = new CodedOutputStream (stream, true);
codedStream.WriteInt32 (expectedResponse.ToProtobufMessage ().CalculateSize ());
expectedResponse.ToProtobufMessage ().WriteTo (codedStream);
codedStream.Flush ();
responseBytes = stream.ToArray ();
}
}
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 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 TestCodedInputOutputPosition()
{
byte[] content = new byte[110];
for (int i = 0; i < content.Length; i++)
{
content[i] = (byte)i;
}
byte[] child = new byte[120];
{
MemoryStream ms = new MemoryStream(child);
CodedOutputStream cout = new CodedOutputStream(ms, 20);
// Field 11: numeric value: 500
cout.WriteTag(11, WireFormat.WireType.Varint);
Assert.AreEqual(1, cout.Position);
cout.WriteInt32(500);
Assert.AreEqual(3, cout.Position);
//Field 12: length delimited 120 bytes
cout.WriteTag(12, WireFormat.WireType.LengthDelimited);
Assert.AreEqual(4, cout.Position);
cout.WriteBytes(ByteString.CopyFrom(content));
Assert.AreEqual(115, cout.Position);
// Field 13: fixed numeric value: 501
cout.WriteTag(13, WireFormat.WireType.Fixed32);
Assert.AreEqual(116, cout.Position);
cout.WriteSFixed32(501);
Assert.AreEqual(120, cout.Position);
cout.Flush();
}
byte[] bytes = new byte[130];
{
CodedOutputStream cout = new CodedOutputStream(bytes);
// Field 1: numeric value: 500
cout.WriteTag(1, WireFormat.WireType.Varint);
Assert.AreEqual(1, cout.Position);
cout.WriteInt32(500);
Assert.AreEqual(3, cout.Position);
//Field 2: length delimited 120 bytes
cout.WriteTag(2, WireFormat.WireType.LengthDelimited);
Assert.AreEqual(4, cout.Position);
cout.WriteBytes(ByteString.CopyFrom(child));
Assert.AreEqual(125, cout.Position);
// Field 3: fixed numeric value: 500
cout.WriteTag(3, WireFormat.WireType.Fixed32);
Assert.AreEqual(126, cout.Position);
cout.WriteSFixed32(501);
Assert.AreEqual(130, cout.Position);
cout.Flush();
}
// Now test Input stream:
{
CodedInputStream cin = new CodedInputStream(new MemoryStream(bytes), new byte[50], 0, 0);
Assert.AreEqual(0, cin.Position);
// Field 1:
uint tag = cin.ReadTag();
Assert.AreEqual(1, tag >> 3);
Assert.AreEqual(1, cin.Position);
Assert.AreEqual(500, cin.ReadInt32());
Assert.AreEqual(3, cin.Position);
//Field 2:
tag = cin.ReadTag();
Assert.AreEqual(2, tag >> 3);
Assert.AreEqual(4, cin.Position);
int childlen = cin.ReadLength();
Assert.AreEqual(120, childlen);
Assert.AreEqual(5, cin.Position);
int oldlimit = cin.PushLimit((int)childlen);
Assert.AreEqual(5, cin.Position);
// Now we are reading child message
{
// Field 11: numeric value: 500
tag = cin.ReadTag();
Assert.AreEqual(11, tag >> 3);
Assert.AreEqual(6, cin.Position);
Assert.AreEqual(500, cin.ReadInt32());
Assert.AreEqual(8, cin.Position);
//Field 12: length delimited 120 bytes
tag = cin.ReadTag();
Assert.AreEqual(12, tag >> 3);
Assert.AreEqual(9, cin.Position);
ByteString bstr = cin.ReadBytes();
Assert.AreEqual(110, bstr.Length);
Assert.AreEqual((byte)109, bstr[109]);
Assert.AreEqual(120, cin.Position);
// Field 13: fixed numeric value: 501
tag = cin.ReadTag();
Assert.AreEqual(13, tag >> 3);
// ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit
Assert.AreEqual(121, cin.Position);
Assert.AreEqual(501, cin.ReadSFixed32());
Assert.AreEqual(125, cin.Position);
Assert.IsTrue(cin.IsAtEnd);
}
cin.PopLimit(oldlimit);
Assert.AreEqual(125, cin.Position);
// Field 3: fixed numeric value: 501
tag = cin.ReadTag();
Assert.AreEqual(3, tag >> 3);
Assert.AreEqual(126, cin.Position);
Assert.AreEqual(501, cin.ReadSFixed32());
Assert.AreEqual(130, cin.Position);
Assert.IsTrue(cin.IsAtEnd);
}
}
public void SetUp()
{
// Create a request object and get the binary representation of it
expectedRequest = new Request ();
expectedRequest.Service = "SomeServiceName";
expectedRequest.Procedure = "SomeMethodName";
using (var stream = new MemoryStream ()) {
var codedStream = new CodedOutputStream (stream);
codedStream.WriteInt32 (expectedRequest.CalculateSize ());
expectedRequest.WriteTo (codedStream);
codedStream.Flush ();
requestBytes = stream.ToArray ();
}
// Create a response object and get the binary representation of it
expectedResponse = new Response ();
expectedResponse.Error = "SomeErrorMessage";
expectedResponse.Time = 42;
using (var stream = new MemoryStream ()) {
var codedStream = new CodedOutputStream (stream);
codedStream.WriteInt32 (expectedResponse.CalculateSize ());
expectedResponse.WriteTo (codedStream);
codedStream.Flush ();
responseBytes = stream.ToArray ();
}
}
private byte[] IntToByteBuffer(int i)
{
int t = CodedOutputStream.ComputeTagSize(5);
int s = CodedOutputStream.ComputeInt32Size(i);
s += t;
byte[] bytes = new byte[s];
CodedOutputStream cos = new CodedOutputStream(bytes);
cos.WriteTag((5 << 3) + 0);
cos.WriteInt32(i);
cos.Flush();
return bytes;
}
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]);
}
/// <summary>
/// Encode a value of the given type.
/// Should not be called directly. This interface is used by service client stubs.
/// </summary>
public static ByteString Encode(object value, Type type)
{
var stream = new MemoryStream ();
var encoder = new CodedOutputStream (stream);
if (value != null && !type.IsAssignableFrom (value.GetType ())) //TODO: nulls?
throw new ArgumentException ("Value of type " + value.GetType () + " cannot be encoded to type " + type);
if (type == typeof(Double))
encoder.WriteDouble ((Double)value);
else if (type == typeof(Single))
encoder.WriteFloat ((Single)value);
else if (type == typeof(Int32))
encoder.WriteInt32 ((Int32)value);
else if (type == typeof(Int64))
encoder.WriteInt64 ((Int64)value);
else if (type == typeof(UInt32))
encoder.WriteUInt32 ((UInt32)value);
else if (type == typeof(UInt64))
encoder.WriteUInt64 ((UInt64)value);
else if (type == typeof(Boolean))
encoder.WriteBool ((Boolean)value);
else if (type == typeof(String))
encoder.WriteString ((String)value);
else if (type == typeof(byte[]))
encoder.WriteBytes (ByteString.CopyFrom ((byte[])value));
else if (value != null && value is Enum)
encoder.WriteInt32 ((int)value);
else if (type.IsSubclassOf (typeof(RemoteObject))) {
if (value == null)
encoder.WriteUInt64 (0);
else
encoder.WriteUInt64 (((RemoteObject)value)._ID);
} else if (value != null && value is IMessage) {
((IMessage)value).WriteTo (stream);
return ByteString.CopyFrom (stream.ToArray ());
} else if (value != null && value is IList)
return EncodeList (value, type);
else if (value != null && value is IDictionary)
return EncodeDictionary (value, type);
else if (value != null && value.GetType ().IsGenericType && value.GetType ().GetGenericTypeDefinition () == typeof(HashSet<>))
return EncodeSet (value, type); //TODO: ugly checking for set types
else if (value != null && value.GetType ().IsGenericType &&
(value.GetType ().GetGenericTypeDefinition () == typeof(Tuple<>) ||
value.GetType ().GetGenericTypeDefinition () == typeof(Tuple<,>) ||
value.GetType ().GetGenericTypeDefinition () == typeof(Tuple<,,>) ||
value.GetType ().GetGenericTypeDefinition () == typeof(Tuple<,,,>) ||
value.GetType ().GetGenericTypeDefinition () == typeof(Tuple<,,,,>) ||
value.GetType ().GetGenericTypeDefinition () == typeof(Tuple<,,,,,>)))
return EncodeTuple (value, type); //TODO: ugly checking for tuple types
else
throw new ArgumentException (type + " is not a serializable type");
encoder.Flush ();
return ByteString.CopyFrom (stream.ToArray ());
}
internal void <ForInt32> b__3_1(CodedOutputStream output, int value)
{
output.WriteInt32(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);
}
public void TestCodedInputOutputPosition()
{
byte[] content = new byte[110];
for (int i = 0; i < content.Length; i++)
content[i] = (byte)i;
byte[] child = new byte[120];
{
MemoryStream ms = new MemoryStream(child);
CodedOutputStream cout = new CodedOutputStream(ms, 20);
// Field 11: numeric value: 500
cout.WriteTag(11, WireFormat.WireType.Varint);
Assert.AreEqual(1, cout.Position);
cout.WriteInt32(500);
Assert.AreEqual(3, cout.Position);
//Field 12: length delimited 120 bytes
cout.WriteTag(12, WireFormat.WireType.LengthDelimited);
Assert.AreEqual(4, cout.Position);
cout.WriteBytes(ByteString.CopyFrom(content));
Assert.AreEqual(115, cout.Position);
// Field 13: fixed numeric value: 501
cout.WriteTag(13, WireFormat.WireType.Fixed32);
Assert.AreEqual(116, cout.Position);
cout.WriteSFixed32(501);
Assert.AreEqual(120, cout.Position);
cout.Flush();
}
byte[] bytes = new byte[130];
{
CodedOutputStream cout = new CodedOutputStream(bytes);
// Field 1: numeric value: 500
cout.WriteTag(1, WireFormat.WireType.Varint);
Assert.AreEqual(1, cout.Position);
cout.WriteInt32(500);
Assert.AreEqual(3, cout.Position);
//Field 2: length delimited 120 bytes
cout.WriteTag(2, WireFormat.WireType.LengthDelimited);
Assert.AreEqual(4, cout.Position);
cout.WriteBytes(ByteString.CopyFrom(child));
Assert.AreEqual(125, cout.Position);
// Field 3: fixed numeric value: 500
cout.WriteTag(3, WireFormat.WireType.Fixed32);
Assert.AreEqual(126, cout.Position);
cout.WriteSFixed32(501);
Assert.AreEqual(130, cout.Position);
cout.Flush();
}
// Now test Input stream:
{
CodedInputStream cin = new CodedInputStream(new MemoryStream(bytes), new byte[50], 0, 0);
Assert.AreEqual(0, cin.Position);
// Field 1:
uint tag = cin.ReadTag();
Assert.AreEqual(1, tag >> 3);
Assert.AreEqual(1, cin.Position);
Assert.AreEqual(500, cin.ReadInt32());
Assert.AreEqual(3, cin.Position);
//Field 2:
tag = cin.ReadTag();
Assert.AreEqual(2, tag >> 3);
Assert.AreEqual(4, cin.Position);
int childlen = cin.ReadLength();
Assert.AreEqual(120, childlen);
Assert.AreEqual(5, cin.Position);
int oldlimit = cin.PushLimit((int)childlen);
Assert.AreEqual(5, cin.Position);
// Now we are reading child message
{
// Field 11: numeric value: 500
tag = cin.ReadTag();
Assert.AreEqual(11, tag >> 3);
Assert.AreEqual(6, cin.Position);
Assert.AreEqual(500, cin.ReadInt32());
Assert.AreEqual(8, cin.Position);
//Field 12: length delimited 120 bytes
tag = cin.ReadTag();
Assert.AreEqual(12, tag >> 3);
Assert.AreEqual(9, cin.Position);
ByteString bstr = cin.ReadBytes();
Assert.AreEqual(110, bstr.Length);
Assert.AreEqual((byte) 109, bstr[109]);
Assert.AreEqual(120, cin.Position);
// Field 13: fixed numeric value: 501
tag = cin.ReadTag();
Assert.AreEqual(13, tag >> 3);
// ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit
Assert.AreEqual(121, cin.Position);
Assert.AreEqual(501, cin.ReadSFixed32());
Assert.AreEqual(125, cin.Position);
Assert.IsTrue(cin.IsAtEnd);
}
cin.PopLimit(oldlimit);
Assert.AreEqual(125, cin.Position);
// Field 3: fixed numeric value: 501
tag = cin.ReadTag();
Assert.AreEqual(3, tag >> 3);
Assert.AreEqual(126, cin.Position);
Assert.AreEqual(501, cin.ReadSFixed32());
Assert.AreEqual(130, cin.Position);
Assert.IsTrue(cin.IsAtEnd);
}
}
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]);
}
/// <summary>
/// Convert a Protocol Buffer value type from a C# value to a byte string.
/// </summary>
public static ByteString WriteValue(object value, Type type)
{
var stream = new MemoryStream ();
var encoder = new CodedOutputStream (stream);
if (type == typeof(double))
encoder.WriteDouble ((double)value);
else if (type == typeof(float))
encoder.WriteFloat ((float)value);
else if (type == typeof(int))
encoder.WriteInt32 ((int)value);
else if (type == typeof(long))
encoder.WriteInt64 ((long)value);
else if (type == typeof(uint))
encoder.WriteUInt32 ((uint)value);
else if (type == typeof(ulong))
encoder.WriteUInt64 ((ulong)value);
else if (type == typeof(bool))
encoder.WriteBool ((bool)value);
else if (type == typeof(string))
encoder.WriteString ((string)value);
else if (type == typeof(byte[]))
encoder.WriteBytes (ByteString.CopyFrom ((byte[])value));
else
throw new ArgumentException (type + " is not a Protocol Buffer value type");
encoder.Flush ();
return ByteString.CopyFrom (stream.ToArray ());
}