Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Allow extra fields in wrapper messages, more tests.

Browse Source
pull/6843/head
Chris Bacon 5 years ago
parent e305e56cad
commit 2ac8946ee3
3 changed files with 274 additions and 60 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 81
      csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs
  2. 228
      csharp/src/Google.Protobuf/CodedInputStream.cs
  3. 25
      csharp/src/Google.Protobuf/FieldCodec.cs

81
csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs
Unescape View File

@ -386,7 +386,7 @@ namespace Google.Protobuf.WellKnownTypes
}
[Test]
public void UnknownFieldInWrapper()
public void UnknownFieldInWrapperInt32FastPath()
{
var stream = new MemoryStream();
var output = new CodedOutputStream(stream);
@ -395,19 +395,96 @@ namespace Google.Protobuf.WellKnownTypes
var valueTag = WireFormat.MakeTag(Int32Value.ValueFieldNumber, WireFormat.WireType.Varint);
output.WriteTag(wrapperTag);
output.WriteLength(4); // unknownTag + value 5 + valueType + value 6, each 1 byte
// Wrapper message is just long enough - 6 bytes - to use the wrapper fast-path.
output.WriteLength(6); // unknownTag + value 5 + valueType, each 1 byte, + value 65536, 3 bytes
output.WriteTag(unknownTag);
output.WriteInt32((int) valueTag); // Sneakily "pretend" it's a tag when it's really a value
output.WriteTag(valueTag);
output.WriteInt32(65536);
output.Flush();
Assert.AreEqual(8, stream.Length); // tag (1 byte) + length (1 byte) + message (6 bytes)
stream.Position = 0;
var message = TestWellKnownTypes.Parser.ParseFrom(stream);
Assert.AreEqual(65536, message.Int32Field);
}
[Test]
public void UnknownFieldInWrapperInt32SlowPath()
{
var stream = new MemoryStream();
var output = new CodedOutputStream(stream);
var wrapperTag = WireFormat.MakeTag(TestWellKnownTypes.Int32FieldFieldNumber, WireFormat.WireType.LengthDelimited);
var unknownTag = WireFormat.MakeTag(15, WireFormat.WireType.Varint);
var valueTag = WireFormat.MakeTag(Int32Value.ValueFieldNumber, WireFormat.WireType.Varint);
output.WriteTag(wrapperTag);
// Wrapper message is too short to be used on the wrapper fast-path.
output.WriteLength(4); // unknownTag + value 5 + valueType + value 6, each 1 byte
output.WriteTag(unknownTag);
output.WriteInt32((int)valueTag); // Sneakily "pretend" it's a tag when it's really a value
output.WriteTag(valueTag);
output.WriteInt32(6);
output.Flush();
Assert.Less(stream.Length, 8); // tag (1 byte) + length (1 byte) + message
stream.Position = 0;
var message = TestWellKnownTypes.Parser.ParseFrom(stream);
Assert.AreEqual(6, message.Int32Field);
}
[Test]
public void UnknownFieldInWrapperInt64FastPath()
{
var stream = new MemoryStream();
var output = new CodedOutputStream(stream);
var wrapperTag = WireFormat.MakeTag(TestWellKnownTypes.Int64FieldFieldNumber, WireFormat.WireType.LengthDelimited);
var unknownTag = WireFormat.MakeTag(15, WireFormat.WireType.Varint);
var valueTag = WireFormat.MakeTag(Int64Value.ValueFieldNumber, WireFormat.WireType.Varint);
output.WriteTag(wrapperTag);
// Wrapper message is just long enough - 10 bytes - to use the wrapper fast-path.
output.WriteLength(11); // unknownTag + value 5 + valueType, each 1 byte, + value 0xfffffffffffff, 8 bytes
output.WriteTag(unknownTag);
output.WriteInt64((int)valueTag); // Sneakily "pretend" it's a tag when it's really a value
output.WriteTag(valueTag);
output.WriteInt64(0xfffffffffffffL);
output.Flush();
Assert.AreEqual(13, stream.Length); // tag (1 byte) + length (1 byte) + message (11 bytes)
stream.Position = 0;
var message = TestWellKnownTypes.Parser.ParseFrom(stream);
Assert.AreEqual(0xfffffffffffffL, message.Int64Field);
}
[Test]
public void UnknownFieldInWrapperInt64SlowPath()
{
var stream = new MemoryStream();
var output = new CodedOutputStream(stream);
var wrapperTag = WireFormat.MakeTag(TestWellKnownTypes.Int64FieldFieldNumber, WireFormat.WireType.LengthDelimited);
var unknownTag = WireFormat.MakeTag(15, WireFormat.WireType.Varint);
var valueTag = WireFormat.MakeTag(Int64Value.ValueFieldNumber, WireFormat.WireType.Varint);
output.WriteTag(wrapperTag);
// Wrapper message is too short to be used on the wrapper fast-path.
output.WriteLength(4); // unknownTag + value 5 + valueType + value 6, each 1 byte
output.WriteTag(unknownTag);
output.WriteInt64((int)valueTag); // Sneakily "pretend" it's a tag when it's really a value
output.WriteTag(valueTag);
output.WriteInt64(6);
output.Flush();
Assert.Less(stream.Length, 12); // tag (1 byte) + length (1 byte) + message
stream.Position = 0;
var message = TestWellKnownTypes.Parser.ParseFrom(stream);
Assert.AreEqual(6L, message.Int64Field);
}
[Test]
public void ClearWithReflection()
{

228
csharp/src/Google.Protobuf/CodedInputStream.cs
Unescape View File

@ -737,29 +737,76 @@ namespace Google.Protobuf
return false;
}
internal static float? ReadFloatWrapperLittleEndian(CodedInputStream input)
{
// length:1 + tag:1 + value:4 = 6 bytes
if (input.bufferPos + 6 <= input.bufferSize)
{
// The entire wrapper message is already contained in `buffer`.
int length = input.buffer[input.bufferPos];
if (length == 0)
{
input.bufferPos++;
return 0F;
}
// tag:1 + value:4 = length of 5 bytes
// field=1, type=32-bit = tag of 13
if (length != 5 || input.buffer[input.bufferPos + 1] != 13)
{
return ReadFloatWrapperSlow(input);
}
var result = BitConverter.ToSingle(input.buffer, input.bufferPos + 2);
input.bufferPos += 6;
return result;
}
else
{
return ReadFloatWrapperSlow(input);
}
}
internal static float? ReadFloatWrapperSlow(CodedInputStream input)
{
int length = input.ReadLength();
if (length == 0)
{
return 0F;
}
int finalBufferPos = input.totalBytesRetired + input.bufferPos + length;
float result = 0F;
do
{
// field=1, type=32-bit = tag of 13
if (input.ReadTag() == 13)
{
result = input.ReadFloat();
}
else
{
input.SkipLastField();
}
}
while (input.totalBytesRetired + input.bufferPos < finalBufferPos);
return result;
}
internal static double? ReadDoubleWrapperLittleEndian(CodedInputStream input)
{
// tag:1 + value:8 = 9 bytes
const int expectedLength = 9;
// field=1, type=64-bit = tag of 9
const int expectedTag = 9;
// length:1 + tag:1 + value:8 = 10 bytes
if (input.bufferPos + 10 <= input.bufferSize)
{
// The entire wrapper message is already contained in `buffer`.
int length = input.buffer[input.bufferPos];
if (length == 0)
{
input.bufferPos++;
return 0D;
}
if (length != expectedLength)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageLength();
}
// tag:1 + value:8 = length of 9 bytes
// field=1, type=64-bit = tag of 9
if (input.buffer[input.bufferPos + 1] != expectedTag)
if (length != 9 || input.buffer[input.bufferPos + 1] != 9)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageTag();
return ReadDoubleWrapperSlow(input);
}
var result = BitConverter.ToDouble(input.buffer, input.bufferPos + 2);
input.bufferPos += 10;
@ -767,50 +814,119 @@ namespace Google.Protobuf
}
else
{
int length = input.ReadLength();
return ReadDoubleWrapperSlow(input);
}
}
internal static double? ReadDoubleWrapperSlow(CodedInputStream input)
{
int length = input.ReadLength();
if (length == 0)
{
return 0D;
}
int finalBufferPos = input.totalBytesRetired + input.bufferPos + length;
double result = 0D;
do
{
// field=1, type=64-bit = tag of 9
if (input.ReadTag() == 9)
{
result = input.ReadDouble();
}
else
{
input.SkipLastField();
}
}
while (input.totalBytesRetired + input.bufferPos < finalBufferPos);
return result;
}
internal static bool? ReadBoolWrapper(CodedInputStream input)
{
return ReadUInt32Wrapper(input) != 0;
}
internal static uint? ReadUInt32Wrapper(CodedInputStream input)
{
// length:1 + tag:1 + value:5(varint32-max) = 7 bytes
if (input.bufferPos + 7 <= input.bufferSize)
{
// The entire wrapper message is already contained in `buffer`.
int pos0 = input.bufferPos;
int length = input.buffer[input.bufferPos++];
if (length == 0)
{
return 0D;
return 0;
}
// Length will always fit in a single byte.
if (length >= 128)
{
input.bufferPos = pos0;
return ReadUInt32WrapperSlow(input);
}
if (length != expectedLength)
int finalBufferPos = input.bufferPos + length;
// field=1, type=varint = tag of 8
if (input.buffer[input.bufferPos++] != 8)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageLength();
input.bufferPos = pos0;
return ReadUInt32WrapperSlow(input);
}
if (input.ReadTag() != expectedTag)
var result = input.ReadUInt32();
// Verify this message only contained a single field.
if (input.bufferPos != finalBufferPos)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageTag();
input.bufferPos = pos0;
return ReadUInt32WrapperSlow(input);
}
return input.ReadDouble();
return result;
}
else
{
return ReadUInt32WrapperSlow(input);
}
}
internal static double? ReadDoubleWrapperBigEndian(CodedInputStream input)
private static uint? ReadUInt32WrapperSlow(CodedInputStream input)
{
int length = input.ReadLength();
if (length == 0)
{
return 0D;
}
// tag:1 + value:8 = 9 bytes
if (length != 9)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageLength();
return 0;
}
// field=1, type=64-bit = tag of 9
if (input.ReadTag() != 9)
int finalBufferPos = input.totalBytesRetired + input.bufferPos + length;
uint result = 0;
do
{
throw InvalidProtocolBufferException.InvalidWrapperMessageTag();
// field=1, type=varint = tag of 8
if (input.ReadTag() == 8)
{
result = input.ReadUInt32();
}
else
{
input.SkipLastField();
}
}
return input.ReadDouble();
while (input.totalBytesRetired + input.bufferPos < finalBufferPos);
return result;
}
internal static long? ReadInt64Wrapper(CodedInputStream input)
internal static int? ReadInt32Wrapper(CodedInputStream input)
{
return (int?)ReadUInt32Wrapper(input);
}
internal static ulong? ReadUInt64Wrapper(CodedInputStream input)
{
// field=1, type=varint = tag of 8
const int expectedTag = 8;
// length:1 + tag:1 + value:10(varint64-max) = 12 bytes
if (input.bufferPos + 12 <= input.bufferSize)
{
// The entire wrapper message is already contained in `buffer`.
int pos0 = input.bufferPos;
int length = input.buffer[input.bufferPos++];
if (length == 0)
{
@ -819,43 +935,61 @@ namespace Google.Protobuf
// Length will always fit in a single byte.
if (length >= 128)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageLength();
input.bufferPos = pos0;
return ReadUInt64WrapperSlow(input);
}
int finalBufferPos = input.bufferPos + length;
if (input.buffer[input.bufferPos++] != expectedTag)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageTag();
input.bufferPos = pos0;
return ReadUInt64WrapperSlow(input);
}
var result = input.ReadInt64();
var result = input.ReadUInt64();
// Verify this message only contained a single field.
if (input.bufferPos != finalBufferPos)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageExtraFields();
input.bufferPos = pos0;
return ReadUInt64WrapperSlow(input);
}
return result;
}
else
{
int length = input.ReadLength();
if (length == 0)
{
return 0L;
}
int finalBufferPos = input.totalBytesRetired + input.bufferPos + length;
if (input.ReadTag() != expectedTag)
return ReadUInt64WrapperSlow(input);
}
}
internal static ulong? ReadUInt64WrapperSlow(CodedInputStream input)
{
// field=1, type=varint = tag of 8
const int expectedTag = 8;
int length = input.ReadLength();
if (length == 0)
{
return 0L;
}
int finalBufferPos = input.totalBytesRetired + input.bufferPos + length;
ulong result = 0L;
do
{
if (input.ReadTag() == expectedTag)
{
throw InvalidProtocolBufferException.InvalidWrapperMessageTag();
result = input.ReadUInt64();
}
var result = input.ReadInt64();
// Verify this message only contained a single field.
if (input.totalBytesRetired + input.bufferPos != finalBufferPos)
else
{
throw InvalidProtocolBufferException.InvalidWrapperMessageExtraFields();
input.SkipLastField();
}
return result;
}
while (input.totalBytesRetired + input.bufferPos < finalBufferPos);
return result;
}
internal static long? ReadInt64Wrapper(CodedInputStream input)
{
return (long?)ReadUInt64Wrapper(input);
}
#endregion
#region Underlying reading primitives

25
csharp/src/Google.Protobuf/FieldCodec.cs
Unescape View File

@ -539,18 +539,21 @@ namespace Google.Protobuf
{ typeof(ByteString), ForBytes(WireFormat.MakeTag(WrappersReflection.WrapperValueFieldNumber, WireFormat.WireType.LengthDelimited)) }
};
private static readonly Dictionary<System.Type, Func<object>> Readers = new Dictionary<System.Type, Func<object>>
private static readonly Dictionary<System.Type, object> Readers = new Dictionary<System.Type, object>
{
// TODO: Provide more optimized readers.
{ typeof(bool), null },
{ typeof(int), null },
{ typeof(long), () => (Func<CodedInputStream, long?>)CodedInputStream.ReadInt64Wrapper },
{ typeof(uint), null },
{ typeof(ulong), null },
{ typeof(float), null },
{ typeof(double), () => BitConverter.IsLittleEndian ?
{ typeof(bool), (Func<CodedInputStream, bool?>)CodedInputStream.ReadBoolWrapper },
{ typeof(int), (Func<CodedInputStream, int?>)CodedInputStream.ReadInt32Wrapper },
{ typeof(long), (Func<CodedInputStream, long?>)CodedInputStream.ReadInt64Wrapper },
{ typeof(uint), (Func<CodedInputStream, uint?>)CodedInputStream.ReadUInt32Wrapper },
{ typeof(ulong), (Func<CodedInputStream, ulong?>)CodedInputStream.ReadUInt64Wrapper },
{ typeof(float), BitConverter.IsLittleEndian ?
(Func<CodedInputStream, float?>)CodedInputStream.ReadFloatWrapperLittleEndian :
(Func<CodedInputStream, float?>)CodedInputStream.ReadFloatWrapperSlow },
{ typeof(double), BitConverter.IsLittleEndian ?
(Func<CodedInputStream, double?>)CodedInputStream.ReadDoubleWrapperLittleEndian :
(Func<CodedInputStream, double?>)CodedInputStream.ReadDoubleWrapperBigEndian },
(Func<CodedInputStream, double?>)CodedInputStream.ReadDoubleWrapperSlow },
// `string` and `ByteString` less performance-sensitive. Do not implement for now.
{ typeof(string), null },
{ typeof(ByteString), null },
};
@ -571,7 +574,7 @@ namespace Google.Protobuf
internal static Func<CodedInputStream, T?> GetReader<T>() where T : struct
{
Func<object> value;
object value;
if (!Readers.TryGetValue(typeof(T), out value))
{
throw new InvalidOperationException("Invalid type argument requested for wrapper reader: " + typeof(T));
@ -583,7 +586,7 @@ namespace Google.Protobuf
return input => Read<T>(input, nestedCoded);
}
// Return optimized read for the wrapper type.
return (Func<CodedInputStream, T?>)value();
return (Func<CodedInputStream, T?>)value;
}
internal static T Read<T>(CodedInputStream input, FieldCodec<T> codec)

Write Preview
Loading…
Cancel
Save