diff --git a/lib/protoc.exe b/lib/protoc.exe
index a7ea45539b..ef0e5a7723 100644
Binary files a/lib/protoc.exe and b/lib/protoc.exe differ
diff --git a/protos/google/protobuf/descriptor.proto b/protos/google/protobuf/descriptor.proto
index 3f91c187ce..e0e6f7f23e 100644
--- a/protos/google/protobuf/descriptor.proto
+++ b/protos/google/protobuf/descriptor.proto
@@ -252,6 +252,8 @@ message FileOptions {
}
optional OptimizeMode optimize_for = 9 [default=CODE_SIZE];
+
+
// The parser stores options it doesn't recognize here. See above.
repeated UninterpretedOption uninterpreted_option = 999;
@@ -298,6 +300,11 @@ message FieldOptions {
STRING_PIECE = 2;
}
+ // The packed option can be enabled for repeated primitive fields to enable
+ // a more efficient representation on the wire. Rather than repeatedly
+ // writing the tag and type for each element, the entire array is encoded as
+ // a single length-delimited blob.
+ optional bool packed = 2;
// EXPERIMENTAL. DO NOT USE.
// For "map" fields, the name of the field in the enclosed type that
diff --git a/protos/google/protobuf/unittest.proto b/protos/google/protobuf/unittest.proto
index 313a514df8..dd58370903 100644
--- a/protos/google/protobuf/unittest.proto
+++ b/protos/google/protobuf/unittest.proto
@@ -458,6 +458,44 @@ message TestExtremeDefaultValues {
optional string utf8_string = 6 [default = "\341\210\264"];
}
+message TestPackedTypes {
+ repeated int32 packed_int32 = 90 [packed = true];
+ repeated int64 packed_int64 = 91 [packed = true];
+ repeated uint32 packed_uint32 = 92 [packed = true];
+ repeated uint64 packed_uint64 = 93 [packed = true];
+ repeated sint32 packed_sint32 = 94 [packed = true];
+ repeated sint64 packed_sint64 = 95 [packed = true];
+ repeated fixed32 packed_fixed32 = 96 [packed = true];
+ repeated fixed64 packed_fixed64 = 97 [packed = true];
+ repeated sfixed32 packed_sfixed32 = 98 [packed = true];
+ repeated sfixed64 packed_sfixed64 = 99 [packed = true];
+ repeated float packed_float = 100 [packed = true];
+ repeated double packed_double = 101 [packed = true];
+ repeated bool packed_bool = 102 [packed = true];
+ repeated ForeignEnum packed_enum = 103 [packed = true];
+}
+
+message TestPackedExtensions {
+ extensions 1 to max;
+}
+
+extend TestPackedExtensions {
+ repeated int32 packed_int32_extension = 90 [packed = true];
+ repeated int64 packed_int64_extension = 91 [packed = true];
+ repeated uint32 packed_uint32_extension = 92 [packed = true];
+ repeated uint64 packed_uint64_extension = 93 [packed = true];
+ repeated sint32 packed_sint32_extension = 94 [packed = true];
+ repeated sint64 packed_sint64_extension = 95 [packed = true];
+ repeated fixed32 packed_fixed32_extension = 96 [packed = true];
+ repeated fixed64 packed_fixed64_extension = 97 [packed = true];
+ repeated sfixed32 packed_sfixed32_extension = 98 [packed = true];
+ repeated sfixed64 packed_sfixed64_extension = 99 [packed = true];
+ repeated float packed_float_extension = 100 [packed = true];
+ repeated double packed_double_extension = 101 [packed = true];
+ repeated bool packed_bool_extension = 102 [packed = true];
+ repeated ForeignEnum packed_enum_extension = 103 [packed = true];
+}
+
// Test that RPC services work.
message FooRequest {}
message FooResponse {}
diff --git a/src/ProtoBench/BenchmarkSpeedProtoFile.cs b/src/ProtoBench/BenchmarkSpeedProtoFile.cs
index 670cccf11c..df0d52ee9d 100644
--- a/src/ProtoBench/BenchmarkSpeedProtoFile.cs
+++ b/src/ProtoBench/BenchmarkSpeedProtoFile.cs
@@ -523,8 +523,10 @@ namespace Google.ProtocolBuffers.ProtoBench {
if (HasField4) {
output.WriteString(4, Field4);
}
- foreach (ulong element in Field5List) {
- output.WriteFixed64(5, element);
+ if (field5_.Count > 0) {
+ foreach (ulong element in field5_) {
+ output.WriteFixed64(5, element);
+ }
}
if (HasField6) {
output.WriteInt32(6, Field6);
@@ -677,8 +679,11 @@ namespace Google.ProtocolBuffers.ProtoBench {
if (HasField4) {
size += pb::CodedOutputStream.ComputeStringSize(4, Field4);
}
- foreach (ulong element in Field5List) {
- size += pb::CodedOutputStream.ComputeFixed64Size(5, element);
+ {
+ int dataSize = 0;
+ dataSize = 8 * field5_.Count;
+ size += dataSize;
+ size += 1 * field5_.Count;
}
if (HasField59) {
size += pb::CodedOutputStream.ComputeBoolSize(59, Field59);
@@ -3116,8 +3121,10 @@ namespace Google.ProtocolBuffers.ProtoBench {
if (HasField13) {
output.WriteString(13, Field13);
}
- foreach (string element in Field14List) {
- output.WriteString(14, element);
+ if (field14_.Count > 0) {
+ foreach (string element in field14_) {
+ output.WriteString(14, element);
+ }
}
if (HasField15) {
output.WriteUInt64(15, Field15);
@@ -3128,8 +3135,10 @@ namespace Google.ProtocolBuffers.ProtoBench {
if (HasField20) {
output.WriteInt32(20, Field20);
}
- foreach (string element in Field22List) {
- output.WriteString(22, element);
+ if (field22_.Count > 0) {
+ foreach (string element in field22_) {
+ output.WriteString(22, element);
+ }
}
if (HasField24) {
output.WriteString(24, Field24);
@@ -3149,8 +3158,10 @@ namespace Google.ProtocolBuffers.ProtoBench {
if (HasField31) {
output.WriteMessage(31, Field31);
}
- foreach (int element in Field73List) {
- output.WriteInt32(73, element);
+ if (field73_.Count > 0) {
+ foreach (int element in field73_) {
+ output.WriteInt32(73, element);
+ }
}
UnknownFields.WriteTo(output);
}
@@ -3174,8 +3185,13 @@ namespace Google.ProtocolBuffers.ProtoBench {
if (HasField13) {
size += pb::CodedOutputStream.ComputeStringSize(13, Field13);
}
- foreach (string element in Field14List) {
- size += pb::CodedOutputStream.ComputeStringSize(14, element);
+ {
+ int dataSize = 0;
+ foreach (string element in Field14List) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 1 * field14_.Count;
}
if (HasField15) {
size += pb::CodedOutputStream.ComputeUInt64Size(15, Field15);
@@ -3195,11 +3211,21 @@ namespace Google.ProtocolBuffers.ProtoBench {
if (HasField16) {
size += pb::CodedOutputStream.ComputeStringSize(16, Field16);
}
- foreach (string element in Field22List) {
- size += pb::CodedOutputStream.ComputeStringSize(22, element);
+ {
+ int dataSize = 0;
+ foreach (string element in Field22List) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * field22_.Count;
}
- foreach (int element in Field73List) {
- size += pb::CodedOutputStream.ComputeInt32Size(73, element);
+ {
+ int dataSize = 0;
+ foreach (int element in Field73List) {
+ dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * field73_.Count;
}
if (HasField20) {
size += pb::CodedOutputStream.ComputeInt32Size(20, Field20);
@@ -4110,17 +4136,23 @@ namespace Google.ProtocolBuffers.ProtoBench {
if (HasField109) {
output.WriteInt32(109, Field109);
}
- foreach (string element in Field127List) {
- output.WriteString(127, element);
+ if (field127_.Count > 0) {
+ foreach (string element in field127_) {
+ output.WriteString(127, element);
+ }
}
- foreach (string element in Field128List) {
- output.WriteString(128, element);
+ if (field128_.Count > 0) {
+ foreach (string element in field128_) {
+ output.WriteString(128, element);
+ }
}
if (HasField129) {
output.WriteInt32(129, Field129);
}
- foreach (long element in Field130List) {
- output.WriteInt64(130, element);
+ if (field130_.Count > 0) {
+ foreach (long element in field130_) {
+ output.WriteInt64(130, element);
+ }
}
if (HasField131) {
output.WriteInt64(131, Field131);
@@ -4240,20 +4272,35 @@ namespace Google.ProtocolBuffers.ProtoBench {
foreach (global::Google.ProtocolBuffers.ProtoBench.SpeedMessage3.Types.Group1 element in Group1List) {
size += pb::CodedOutputStream.ComputeGroupSize(10, element);
}
- foreach (string element in Field128List) {
- size += pb::CodedOutputStream.ComputeStringSize(128, element);
+ {
+ int dataSize = 0;
+ foreach (string element in Field128List) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * field128_.Count;
}
if (HasField131) {
size += pb::CodedOutputStream.ComputeInt64Size(131, Field131);
}
- foreach (string element in Field127List) {
- size += pb::CodedOutputStream.ComputeStringSize(127, element);
+ {
+ int dataSize = 0;
+ foreach (string element in Field127List) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * field127_.Count;
}
if (HasField129) {
size += pb::CodedOutputStream.ComputeInt32Size(129, Field129);
}
- foreach (long element in Field130List) {
- size += pb::CodedOutputStream.ComputeInt64Size(130, element);
+ {
+ int dataSize = 0;
+ foreach (long element in Field130List) {
+ dataSize += pb::CodedOutputStream.ComputeInt64SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * field130_.Count;
}
if (HasField205) {
size += pb::CodedOutputStream.ComputeBoolSize(205, Field205);
diff --git a/src/ProtoGen/FieldGeneratorBase.cs b/src/ProtoGen/FieldGeneratorBase.cs
index 207f3fdc35..357614d1dc 100644
--- a/src/ProtoGen/FieldGeneratorBase.cs
+++ b/src/ProtoGen/FieldGeneratorBase.cs
@@ -97,6 +97,45 @@ namespace Google.ProtocolBuffers.ProtoGen {
}
}
+ ///
+ /// For encodings with fixed sizes, returns that size in bytes. Otherwise
+ /// returns -1. TODO(jonskeet): Make this less ugly.
+ ///
+ protected int FixedSize {
+ get {
+ switch (Descriptor.FieldType) {
+ case FieldType.UInt32:
+ case FieldType.UInt64:
+ case FieldType.Int32:
+ case FieldType.Int64:
+ case FieldType.SInt32:
+ case FieldType.SInt64:
+ case FieldType.Enum:
+ case FieldType.Bytes:
+ case FieldType.String:
+ case FieldType.Message:
+ case FieldType.Group:
+ return -1;
+ case FieldType.Float:
+ return WireFormat.FloatSize;
+ case FieldType.SFixed32:
+ return WireFormat.SFixed32Size;
+ case FieldType.Fixed32:
+ return WireFormat.Fixed32Size;
+ case FieldType.Double:
+ return WireFormat.DoubleSize;
+ case FieldType.SFixed64:
+ return WireFormat.SFixed64Size;
+ case FieldType.Fixed64:
+ return WireFormat.Fixed64Size;
+ case FieldType.Bool:
+ return WireFormat.BoolSize;
+ default:
+ throw new InvalidOperationException("Invalid field descriptor type");
+ }
+ }
+ }
+
protected bool IsNullableType {
get {
switch (Descriptor.FieldType) {
diff --git a/src/ProtoGen/MessageGenerator.cs b/src/ProtoGen/MessageGenerator.cs
index efd02db1d5..3c26569ec6 100644
--- a/src/ProtoGen/MessageGenerator.cs
+++ b/src/ProtoGen/MessageGenerator.cs
@@ -391,7 +391,7 @@ namespace Google.ProtocolBuffers.ProtoGen {
writer.WriteLine(" break;");
writer.WriteLine("}");
foreach (FieldDescriptor field in sortedFields) {
- uint tag = WireFormat.MakeTag(field.FieldNumber, WireFormat.GetWireType(field.FieldType));
+ uint tag = WireFormat.MakeTag(field);
writer.WriteLine("case {0}: {{", tag);
writer.Indent();
SourceGenerators.CreateFieldGenerator(field).GenerateParsingCode(writer);
diff --git a/src/ProtoGen/RepeatedEnumFieldGenerator.cs b/src/ProtoGen/RepeatedEnumFieldGenerator.cs
index 58d0141cf1..1bd6c0054e 100644
--- a/src/ProtoGen/RepeatedEnumFieldGenerator.cs
+++ b/src/ProtoGen/RepeatedEnumFieldGenerator.cs
@@ -1,6 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
@@ -11,6 +9,9 @@ namespace Google.ProtocolBuffers.ProtoGen {
}
public void GenerateMembers(TextGenerator writer) {
+ if (Descriptor.IsPacked && Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
+ writer.WriteLine("private int {0}MemoizedSerializedSize;", Name);
+ }
writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name);
@@ -66,6 +67,15 @@ namespace Google.ProtocolBuffers.ProtoGen {
}
public void GenerateParsingCode(TextGenerator writer) {
+ // If packed, set up the while loop
+ if (Descriptor.IsPacked) {
+ writer.WriteLine("int length = input.ReadInt32();");
+ writer.WriteLine("int oldLimit = input.PushLimit(length);");
+ writer.WriteLine("while (!input.ReachedLimit) {");
+ writer.Indent();
+ }
+
+ // Read and store the enum
// TODO(jonskeet): Make a more efficient way of doing this
writer.WriteLine("int rawValue = input.ReadEnum();");
writer.WriteLine("if (!global::System.Enum.IsDefined(typeof({0}), rawValue)) {{", TypeName);
@@ -73,17 +83,56 @@ namespace Google.ProtocolBuffers.ProtoGen {
writer.WriteLine("} else {");
writer.WriteLine(" Add{0}(({1}) rawValue);", PropertyName, TypeName);
writer.WriteLine("}");
+
+ if (Descriptor.IsPacked) {
+ writer.Outdent();
+ writer.WriteLine("}");
+ writer.WriteLine("input.PopLimit(oldLimit);");
+ }
}
public void GenerateSerializationCode(TextGenerator writer) {
- writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, PropertyName);
- writer.WriteLine(" output.WriteEnum({0}, (int) element);", Number);
+ writer.WriteLine("if ({0}_.Count > 0) {{", Name);
+ writer.Indent();
+ if (Descriptor.IsPacked) {
+ writer.WriteLine("output.WriteRawVarint32({0});", WireFormat.MakeTag(Descriptor));
+ writer.WriteLine("output.WriteRawVarint32((uint) {0}MemoizedSerializedSize);", Name);
+ writer.WriteLine("foreach (int element in {0}_) {{", Name);
+ writer.WriteLine(" output.WriteEnumNoTag(element);");
+ writer.WriteLine("}");
+ } else {
+ writer.WriteLine("foreach (int element in {0}_) {{", Name);
+ writer.WriteLine(" output.WriteEnum({0}, element);", Number);
+ writer.WriteLine("}");
+ }
+ writer.Outdent();
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer) {
- writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, PropertyName);
- writer.WriteLine(" size += pb::CodedOutputStream.ComputeEnumSize({0}, (int) element);", Number);
+ writer.WriteLine("{");
+ writer.Indent();
+ writer.WriteLine("int dataSize = 0;");
+ writer.WriteLine("if ({0}_.Count > 0) {{", Name);
+ writer.Indent();
+ writer.WriteLine("foreach ({0} element in {1}_) {{", TypeName, Name);
+ writer.WriteLine(" dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element);");
+ writer.WriteLine("}");
+ writer.WriteLine("size += dataSize;");
+ int tagSize = CodedOutputStream.ComputeTagSize(Descriptor.FieldNumber);
+ if (Descriptor.IsPacked) {
+ writer.WriteLine("size += {0};", tagSize);
+ writer.WriteLine("size += pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);");
+ } else {
+ writer.WriteLine("size += {0} * {1}_.Count;", tagSize, Name);
+ }
+ writer.Outdent();
+ writer.WriteLine("}");
+ // cache the data size for packed fields.
+ if (Descriptor.IsPacked) {
+ writer.WriteLine("{0}MemoizedSerializedSize = dataSize;", Name);
+ }
+ writer.Outdent();
writer.WriteLine("}");
}
}
diff --git a/src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs b/src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs
index 3650642f22..208d41513b 100644
--- a/src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs
+++ b/src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs
@@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Text;
+using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Descriptors;
namespace Google.ProtocolBuffers.ProtoGen {
@@ -11,6 +12,9 @@ namespace Google.ProtocolBuffers.ProtoGen {
}
public void GenerateMembers(TextGenerator writer) {
+ if (Descriptor.IsPacked && Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
+ writer.WriteLine("private int {0}MemoizedSerializedSize;", Name);
+ }
writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, PropertyName);
writer.WriteLine(" get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name);
@@ -68,18 +72,60 @@ namespace Google.ProtocolBuffers.ProtoGen {
}
public void GenerateParsingCode(TextGenerator writer) {
- writer.WriteLine("Add{0}(input.Read{1}());", PropertyName, CapitalizedTypeName);
+ if (Descriptor.IsPacked) {
+ writer.WriteLine("int length = input.ReadInt32();");
+ writer.WriteLine("int limit = input.PushLimit(length);");
+ writer.WriteLine("while (!input.ReachedLimit) {");
+ writer.WriteLine(" Add{0}(input.Read{1}());", PropertyName, CapitalizedTypeName);
+ writer.WriteLine("}");
+ writer.WriteLine("input.PopLimit(limit);");
+ } else {
+ writer.WriteLine("Add{0}(input.Read{1}());", PropertyName, CapitalizedTypeName);
+ }
}
public void GenerateSerializationCode(TextGenerator writer) {
- writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, PropertyName);
- writer.WriteLine(" output.Write{0}({1}, element);", CapitalizedTypeName, Number);
+ writer.WriteLine("if ({0}_.Count > 0) {{", Name);
+ writer.Indent();
+ if (Descriptor.IsPacked) {
+ writer.WriteLine("output.WriteRawVarint32({0});", WireFormat.MakeTag(Descriptor));
+ writer.WriteLine("output.WriteRawVarint32((uint) {0}MemoizedSerializedSize);", Name);
+ writer.WriteLine("foreach ({0} element in {1}_) {{", TypeName, Name);
+ writer.WriteLine(" output.Write{0}NoTag(element);", CapitalizedTypeName);
+ writer.WriteLine("}");
+ } else {
+ writer.WriteLine("foreach ({0} element in {1}_) {{", TypeName, Name);
+ writer.WriteLine(" output.Write{0}({1}, element);", CapitalizedTypeName, Number);
+ writer.WriteLine("}");
+ }
+ writer.Outdent();
writer.WriteLine("}");
}
public void GenerateSerializedSizeCode(TextGenerator writer) {
- writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, PropertyName);
- writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, element);", CapitalizedTypeName, Number);
+ writer.WriteLine("{");
+ writer.Indent();
+ writer.WriteLine("int dataSize = 0;");
+ if (FixedSize == -1) {
+ writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, PropertyName);
+ writer.WriteLine(" dataSize += pb::CodedOutputStream.Compute{0}SizeNoTag(element);", CapitalizedTypeName, Number);
+ writer.WriteLine("}");
+ } else {
+ writer.WriteLine("dataSize = {0} * {1}_.Count;", FixedSize, Name);
+ }
+ writer.WriteLine("size += dataSize;");
+ int tagSize = CodedOutputStream.ComputeTagSize(Descriptor.FieldNumber);
+ if (Descriptor.IsPacked) {
+ writer.WriteLine("size += {0};", tagSize);
+ writer.WriteLine("size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);");
+ } else {
+ writer.WriteLine("size += {0} * {1}_.Count;", tagSize, Name);
+ }
+ // cache the data size for packed fields.
+ if (Descriptor.IsPacked) {
+ writer.WriteLine("{0}MemoizedSerializedSize = dataSize;", Name);
+ }
+ writer.Outdent();
writer.WriteLine("}");
}
}
diff --git a/src/ProtocolBuffers.Test/AbstractMessageTest.cs b/src/ProtocolBuffers.Test/AbstractMessageTest.cs
index 260ae28c18..b77264f27e 100644
--- a/src/ProtocolBuffers.Test/AbstractMessageTest.cs
+++ b/src/ProtocolBuffers.Test/AbstractMessageTest.cs
@@ -73,6 +73,20 @@ namespace Google.ProtocolBuffers {
TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage);
}
+ [Test]
+ public void PackedSerialization() {
+ IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetPackedSet());
+ TestUtil.AssertPackedFieldsSet(TestPackedTypes.ParseFrom(abstractMessage.ToByteString()));
+ Assert.AreEqual(TestUtil.GetPackedSet().ToByteString(), abstractMessage.ToByteString());
+ }
+
+ [Test]
+ public void PackedParsing() {
+ AbstractMessageWrapper.Builder builder = new AbstractMessageWrapper.Builder(TestPackedTypes.CreateBuilder());
+ AbstractMessageWrapper message = builder.MergeFrom(TestUtil.GetPackedSet().ToByteString()).Build();
+ TestUtil.AssertPackedFieldsSet((TestPackedTypes)message.WrappedMessage);
+ }
+
[Test]
public void OptimizedForSize() {
// We're mostly only Checking that this class was compiled successfully.
diff --git a/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
index 01762f7424..b4aa14dd03 100644
--- a/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
+++ b/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs
@@ -196,6 +196,18 @@ namespace Google.ProtocolBuffers {
}
}
+ ///
+ /// Tests writing a whole message with every packed field type. Ensures the
+ /// wire format of packed fields is compatible with C++.
+ ///
+ [Test]
+ public void WriteWholePackedFieldsMessage() {
+ TestPackedTypes message = TestUtil.GetPackedSet();
+
+ byte[] rawBytes = message.ToByteArray();
+ TestUtil.AssertEqualBytes(TestUtil.GetGoldenPackedFieldsMessage().ToByteArray(),
+ rawBytes);
+ }
[Test]
public void EncodeZigZag32() {
diff --git a/src/ProtocolBuffers.Test/DynamicMessageTest.cs b/src/ProtocolBuffers.Test/DynamicMessageTest.cs
index 045f5c4f5c..89193ad23c 100644
--- a/src/ProtocolBuffers.Test/DynamicMessageTest.cs
+++ b/src/ProtocolBuffers.Test/DynamicMessageTest.cs
@@ -38,11 +38,13 @@ namespace Google.ProtocolBuffers {
private ReflectionTester reflectionTester;
private ReflectionTester extensionsReflectionTester;
+ private ReflectionTester packedReflectionTester;
[SetUp]
public void SetUp() {
reflectionTester = ReflectionTester.CreateTestAllTypesInstance();
extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance();
+ packedReflectionTester = ReflectionTester.CreateTestPackedTypesInstance();
}
[Test]
@@ -135,6 +137,33 @@ namespace Google.ProtocolBuffers {
reflectionTester.AssertAllFieldsSetViaReflection(message2);
}
+ [Test]
+ public void DynamicMessagePackedSerialization() {
+ IBuilder builder = DynamicMessage.CreateBuilder(TestPackedTypes.Descriptor);
+ packedReflectionTester.SetPackedFieldsViaReflection(builder);
+ IMessage message = builder.WeakBuild();
+
+ ByteString rawBytes = message.ToByteString();
+ TestPackedTypes message2 = TestPackedTypes.ParseFrom(rawBytes);
+
+ TestUtil.AssertPackedFieldsSet(message2);
+
+ // In fact, the serialized forms should be exactly the same, byte-for-byte.
+ Assert.AreEqual(TestUtil.GetPackedSet().ToByteString(), rawBytes);
+ }
+
+ [Test]
+ public void testDynamicMessagePackedParsing() {
+ TestPackedTypes.Builder builder = TestPackedTypes.CreateBuilder();
+ TestUtil.SetPackedFields(builder);
+ TestPackedTypes message = builder.Build();
+
+ ByteString rawBytes = message.ToByteString();
+
+ IMessage message2 = DynamicMessage.ParseFrom(TestPackedTypes.Descriptor, rawBytes);
+ packedReflectionTester.AssertPackedFieldsSetViaReflection(message2);
+ }
+
[Test]
public void DynamicMessageCopy() {
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
diff --git a/src/ProtocolBuffers.Test/ReflectionTester.cs b/src/ProtocolBuffers.Test/ReflectionTester.cs
index 767c8cc969..4953314ab8 100644
--- a/src/ProtocolBuffers.Test/ReflectionTester.cs
+++ b/src/ProtocolBuffers.Test/ReflectionTester.cs
@@ -88,12 +88,12 @@ namespace Google.ProtocolBuffers {
this.file = baseDescriptor.File;
// TODO(jonskeet): We've got 2 dependencies, not 1 - because of the C# options. Hmm.
-// Assert.AreEqual(1, file.Dependencies.Count);
+ // Assert.AreEqual(1, file.Dependencies.Count);
// TODO(jonskeet): Find dependency by name instead of number?
this.importFile = file.Dependencies[1];
MessageDescriptor testAllTypes;
- if (extensionRegistry == null) {
+ if (baseDescriptor.Name == "TestAllTypes") {
testAllTypes = baseDescriptor;
} else {
testAllTypes = file.FindTypeByName("TestAllTypes");
@@ -101,10 +101,13 @@ namespace Google.ProtocolBuffers {
}
if (extensionRegistry == null) {
+ // Use testAllTypes, rather than baseDescriptor, to allow
+ // initialization using TestPackedTypes descriptors. These objects
+ // won't be used by the methods for packed fields.
this.optionalGroup =
- baseDescriptor.FindDescriptor("OptionalGroup");
+ testAllTypes.FindDescriptor("OptionalGroup");
this.repeatedGroup =
- baseDescriptor.FindDescriptor("RepeatedGroup");
+ testAllTypes.FindDescriptor("RepeatedGroup");
} else {
this.optionalGroup =
file.FindTypeByName("OptionalGroup_extension");
@@ -119,18 +122,18 @@ namespace Google.ProtocolBuffers {
this.foreignEnum = file.FindTypeByName("ForeignEnum");
this.importEnum = importFile.FindTypeByName("ImportEnum");
- Assert.IsNotNull(optionalGroup );
- Assert.IsNotNull(repeatedGroup );
- Assert.IsNotNull(nestedMessage );
+ Assert.IsNotNull(optionalGroup);
+ Assert.IsNotNull(repeatedGroup);
+ Assert.IsNotNull(nestedMessage);
Assert.IsNotNull(foreignMessage);
- Assert.IsNotNull(importMessage );
- Assert.IsNotNull(nestedEnum );
- Assert.IsNotNull(foreignEnum );
- Assert.IsNotNull(importEnum );
+ Assert.IsNotNull(importMessage);
+ Assert.IsNotNull(nestedEnum);
+ Assert.IsNotNull(foreignEnum);
+ Assert.IsNotNull(importEnum);
- this.nestedB = nestedMessage.FindDescriptor("bb");
+ this.nestedB = nestedMessage.FindDescriptor("bb");
this.foreignC = foreignMessage.FindDescriptor("c");
- this.importD = importMessage .FindDescriptor("d");
+ this.importD = importMessage.FindDescriptor("d");
this.nestedFoo = nestedEnum.FindValueByName("FOO");
this.nestedBar = nestedEnum.FindValueByName("BAR");
this.nestedBaz = nestedEnum.FindValueByName("BAZ");
@@ -144,20 +147,20 @@ namespace Google.ProtocolBuffers {
this.groupA = optionalGroup.FindDescriptor("a");
this.repeatedGroupA = repeatedGroup.FindDescriptor("a");
- Assert.IsNotNull(groupA );
+ Assert.IsNotNull(groupA);
Assert.IsNotNull(repeatedGroupA);
- Assert.IsNotNull(nestedB );
- Assert.IsNotNull(foreignC );
- Assert.IsNotNull(importD );
- Assert.IsNotNull(nestedFoo );
- Assert.IsNotNull(nestedBar );
- Assert.IsNotNull(nestedBaz );
- Assert.IsNotNull(foreignFoo );
- Assert.IsNotNull(foreignBar );
- Assert.IsNotNull(foreignBaz );
- Assert.IsNotNull(importFoo );
- Assert.IsNotNull(importBar );
- Assert.IsNotNull(importBaz );
+ Assert.IsNotNull(nestedB);
+ Assert.IsNotNull(foreignC);
+ Assert.IsNotNull(importD);
+ Assert.IsNotNull(nestedFoo);
+ Assert.IsNotNull(nestedBar);
+ Assert.IsNotNull(nestedBaz);
+ Assert.IsNotNull(foreignFoo);
+ Assert.IsNotNull(foreignBar);
+ Assert.IsNotNull(foreignBaz);
+ Assert.IsNotNull(importFoo);
+ Assert.IsNotNull(importBar);
+ Assert.IsNotNull(importBaz);
}
///
@@ -171,10 +174,17 @@ namespace Google.ProtocolBuffers {
/// Creates an instance for the TestAllExtensions message, with an
/// extension registry from TestUtil.CreateExtensionRegistry.
///
- public static ReflectionTester CreateTestAllExtensionsInstance() {
+ public static ReflectionTester CreateTestAllExtensionsInstance() {
return new ReflectionTester(TestAllExtensions.Descriptor, TestUtil.CreateExtensionRegistry());
}
+ ///
+ /// Creates an instance for the TestPackedTypes message, with no extensions.
+ ///
+ public static ReflectionTester CreateTestPackedTypesInstance() {
+ return new ReflectionTester(TestPackedTypes.Descriptor, null);
+ }
+
///
/// Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes.
///
@@ -210,20 +220,20 @@ namespace Google.ProtocolBuffers {
///
///
internal void SetAllFieldsViaReflection(IBuilder message) {
- message[f("optional_int32" )] = 101 ;
- message[f("optional_int64" )] = 102L;
- message[f("optional_uint32" )] = 103U ;
- message[f("optional_uint64" )] = 104UL;
- message[f("optional_sint32" )] = 105 ;
- message[f("optional_sint64" )] = 106L;
- message[f("optional_fixed32" )] = 107U ;
- message[f("optional_fixed64" )] = 108UL;
- message[f("optional_sfixed32")] = 109 ;
+ message[f("optional_int32")] = 101;
+ message[f("optional_int64")] = 102L;
+ message[f("optional_uint32")] = 103U;
+ message[f("optional_uint64")] = 104UL;
+ message[f("optional_sint32")] = 105;
+ message[f("optional_sint64")] = 106L;
+ message[f("optional_fixed32")] = 107U;
+ message[f("optional_fixed64")] = 108UL;
+ message[f("optional_sfixed32")] = 109;
message[f("optional_sfixed64")] = 110L;
- message[f("optional_float" )] = 111F;
- message[f("optional_double" )] = 112D;
- message[f("optional_bool" )] = true;
- message[f("optional_string" )] = "115";
+ message[f("optional_float")] = 111F;
+ message[f("optional_double")] = 112D;
+ message[f("optional_bool")] = true;
+ message[f("optional_string")] = "115";
message[f("optional_bytes")] = TestUtil.ToBytes("116");
message[f("optionalgroup")] = CreateBuilderForField(message, f("optionalgroup")).SetField(groupA, 117).WeakBuild();
@@ -231,30 +241,30 @@ namespace Google.ProtocolBuffers {
message[f("optional_foreign_message")] = CreateBuilderForField(message, f("optional_foreign_message")).SetField(foreignC, 119).WeakBuild();
message[f("optional_import_message")] = CreateBuilderForField(message, f("optional_import_message")).SetField(importD, 120).WeakBuild();
- message[f("optional_nested_enum" )] = nestedBaz;
+ message[f("optional_nested_enum")] = nestedBaz;
message[f("optional_foreign_enum")] = foreignBaz;
- message[f("optional_import_enum" )] = importBaz;
+ message[f("optional_import_enum")] = importBaz;
- message[f("optional_string_piece" )] = "124";
- message[f("optional_cord" )] = "125";
+ message[f("optional_string_piece")] = "124";
+ message[f("optional_cord")] = "125";
// -----------------------------------------------------------------
- message.WeakAddRepeatedField(f("repeated_int32" ), 201 );
- message.WeakAddRepeatedField(f("repeated_int64" ), 202L);
- message.WeakAddRepeatedField(f("repeated_uint32" ), 203U );
- message.WeakAddRepeatedField(f("repeated_uint64" ), 204UL);
- message.WeakAddRepeatedField(f("repeated_sint32" ), 205 );
- message.WeakAddRepeatedField(f("repeated_sint64" ), 206L);
- message.WeakAddRepeatedField(f("repeated_fixed32" ), 207U );
- message.WeakAddRepeatedField(f("repeated_fixed64" ), 208UL);
- message.WeakAddRepeatedField(f("repeated_sfixed32"), 209 );
+ message.WeakAddRepeatedField(f("repeated_int32"), 201);
+ message.WeakAddRepeatedField(f("repeated_int64"), 202L);
+ message.WeakAddRepeatedField(f("repeated_uint32"), 203U);
+ message.WeakAddRepeatedField(f("repeated_uint64"), 204UL);
+ message.WeakAddRepeatedField(f("repeated_sint32"), 205);
+ message.WeakAddRepeatedField(f("repeated_sint64"), 206L);
+ message.WeakAddRepeatedField(f("repeated_fixed32"), 207U);
+ message.WeakAddRepeatedField(f("repeated_fixed64"), 208UL);
+ message.WeakAddRepeatedField(f("repeated_sfixed32"), 209);
message.WeakAddRepeatedField(f("repeated_sfixed64"), 210L);
- message.WeakAddRepeatedField(f("repeated_float" ), 211F);
- message.WeakAddRepeatedField(f("repeated_double" ), 212D);
- message.WeakAddRepeatedField(f("repeated_bool" ), true);
- message.WeakAddRepeatedField(f("repeated_string" ), "215");
- message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("216"));
+ message.WeakAddRepeatedField(f("repeated_float"), 211F);
+ message.WeakAddRepeatedField(f("repeated_double"), 212D);
+ message.WeakAddRepeatedField(f("repeated_bool"), true);
+ message.WeakAddRepeatedField(f("repeated_string"), "215");
+ message.WeakAddRepeatedField(f("repeated_bytes"), TestUtil.ToBytes("216"));
message.WeakAddRepeatedField(f("repeatedgroup"), CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 217).WeakBuild());
@@ -262,29 +272,29 @@ namespace Google.ProtocolBuffers {
message.WeakAddRepeatedField(f("repeated_foreign_message"), CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 219).WeakBuild());
message.WeakAddRepeatedField(f("repeated_import_message"), CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 220).WeakBuild());
- message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBar);
+ message.WeakAddRepeatedField(f("repeated_nested_enum"), nestedBar);
message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBar);
- message.WeakAddRepeatedField(f("repeated_import_enum" ), importBar);
+ message.WeakAddRepeatedField(f("repeated_import_enum"), importBar);
- message.WeakAddRepeatedField(f("repeated_string_piece" ), "224");
- message.WeakAddRepeatedField(f("repeated_cord" ), "225");
+ message.WeakAddRepeatedField(f("repeated_string_piece"), "224");
+ message.WeakAddRepeatedField(f("repeated_cord"), "225");
// Add a second one of each field.
- message.WeakAddRepeatedField(f("repeated_int32" ), 301 );
- message.WeakAddRepeatedField(f("repeated_int64" ), 302L);
- message.WeakAddRepeatedField(f("repeated_uint32" ), 303U );
- message.WeakAddRepeatedField(f("repeated_uint64" ), 304UL);
- message.WeakAddRepeatedField(f("repeated_sint32" ), 305 );
- message.WeakAddRepeatedField(f("repeated_sint64" ), 306L);
- message.WeakAddRepeatedField(f("repeated_fixed32" ), 307U );
- message.WeakAddRepeatedField(f("repeated_fixed64" ), 308UL);
- message.WeakAddRepeatedField(f("repeated_sfixed32"), 309 );
+ message.WeakAddRepeatedField(f("repeated_int32"), 301);
+ message.WeakAddRepeatedField(f("repeated_int64"), 302L);
+ message.WeakAddRepeatedField(f("repeated_uint32"), 303U);
+ message.WeakAddRepeatedField(f("repeated_uint64"), 304UL);
+ message.WeakAddRepeatedField(f("repeated_sint32"), 305);
+ message.WeakAddRepeatedField(f("repeated_sint64"), 306L);
+ message.WeakAddRepeatedField(f("repeated_fixed32"), 307U);
+ message.WeakAddRepeatedField(f("repeated_fixed64"), 308UL);
+ message.WeakAddRepeatedField(f("repeated_sfixed32"), 309);
message.WeakAddRepeatedField(f("repeated_sfixed64"), 310L);
- message.WeakAddRepeatedField(f("repeated_float" ), 311F);
- message.WeakAddRepeatedField(f("repeated_double" ), 312D);
- message.WeakAddRepeatedField(f("repeated_bool" ), false);
- message.WeakAddRepeatedField(f("repeated_string" ), "315");
- message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("316"));
+ message.WeakAddRepeatedField(f("repeated_float"), 311F);
+ message.WeakAddRepeatedField(f("repeated_double"), 312D);
+ message.WeakAddRepeatedField(f("repeated_bool"), false);
+ message.WeakAddRepeatedField(f("repeated_string"), "315");
+ message.WeakAddRepeatedField(f("repeated_bytes"), TestUtil.ToBytes("316"));
message.WeakAddRepeatedField(f("repeatedgroup"),
CreateBuilderForField(message, f("repeatedgroup"))
@@ -299,37 +309,37 @@ namespace Google.ProtocolBuffers {
CreateBuilderForField(message, f("repeated_import_message"))
.SetField(importD, 320).WeakBuild());
- message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBaz);
+ message.WeakAddRepeatedField(f("repeated_nested_enum"), nestedBaz);
message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBaz);
- message.WeakAddRepeatedField(f("repeated_import_enum" ), importBaz);
+ message.WeakAddRepeatedField(f("repeated_import_enum"), importBaz);
- message.WeakAddRepeatedField(f("repeated_string_piece" ), "324");
- message.WeakAddRepeatedField(f("repeated_cord" ), "325");
+ message.WeakAddRepeatedField(f("repeated_string_piece"), "324");
+ message.WeakAddRepeatedField(f("repeated_cord"), "325");
// -----------------------------------------------------------------
- message[f("default_int32" )] = 401 ;
- message[f("default_int64" )] = 402L;
- message[f("default_uint32" )] = 403U ;
- message[f("default_uint64" )] = 404UL;
- message[f("default_sint32" )] = 405 ;
- message[f("default_sint64" )] = 406L;
- message[f("default_fixed32" )] = 407U ;
- message[f("default_fixed64" )] = 408UL;
- message[f("default_sfixed32")] = 409 ;
+ message[f("default_int32")] = 401;
+ message[f("default_int64")] = 402L;
+ message[f("default_uint32")] = 403U;
+ message[f("default_uint64")] = 404UL;
+ message[f("default_sint32")] = 405;
+ message[f("default_sint64")] = 406L;
+ message[f("default_fixed32")] = 407U;
+ message[f("default_fixed64")] = 408UL;
+ message[f("default_sfixed32")] = 409;
message[f("default_sfixed64")] = 410L;
- message[f("default_float" )] = 411F;
- message[f("default_double" )] = 412D;
- message[f("default_bool" )] = false;
- message[f("default_string" )] = "415";
- message[f("default_bytes" )] = TestUtil.ToBytes("416");
+ message[f("default_float")] = 411F;
+ message[f("default_double")] = 412D;
+ message[f("default_bool")] = false;
+ message[f("default_string")] = "415";
+ message[f("default_bytes")] = TestUtil.ToBytes("416");
- message[f("default_nested_enum" )] = nestedFoo;
+ message[f("default_nested_enum")] = nestedFoo;
message[f("default_foreign_enum")] = foreignFoo;
- message[f("default_import_enum" )] = importFoo;
+ message[f("default_import_enum")] = importFoo;
- message[f("default_string_piece" )] = "424";
- message[f("default_cord" )] = "425";
+ message[f("default_string_piece")] = "424";
+ message[f("default_cord")] = "425";
}
// -------------------------------------------------------------------
@@ -340,30 +350,30 @@ namespace Google.ProtocolBuffers {
/// reflection interface.
///
internal void ModifyRepeatedFieldsViaReflection(IBuilder message) {
- message[f("repeated_int32" ), 1] = 501 ;
- message[f("repeated_int64" ), 1] = 502L;
- message[f("repeated_uint32" ), 1] = 503U ;
- message[f("repeated_uint64" ), 1] = 504UL;
- message[f("repeated_sint32" ), 1] = 505 ;
- message[f("repeated_sint64" ), 1] = 506L;
- message[f("repeated_fixed32" ), 1] = 507U ;
- message[f("repeated_fixed64" ), 1] = 508UL;
- message[f("repeated_sfixed32"), 1] = 509 ;
+ message[f("repeated_int32"), 1] = 501;
+ message[f("repeated_int64"), 1] = 502L;
+ message[f("repeated_uint32"), 1] = 503U;
+ message[f("repeated_uint64"), 1] = 504UL;
+ message[f("repeated_sint32"), 1] = 505;
+ message[f("repeated_sint64"), 1] = 506L;
+ message[f("repeated_fixed32"), 1] = 507U;
+ message[f("repeated_fixed64"), 1] = 508UL;
+ message[f("repeated_sfixed32"), 1] = 509;
message[f("repeated_sfixed64"), 1] = 510L;
- message[f("repeated_float" ), 1] = 511F;
- message[f("repeated_double" ), 1] = 512D;
- message[f("repeated_bool" ), 1] = true;
- message[f("repeated_string" ), 1] = "515";
- message.SetRepeatedField(f("repeated_bytes" ), 1, TestUtil.ToBytes("516"));
+ message[f("repeated_float"), 1] = 511F;
+ message[f("repeated_double"), 1] = 512D;
+ message[f("repeated_bool"), 1] = true;
+ message[f("repeated_string"), 1] = "515";
+ message.SetRepeatedField(f("repeated_bytes"), 1, TestUtil.ToBytes("516"));
message.SetRepeatedField(f("repeatedgroup"), 1, CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 517).WeakBuild());
message.SetRepeatedField(f("repeated_nested_message"), 1, CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 518).WeakBuild());
message.SetRepeatedField(f("repeated_foreign_message"), 1, CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 519).WeakBuild());
message.SetRepeatedField(f("repeated_import_message"), 1, CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 520).WeakBuild());
- message[f("repeated_nested_enum" ), 1] = nestedFoo;
+ message[f("repeated_nested_enum"), 1] = nestedFoo;
message[f("repeated_foreign_enum"), 1] = foreignFoo;
- message[f("repeated_import_enum" ), 1] = importFoo;
+ message[f("repeated_import_enum"), 1] = importFoo;
message[f("repeated_string_piece"), 1] = "524";
message[f("repeated_cord"), 1] = "525";
@@ -376,196 +386,196 @@ namespace Google.ProtocolBuffers {
/// assigned by SetAllFields, using the IMessage reflection interface.
///
public void AssertAllFieldsSetViaReflection(IMessage message) {
- Assert.IsTrue(message.HasField(f("optional_int32" )));
- Assert.IsTrue(message.HasField(f("optional_int64" )));
- Assert.IsTrue(message.HasField(f("optional_uint32" )));
- Assert.IsTrue(message.HasField(f("optional_uint64" )));
- Assert.IsTrue(message.HasField(f("optional_sint32" )));
- Assert.IsTrue(message.HasField(f("optional_sint64" )));
- Assert.IsTrue(message.HasField(f("optional_fixed32" )));
- Assert.IsTrue(message.HasField(f("optional_fixed64" )));
+ Assert.IsTrue(message.HasField(f("optional_int32")));
+ Assert.IsTrue(message.HasField(f("optional_int64")));
+ Assert.IsTrue(message.HasField(f("optional_uint32")));
+ Assert.IsTrue(message.HasField(f("optional_uint64")));
+ Assert.IsTrue(message.HasField(f("optional_sint32")));
+ Assert.IsTrue(message.HasField(f("optional_sint64")));
+ Assert.IsTrue(message.HasField(f("optional_fixed32")));
+ Assert.IsTrue(message.HasField(f("optional_fixed64")));
Assert.IsTrue(message.HasField(f("optional_sfixed32")));
Assert.IsTrue(message.HasField(f("optional_sfixed64")));
- Assert.IsTrue(message.HasField(f("optional_float" )));
- Assert.IsTrue(message.HasField(f("optional_double" )));
- Assert.IsTrue(message.HasField(f("optional_bool" )));
- Assert.IsTrue(message.HasField(f("optional_string" )));
- Assert.IsTrue(message.HasField(f("optional_bytes" )));
-
- Assert.IsTrue(message.HasField(f("optionalgroup" )));
- Assert.IsTrue(message.HasField(f("optional_nested_message" )));
+ Assert.IsTrue(message.HasField(f("optional_float")));
+ Assert.IsTrue(message.HasField(f("optional_double")));
+ Assert.IsTrue(message.HasField(f("optional_bool")));
+ Assert.IsTrue(message.HasField(f("optional_string")));
+ Assert.IsTrue(message.HasField(f("optional_bytes")));
+
+ Assert.IsTrue(message.HasField(f("optionalgroup")));
+ Assert.IsTrue(message.HasField(f("optional_nested_message")));
Assert.IsTrue(message.HasField(f("optional_foreign_message")));
- Assert.IsTrue(message.HasField(f("optional_import_message" )));
+ Assert.IsTrue(message.HasField(f("optional_import_message")));
Assert.IsTrue(((IMessage)message[f("optionalgroup")]).HasField(groupA));
Assert.IsTrue(((IMessage)message[f("optional_nested_message")]).HasField(nestedB));
Assert.IsTrue(((IMessage)message[f("optional_foreign_message")]).HasField(foreignC));
Assert.IsTrue(((IMessage)message[f("optional_import_message")]).HasField(importD));
- Assert.IsTrue(message.HasField(f("optional_nested_enum" )));
+ Assert.IsTrue(message.HasField(f("optional_nested_enum")));
Assert.IsTrue(message.HasField(f("optional_foreign_enum")));
- Assert.IsTrue(message.HasField(f("optional_import_enum" )));
+ Assert.IsTrue(message.HasField(f("optional_import_enum")));
Assert.IsTrue(message.HasField(f("optional_string_piece")));
Assert.IsTrue(message.HasField(f("optional_cord")));
- Assert.AreEqual(101 , message[f("optional_int32" )]);
- Assert.AreEqual(102L , message[f("optional_int64" )]);
- Assert.AreEqual(103U , message[f("optional_uint32" )]);
- Assert.AreEqual(104UL , message[f("optional_uint64" )]);
- Assert.AreEqual(105 , message[f("optional_sint32" )]);
- Assert.AreEqual(106L , message[f("optional_sint64" )]);
- Assert.AreEqual(107U , message[f("optional_fixed32" )]);
- Assert.AreEqual(108UL , message[f("optional_fixed64" )]);
- Assert.AreEqual(109 , message[f("optional_sfixed32")]);
- Assert.AreEqual(110L , message[f("optional_sfixed64")]);
- Assert.AreEqual(111F , message[f("optional_float" )]);
- Assert.AreEqual(112D , message[f("optional_double" )]);
- Assert.AreEqual(true , message[f("optional_bool" )]);
- Assert.AreEqual("115", message[f("optional_string" )]);
+ Assert.AreEqual(101, message[f("optional_int32")]);
+ Assert.AreEqual(102L, message[f("optional_int64")]);
+ Assert.AreEqual(103U, message[f("optional_uint32")]);
+ Assert.AreEqual(104UL, message[f("optional_uint64")]);
+ Assert.AreEqual(105, message[f("optional_sint32")]);
+ Assert.AreEqual(106L, message[f("optional_sint64")]);
+ Assert.AreEqual(107U, message[f("optional_fixed32")]);
+ Assert.AreEqual(108UL, message[f("optional_fixed64")]);
+ Assert.AreEqual(109, message[f("optional_sfixed32")]);
+ Assert.AreEqual(110L, message[f("optional_sfixed64")]);
+ Assert.AreEqual(111F, message[f("optional_float")]);
+ Assert.AreEqual(112D, message[f("optional_double")]);
+ Assert.AreEqual(true, message[f("optional_bool")]);
+ Assert.AreEqual("115", message[f("optional_string")]);
Assert.AreEqual(TestUtil.ToBytes("116"), message[f("optional_bytes")]);
- Assert.AreEqual(117,((IMessage)message[f("optionalgroup")])[groupA]);
- Assert.AreEqual(118,((IMessage)message[f("optional_nested_message")])[nestedB]);
- Assert.AreEqual(119,((IMessage)message[f("optional_foreign_message")])[foreignC]);
- Assert.AreEqual(120,((IMessage)message[f("optional_import_message")])[importD]);
+ Assert.AreEqual(117, ((IMessage)message[f("optionalgroup")])[groupA]);
+ Assert.AreEqual(118, ((IMessage)message[f("optional_nested_message")])[nestedB]);
+ Assert.AreEqual(119, ((IMessage)message[f("optional_foreign_message")])[foreignC]);
+ Assert.AreEqual(120, ((IMessage)message[f("optional_import_message")])[importD]);
- Assert.AreEqual( nestedBaz, message[f("optional_nested_enum" )]);
+ Assert.AreEqual(nestedBaz, message[f("optional_nested_enum")]);
Assert.AreEqual(foreignBaz, message[f("optional_foreign_enum")]);
- Assert.AreEqual( importBaz, message[f("optional_import_enum" )]);
+ Assert.AreEqual(importBaz, message[f("optional_import_enum")]);
Assert.AreEqual("124", message[f("optional_string_piece")]);
Assert.AreEqual("125", message[f("optional_cord")]);
// -----------------------------------------------------------------
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" )));
-
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes")));
+
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord")));
- Assert.AreEqual(201 , message[f("repeated_int32" ), 0]);
- Assert.AreEqual(202L , message[f("repeated_int64" ), 0]);
- Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]);
- Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]);
- Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]);
- Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]);
- Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]);
- Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]);
- Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]);
- Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]);
- Assert.AreEqual(211F , message[f("repeated_float" ), 0]);
- Assert.AreEqual(212D , message[f("repeated_double" ), 0]);
- Assert.AreEqual(true , message[f("repeated_bool" ), 0]);
- Assert.AreEqual("215", message[f("repeated_string" ), 0]);
+ Assert.AreEqual(201, message[f("repeated_int32"), 0]);
+ Assert.AreEqual(202L, message[f("repeated_int64"), 0]);
+ Assert.AreEqual(203U, message[f("repeated_uint32"), 0]);
+ Assert.AreEqual(204UL, message[f("repeated_uint64"), 0]);
+ Assert.AreEqual(205, message[f("repeated_sint32"), 0]);
+ Assert.AreEqual(206L, message[f("repeated_sint64"), 0]);
+ Assert.AreEqual(207U, message[f("repeated_fixed32"), 0]);
+ Assert.AreEqual(208UL, message[f("repeated_fixed64"), 0]);
+ Assert.AreEqual(209, message[f("repeated_sfixed32"), 0]);
+ Assert.AreEqual(210L, message[f("repeated_sfixed64"), 0]);
+ Assert.AreEqual(211F, message[f("repeated_float"), 0]);
+ Assert.AreEqual(212D, message[f("repeated_double"), 0]);
+ Assert.AreEqual(true, message[f("repeated_bool"), 0]);
+ Assert.AreEqual("215", message[f("repeated_string"), 0]);
Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]);
- Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]);
- Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]);
- Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]);
- Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]);
+ Assert.AreEqual(217, ((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]);
+ Assert.AreEqual(218, ((IMessage)message[f("repeated_nested_message"), 0])[nestedB]);
+ Assert.AreEqual(219, ((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]);
+ Assert.AreEqual(220, ((IMessage)message[f("repeated_import_message"), 0])[importD]);
- Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]);
- Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]);
- Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]);
+ Assert.AreEqual(nestedBar, message[f("repeated_nested_enum"), 0]);
+ Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"), 0]);
+ Assert.AreEqual(importBar, message[f("repeated_import_enum"), 0]);
Assert.AreEqual("224", message[f("repeated_string_piece"), 0]);
Assert.AreEqual("225", message[f("repeated_cord"), 0]);
- Assert.AreEqual(301 , message[f("repeated_int32" ), 1]);
- Assert.AreEqual(302L , message[f("repeated_int64" ), 1]);
- Assert.AreEqual(303U , message[f("repeated_uint32" ), 1]);
- Assert.AreEqual(304UL, message[f("repeated_uint64" ), 1]);
- Assert.AreEqual(305 , message[f("repeated_sint32" ), 1]);
- Assert.AreEqual(306L , message[f("repeated_sint64" ), 1]);
- Assert.AreEqual(307U , message[f("repeated_fixed32" ), 1]);
- Assert.AreEqual(308UL, message[f("repeated_fixed64" ), 1]);
- Assert.AreEqual(309 , message[f("repeated_sfixed32"), 1]);
- Assert.AreEqual(310L , message[f("repeated_sfixed64"), 1]);
- Assert.AreEqual(311F , message[f("repeated_float" ), 1]);
- Assert.AreEqual(312D , message[f("repeated_double" ), 1]);
- Assert.AreEqual(false, message[f("repeated_bool" ), 1]);
- Assert.AreEqual("315", message[f("repeated_string" ), 1]);
+ Assert.AreEqual(301, message[f("repeated_int32"), 1]);
+ Assert.AreEqual(302L, message[f("repeated_int64"), 1]);
+ Assert.AreEqual(303U, message[f("repeated_uint32"), 1]);
+ Assert.AreEqual(304UL, message[f("repeated_uint64"), 1]);
+ Assert.AreEqual(305, message[f("repeated_sint32"), 1]);
+ Assert.AreEqual(306L, message[f("repeated_sint64"), 1]);
+ Assert.AreEqual(307U, message[f("repeated_fixed32"), 1]);
+ Assert.AreEqual(308UL, message[f("repeated_fixed64"), 1]);
+ Assert.AreEqual(309, message[f("repeated_sfixed32"), 1]);
+ Assert.AreEqual(310L, message[f("repeated_sfixed64"), 1]);
+ Assert.AreEqual(311F, message[f("repeated_float"), 1]);
+ Assert.AreEqual(312D, message[f("repeated_double"), 1]);
+ Assert.AreEqual(false, message[f("repeated_bool"), 1]);
+ Assert.AreEqual("315", message[f("repeated_string"), 1]);
Assert.AreEqual(TestUtil.ToBytes("316"), message[f("repeated_bytes"), 1]);
- Assert.AreEqual(317,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]);
- Assert.AreEqual(318,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]);
- Assert.AreEqual(319,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]);
- Assert.AreEqual(320,((IMessage)message[f("repeated_import_message"), 1])[importD]);
+ Assert.AreEqual(317, ((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]);
+ Assert.AreEqual(318, ((IMessage)message[f("repeated_nested_message"), 1])[nestedB]);
+ Assert.AreEqual(319, ((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]);
+ Assert.AreEqual(320, ((IMessage)message[f("repeated_import_message"), 1])[importD]);
- Assert.AreEqual( nestedBaz, message[f("repeated_nested_enum" ),1]);
- Assert.AreEqual(foreignBaz, message[f("repeated_foreign_enum"),1]);
- Assert.AreEqual( importBaz, message[f("repeated_import_enum" ),1]);
+ Assert.AreEqual(nestedBaz, message[f("repeated_nested_enum"), 1]);
+ Assert.AreEqual(foreignBaz, message[f("repeated_foreign_enum"), 1]);
+ Assert.AreEqual(importBaz, message[f("repeated_import_enum"), 1]);
Assert.AreEqual("324", message[f("repeated_string_piece"), 1]);
Assert.AreEqual("325", message[f("repeated_cord"), 1]);
// -----------------------------------------------------------------
- Assert.IsTrue(message.HasField(f("default_int32" )));
- Assert.IsTrue(message.HasField(f("default_int64" )));
- Assert.IsTrue(message.HasField(f("default_uint32" )));
- Assert.IsTrue(message.HasField(f("default_uint64" )));
- Assert.IsTrue(message.HasField(f("default_sint32" )));
- Assert.IsTrue(message.HasField(f("default_sint64" )));
- Assert.IsTrue(message.HasField(f("default_fixed32" )));
- Assert.IsTrue(message.HasField(f("default_fixed64" )));
+ Assert.IsTrue(message.HasField(f("default_int32")));
+ Assert.IsTrue(message.HasField(f("default_int64")));
+ Assert.IsTrue(message.HasField(f("default_uint32")));
+ Assert.IsTrue(message.HasField(f("default_uint64")));
+ Assert.IsTrue(message.HasField(f("default_sint32")));
+ Assert.IsTrue(message.HasField(f("default_sint64")));
+ Assert.IsTrue(message.HasField(f("default_fixed32")));
+ Assert.IsTrue(message.HasField(f("default_fixed64")));
Assert.IsTrue(message.HasField(f("default_sfixed32")));
Assert.IsTrue(message.HasField(f("default_sfixed64")));
- Assert.IsTrue(message.HasField(f("default_float" )));
- Assert.IsTrue(message.HasField(f("default_double" )));
- Assert.IsTrue(message.HasField(f("default_bool" )));
- Assert.IsTrue(message.HasField(f("default_string" )));
- Assert.IsTrue(message.HasField(f("default_bytes" )));
+ Assert.IsTrue(message.HasField(f("default_float")));
+ Assert.IsTrue(message.HasField(f("default_double")));
+ Assert.IsTrue(message.HasField(f("default_bool")));
+ Assert.IsTrue(message.HasField(f("default_string")));
+ Assert.IsTrue(message.HasField(f("default_bytes")));
- Assert.IsTrue(message.HasField(f("default_nested_enum" )));
+ Assert.IsTrue(message.HasField(f("default_nested_enum")));
Assert.IsTrue(message.HasField(f("default_foreign_enum")));
- Assert.IsTrue(message.HasField(f("default_import_enum" )));
+ Assert.IsTrue(message.HasField(f("default_import_enum")));
Assert.IsTrue(message.HasField(f("default_string_piece")));
Assert.IsTrue(message.HasField(f("default_cord")));
- Assert.AreEqual(401 , message[f("default_int32" )]);
- Assert.AreEqual(402L , message[f("default_int64" )]);
- Assert.AreEqual(403U , message[f("default_uint32" )]);
- Assert.AreEqual(404UL, message[f("default_uint64" )]);
- Assert.AreEqual(405 , message[f("default_sint32" )]);
- Assert.AreEqual(406L , message[f("default_sint64" )]);
- Assert.AreEqual(407U , message[f("default_fixed32" )]);
- Assert.AreEqual(408UL, message[f("default_fixed64" )]);
- Assert.AreEqual(409 , message[f("default_sfixed32")]);
- Assert.AreEqual(410L , message[f("default_sfixed64")]);
- Assert.AreEqual(411F , message[f("default_float" )]);
- Assert.AreEqual(412D , message[f("default_double" )]);
- Assert.AreEqual(false, message[f("default_bool" )]);
- Assert.AreEqual("415", message[f("default_string" )]);
+ Assert.AreEqual(401, message[f("default_int32")]);
+ Assert.AreEqual(402L, message[f("default_int64")]);
+ Assert.AreEqual(403U, message[f("default_uint32")]);
+ Assert.AreEqual(404UL, message[f("default_uint64")]);
+ Assert.AreEqual(405, message[f("default_sint32")]);
+ Assert.AreEqual(406L, message[f("default_sint64")]);
+ Assert.AreEqual(407U, message[f("default_fixed32")]);
+ Assert.AreEqual(408UL, message[f("default_fixed64")]);
+ Assert.AreEqual(409, message[f("default_sfixed32")]);
+ Assert.AreEqual(410L, message[f("default_sfixed64")]);
+ Assert.AreEqual(411F, message[f("default_float")]);
+ Assert.AreEqual(412D, message[f("default_double")]);
+ Assert.AreEqual(false, message[f("default_bool")]);
+ Assert.AreEqual("415", message[f("default_string")]);
Assert.AreEqual(TestUtil.ToBytes("416"), message[f("default_bytes")]);
- Assert.AreEqual( nestedFoo, message[f("default_nested_enum" )]);
+ Assert.AreEqual(nestedFoo, message[f("default_nested_enum")]);
Assert.AreEqual(foreignFoo, message[f("default_foreign_enum")]);
- Assert.AreEqual( importFoo, message[f("default_import_enum" )]);
+ Assert.AreEqual(importFoo, message[f("default_import_enum")]);
Assert.AreEqual("424", message[f("default_string_piece")]);
Assert.AreEqual("425", message[f("default_cord")]);
@@ -577,49 +587,49 @@ namespace Google.ProtocolBuffers {
///
public void AssertClearViaReflection(IMessage message) {
// has_blah() should initially be false for all optional fields.
- Assert.IsFalse(message.HasField(f("optional_int32" )));
- Assert.IsFalse(message.HasField(f("optional_int64" )));
- Assert.IsFalse(message.HasField(f("optional_uint32" )));
- Assert.IsFalse(message.HasField(f("optional_uint64" )));
- Assert.IsFalse(message.HasField(f("optional_sint32" )));
- Assert.IsFalse(message.HasField(f("optional_sint64" )));
- Assert.IsFalse(message.HasField(f("optional_fixed32" )));
- Assert.IsFalse(message.HasField(f("optional_fixed64" )));
+ Assert.IsFalse(message.HasField(f("optional_int32")));
+ Assert.IsFalse(message.HasField(f("optional_int64")));
+ Assert.IsFalse(message.HasField(f("optional_uint32")));
+ Assert.IsFalse(message.HasField(f("optional_uint64")));
+ Assert.IsFalse(message.HasField(f("optional_sint32")));
+ Assert.IsFalse(message.HasField(f("optional_sint64")));
+ Assert.IsFalse(message.HasField(f("optional_fixed32")));
+ Assert.IsFalse(message.HasField(f("optional_fixed64")));
Assert.IsFalse(message.HasField(f("optional_sfixed32")));
Assert.IsFalse(message.HasField(f("optional_sfixed64")));
- Assert.IsFalse(message.HasField(f("optional_float" )));
- Assert.IsFalse(message.HasField(f("optional_double" )));
- Assert.IsFalse(message.HasField(f("optional_bool" )));
- Assert.IsFalse(message.HasField(f("optional_string" )));
- Assert.IsFalse(message.HasField(f("optional_bytes" )));
-
- Assert.IsFalse(message.HasField(f("optionalgroup" )));
- Assert.IsFalse(message.HasField(f("optional_nested_message" )));
+ Assert.IsFalse(message.HasField(f("optional_float")));
+ Assert.IsFalse(message.HasField(f("optional_double")));
+ Assert.IsFalse(message.HasField(f("optional_bool")));
+ Assert.IsFalse(message.HasField(f("optional_string")));
+ Assert.IsFalse(message.HasField(f("optional_bytes")));
+
+ Assert.IsFalse(message.HasField(f("optionalgroup")));
+ Assert.IsFalse(message.HasField(f("optional_nested_message")));
Assert.IsFalse(message.HasField(f("optional_foreign_message")));
- Assert.IsFalse(message.HasField(f("optional_import_message" )));
+ Assert.IsFalse(message.HasField(f("optional_import_message")));
- Assert.IsFalse(message.HasField(f("optional_nested_enum" )));
+ Assert.IsFalse(message.HasField(f("optional_nested_enum")));
Assert.IsFalse(message.HasField(f("optional_foreign_enum")));
- Assert.IsFalse(message.HasField(f("optional_import_enum" )));
+ Assert.IsFalse(message.HasField(f("optional_import_enum")));
Assert.IsFalse(message.HasField(f("optional_string_piece")));
Assert.IsFalse(message.HasField(f("optional_cord")));
// Optional fields without defaults are set to zero or something like it.
- Assert.AreEqual(0 , message[f("optional_int32" )]);
- Assert.AreEqual(0L , message[f("optional_int64" )]);
- Assert.AreEqual(0U , message[f("optional_uint32" )]);
- Assert.AreEqual(0UL , message[f("optional_uint64" )]);
- Assert.AreEqual(0 , message[f("optional_sint32" )]);
- Assert.AreEqual(0L , message[f("optional_sint64" )]);
- Assert.AreEqual(0U , message[f("optional_fixed32" )]);
- Assert.AreEqual(0UL , message[f("optional_fixed64" )]);
- Assert.AreEqual(0 , message[f("optional_sfixed32")]);
- Assert.AreEqual(0L , message[f("optional_sfixed64")]);
- Assert.AreEqual(0F , message[f("optional_float" )]);
- Assert.AreEqual(0D , message[f("optional_double" )]);
- Assert.AreEqual(false, message[f("optional_bool" )]);
- Assert.AreEqual("" , message[f("optional_string" )]);
+ Assert.AreEqual(0, message[f("optional_int32")]);
+ Assert.AreEqual(0L, message[f("optional_int64")]);
+ Assert.AreEqual(0U, message[f("optional_uint32")]);
+ Assert.AreEqual(0UL, message[f("optional_uint64")]);
+ Assert.AreEqual(0, message[f("optional_sint32")]);
+ Assert.AreEqual(0L, message[f("optional_sint64")]);
+ Assert.AreEqual(0U, message[f("optional_fixed32")]);
+ Assert.AreEqual(0UL, message[f("optional_fixed64")]);
+ Assert.AreEqual(0, message[f("optional_sfixed32")]);
+ Assert.AreEqual(0L, message[f("optional_sfixed64")]);
+ Assert.AreEqual(0F, message[f("optional_float")]);
+ Assert.AreEqual(0D, message[f("optional_double")]);
+ Assert.AreEqual(false, message[f("optional_bool")]);
+ Assert.AreEqual("", message[f("optional_string")]);
Assert.AreEqual(ByteString.Empty, message[f("optional_bytes")]);
// Embedded messages should also be clear.
@@ -631,91 +641,91 @@ namespace Google.ProtocolBuffers {
Assert.IsFalse(((IMessage)message[f("optional_import_message")])
.HasField(importD));
- Assert.AreEqual(0,((IMessage)message[f("optionalgroup")])[groupA]);
- Assert.AreEqual(0,((IMessage)message[f("optional_nested_message")])[nestedB]);
- Assert.AreEqual(0,((IMessage)message[f("optional_foreign_message")])[foreignC]);
- Assert.AreEqual(0,((IMessage)message[f("optional_import_message")])[importD]);
+ Assert.AreEqual(0, ((IMessage)message[f("optionalgroup")])[groupA]);
+ Assert.AreEqual(0, ((IMessage)message[f("optional_nested_message")])[nestedB]);
+ Assert.AreEqual(0, ((IMessage)message[f("optional_foreign_message")])[foreignC]);
+ Assert.AreEqual(0, ((IMessage)message[f("optional_import_message")])[importD]);
// Enums without defaults are set to the first value in the enum.
- Assert.AreEqual( nestedFoo, message[f("optional_nested_enum" )]);
+ Assert.AreEqual(nestedFoo, message[f("optional_nested_enum")]);
Assert.AreEqual(foreignFoo, message[f("optional_foreign_enum")]);
- Assert.AreEqual( importFoo, message[f("optional_import_enum" )]);
+ Assert.AreEqual(importFoo, message[f("optional_import_enum")]);
Assert.AreEqual("", message[f("optional_string_piece")]);
Assert.AreEqual("", message[f("optional_cord")]);
// Repeated fields are empty.
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int32" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int64" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint32" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint64" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint32" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint64" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int32")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int64")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint32")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint64")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint32")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint64")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed32")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed64")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_float" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_double" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bool" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bytes" )));
-
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeatedgroup" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_float")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_double")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bool")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bytes")));
+
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeatedgroup")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_message")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_message" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
- Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_message")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_enum")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum")));
+ Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_enum")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string_piece")));
Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_cord")));
// has_blah() should also be false for all default fields.
- Assert.IsFalse(message.HasField(f("default_int32" )));
- Assert.IsFalse(message.HasField(f("default_int64" )));
- Assert.IsFalse(message.HasField(f("default_uint32" )));
- Assert.IsFalse(message.HasField(f("default_uint64" )));
- Assert.IsFalse(message.HasField(f("default_sint32" )));
- Assert.IsFalse(message.HasField(f("default_sint64" )));
- Assert.IsFalse(message.HasField(f("default_fixed32" )));
- Assert.IsFalse(message.HasField(f("default_fixed64" )));
+ Assert.IsFalse(message.HasField(f("default_int32")));
+ Assert.IsFalse(message.HasField(f("default_int64")));
+ Assert.IsFalse(message.HasField(f("default_uint32")));
+ Assert.IsFalse(message.HasField(f("default_uint64")));
+ Assert.IsFalse(message.HasField(f("default_sint32")));
+ Assert.IsFalse(message.HasField(f("default_sint64")));
+ Assert.IsFalse(message.HasField(f("default_fixed32")));
+ Assert.IsFalse(message.HasField(f("default_fixed64")));
Assert.IsFalse(message.HasField(f("default_sfixed32")));
Assert.IsFalse(message.HasField(f("default_sfixed64")));
- Assert.IsFalse(message.HasField(f("default_float" )));
- Assert.IsFalse(message.HasField(f("default_double" )));
- Assert.IsFalse(message.HasField(f("default_bool" )));
- Assert.IsFalse(message.HasField(f("default_string" )));
- Assert.IsFalse(message.HasField(f("default_bytes" )));
+ Assert.IsFalse(message.HasField(f("default_float")));
+ Assert.IsFalse(message.HasField(f("default_double")));
+ Assert.IsFalse(message.HasField(f("default_bool")));
+ Assert.IsFalse(message.HasField(f("default_string")));
+ Assert.IsFalse(message.HasField(f("default_bytes")));
- Assert.IsFalse(message.HasField(f("default_nested_enum" )));
+ Assert.IsFalse(message.HasField(f("default_nested_enum")));
Assert.IsFalse(message.HasField(f("default_foreign_enum")));
- Assert.IsFalse(message.HasField(f("default_import_enum" )));
+ Assert.IsFalse(message.HasField(f("default_import_enum")));
- Assert.IsFalse(message.HasField(f("default_string_piece" )));
- Assert.IsFalse(message.HasField(f("default_cord" )));
+ Assert.IsFalse(message.HasField(f("default_string_piece")));
+ Assert.IsFalse(message.HasField(f("default_cord")));
// Fields with defaults have their default values (duh).
- Assert.AreEqual( 41 , message[f("default_int32" )]);
- Assert.AreEqual( 42L , message[f("default_int64" )]);
- Assert.AreEqual( 43U , message[f("default_uint32" )]);
- Assert.AreEqual( 44UL , message[f("default_uint64" )]);
- Assert.AreEqual(-45 , message[f("default_sint32" )]);
- Assert.AreEqual( 46L , message[f("default_sint64" )]);
- Assert.AreEqual( 47U , message[f("default_fixed32" )]);
- Assert.AreEqual( 48UL , message[f("default_fixed64" )]);
- Assert.AreEqual( 49 , message[f("default_sfixed32")]);
- Assert.AreEqual(-50L , message[f("default_sfixed64")]);
- Assert.AreEqual( 51.5F , message[f("default_float" )]);
- Assert.AreEqual( 52e3D , message[f("default_double" )]);
- Assert.AreEqual(true , message[f("default_bool" )]);
- Assert.AreEqual("hello", message[f("default_string" )]);
+ Assert.AreEqual(41, message[f("default_int32")]);
+ Assert.AreEqual(42L, message[f("default_int64")]);
+ Assert.AreEqual(43U, message[f("default_uint32")]);
+ Assert.AreEqual(44UL, message[f("default_uint64")]);
+ Assert.AreEqual(-45, message[f("default_sint32")]);
+ Assert.AreEqual(46L, message[f("default_sint64")]);
+ Assert.AreEqual(47U, message[f("default_fixed32")]);
+ Assert.AreEqual(48UL, message[f("default_fixed64")]);
+ Assert.AreEqual(49, message[f("default_sfixed32")]);
+ Assert.AreEqual(-50L, message[f("default_sfixed64")]);
+ Assert.AreEqual(51.5F, message[f("default_float")]);
+ Assert.AreEqual(52e3D, message[f("default_double")]);
+ Assert.AreEqual(true, message[f("default_bool")]);
+ Assert.AreEqual("hello", message[f("default_string")]);
Assert.AreEqual(TestUtil.ToBytes("world"), message[f("default_bytes")]);
- Assert.AreEqual( nestedBar, message[f("default_nested_enum" )]);
+ Assert.AreEqual(nestedBar, message[f("default_nested_enum")]);
Assert.AreEqual(foreignBar, message[f("default_foreign_enum")]);
- Assert.AreEqual( importBar, message[f("default_import_enum" )]);
+ Assert.AreEqual(importBar, message[f("default_import_enum")]);
Assert.AreEqual("abc", message[f("default_string_piece")]);
Assert.AreEqual("123", message[f("default_cord")]);
@@ -727,85 +737,85 @@ namespace Google.ProtocolBuffers {
// ModifyRepeatedFields only sets the second repeated element of each
// field. In addition to verifying this, we also verify that the first
// element and size were *not* modified.
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" )));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64")));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" )));
-
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" )));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes")));
+
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message")));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" )));
- Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" )));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece")));
Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord")));
- Assert.AreEqual(201 , message[f("repeated_int32" ), 0]);
- Assert.AreEqual(202L , message[f("repeated_int64" ), 0]);
- Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]);
- Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]);
- Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]);
- Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]);
- Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]);
- Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]);
- Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]);
- Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]);
- Assert.AreEqual(211F , message[f("repeated_float" ), 0]);
- Assert.AreEqual(212D , message[f("repeated_double" ), 0]);
- Assert.AreEqual(true , message[f("repeated_bool" ), 0]);
- Assert.AreEqual("215", message[f("repeated_string" ), 0]);
+ Assert.AreEqual(201, message[f("repeated_int32"), 0]);
+ Assert.AreEqual(202L, message[f("repeated_int64"), 0]);
+ Assert.AreEqual(203U, message[f("repeated_uint32"), 0]);
+ Assert.AreEqual(204UL, message[f("repeated_uint64"), 0]);
+ Assert.AreEqual(205, message[f("repeated_sint32"), 0]);
+ Assert.AreEqual(206L, message[f("repeated_sint64"), 0]);
+ Assert.AreEqual(207U, message[f("repeated_fixed32"), 0]);
+ Assert.AreEqual(208UL, message[f("repeated_fixed64"), 0]);
+ Assert.AreEqual(209, message[f("repeated_sfixed32"), 0]);
+ Assert.AreEqual(210L, message[f("repeated_sfixed64"), 0]);
+ Assert.AreEqual(211F, message[f("repeated_float"), 0]);
+ Assert.AreEqual(212D, message[f("repeated_double"), 0]);
+ Assert.AreEqual(true, message[f("repeated_bool"), 0]);
+ Assert.AreEqual("215", message[f("repeated_string"), 0]);
Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]);
- Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]);
- Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]);
- Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]);
- Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]);
+ Assert.AreEqual(217, ((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]);
+ Assert.AreEqual(218, ((IMessage)message[f("repeated_nested_message"), 0])[nestedB]);
+ Assert.AreEqual(219, ((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]);
+ Assert.AreEqual(220, ((IMessage)message[f("repeated_import_message"), 0])[importD]);
- Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]);
- Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]);
- Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]);
+ Assert.AreEqual(nestedBar, message[f("repeated_nested_enum"), 0]);
+ Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"), 0]);
+ Assert.AreEqual(importBar, message[f("repeated_import_enum"), 0]);
Assert.AreEqual("224", message[f("repeated_string_piece"), 0]);
Assert.AreEqual("225", message[f("repeated_cord"), 0]);
- Assert.AreEqual(501 , message[f("repeated_int32" ), 1]);
- Assert.AreEqual(502L , message[f("repeated_int64" ), 1]);
- Assert.AreEqual(503U , message[f("repeated_uint32" ), 1]);
- Assert.AreEqual(504UL, message[f("repeated_uint64" ), 1]);
- Assert.AreEqual(505 , message[f("repeated_sint32" ), 1]);
- Assert.AreEqual(506L , message[f("repeated_sint64" ), 1]);
- Assert.AreEqual(507U , message[f("repeated_fixed32" ), 1]);
- Assert.AreEqual(508UL, message[f("repeated_fixed64" ), 1]);
- Assert.AreEqual(509 , message[f("repeated_sfixed32"), 1]);
- Assert.AreEqual(510L , message[f("repeated_sfixed64"), 1]);
- Assert.AreEqual(511F , message[f("repeated_float" ), 1]);
- Assert.AreEqual(512D , message[f("repeated_double" ), 1]);
- Assert.AreEqual(true , message[f("repeated_bool" ), 1]);
- Assert.AreEqual("515", message[f("repeated_string" ), 1]);
+ Assert.AreEqual(501, message[f("repeated_int32"), 1]);
+ Assert.AreEqual(502L, message[f("repeated_int64"), 1]);
+ Assert.AreEqual(503U, message[f("repeated_uint32"), 1]);
+ Assert.AreEqual(504UL, message[f("repeated_uint64"), 1]);
+ Assert.AreEqual(505, message[f("repeated_sint32"), 1]);
+ Assert.AreEqual(506L, message[f("repeated_sint64"), 1]);
+ Assert.AreEqual(507U, message[f("repeated_fixed32"), 1]);
+ Assert.AreEqual(508UL, message[f("repeated_fixed64"), 1]);
+ Assert.AreEqual(509, message[f("repeated_sfixed32"), 1]);
+ Assert.AreEqual(510L, message[f("repeated_sfixed64"), 1]);
+ Assert.AreEqual(511F, message[f("repeated_float"), 1]);
+ Assert.AreEqual(512D, message[f("repeated_double"), 1]);
+ Assert.AreEqual(true, message[f("repeated_bool"), 1]);
+ Assert.AreEqual("515", message[f("repeated_string"), 1]);
Assert.AreEqual(TestUtil.ToBytes("516"), message[f("repeated_bytes"), 1]);
- Assert.AreEqual(517,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]);
- Assert.AreEqual(518,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]);
- Assert.AreEqual(519,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]);
- Assert.AreEqual(520,((IMessage)message[f("repeated_import_message"), 1])[importD]);
+ Assert.AreEqual(517, ((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]);
+ Assert.AreEqual(518, ((IMessage)message[f("repeated_nested_message"), 1])[nestedB]);
+ Assert.AreEqual(519, ((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]);
+ Assert.AreEqual(520, ((IMessage)message[f("repeated_import_message"), 1])[importD]);
- Assert.AreEqual( nestedFoo, message[f("repeated_nested_enum" ),1]);
- Assert.AreEqual(foreignFoo, message[f("repeated_foreign_enum"),1]);
- Assert.AreEqual( importFoo, message[f("repeated_import_enum" ),1]);
+ Assert.AreEqual(nestedFoo, message[f("repeated_nested_enum"), 1]);
+ Assert.AreEqual(foreignFoo, message[f("repeated_foreign_enum"), 1]);
+ Assert.AreEqual(importFoo, message[f("repeated_import_enum"), 1]);
Assert.AreEqual("524", message[f("repeated_string_piece"), 1]);
Assert.AreEqual("525", message[f("repeated_cord"), 1]);
@@ -842,5 +852,82 @@ namespace Google.ProtocolBuffers {
new TestAllTypes.Types.NestedMessage.Builder { Bb = 218 }.Build());
TestUtil.AssertArgumentNullException(() => builder.SetRepeatedField(f("repeated_nested_message"), 0, null));
}
+
+ public void SetPackedFieldsViaReflection(IBuilder message) {
+ message.WeakAddRepeatedField(f("packed_int32"), 601);
+ message.WeakAddRepeatedField(f("packed_int64"), 602L);
+ message.WeakAddRepeatedField(f("packed_uint32"), 603U);
+ message.WeakAddRepeatedField(f("packed_uint64"), 604UL);
+ message.WeakAddRepeatedField(f("packed_sint32"), 605);
+ message.WeakAddRepeatedField(f("packed_sint64"), 606L);
+ message.WeakAddRepeatedField(f("packed_fixed32"), 607U);
+ message.WeakAddRepeatedField(f("packed_fixed64"), 608UL);
+ message.WeakAddRepeatedField(f("packed_sfixed32"), 609);
+ message.WeakAddRepeatedField(f("packed_sfixed64"), 610L);
+ message.WeakAddRepeatedField(f("packed_float"), 611F);
+ message.WeakAddRepeatedField(f("packed_double"), 612D);
+ message.WeakAddRepeatedField(f("packed_bool"), true);
+ message.WeakAddRepeatedField(f("packed_enum"), foreignBar);
+ // Add a second one of each field.
+ message.WeakAddRepeatedField(f("packed_int32"), 701);
+ message.WeakAddRepeatedField(f("packed_int64"), 702L);
+ message.WeakAddRepeatedField(f("packed_uint32"), 703U);
+ message.WeakAddRepeatedField(f("packed_uint64"), 704UL);
+ message.WeakAddRepeatedField(f("packed_sint32"), 705);
+ message.WeakAddRepeatedField(f("packed_sint64"), 706L);
+ message.WeakAddRepeatedField(f("packed_fixed32"), 707U);
+ message.WeakAddRepeatedField(f("packed_fixed64"), 708UL);
+ message.WeakAddRepeatedField(f("packed_sfixed32"), 709);
+ message.WeakAddRepeatedField(f("packed_sfixed64"), 710L);
+ message.WeakAddRepeatedField(f("packed_float"), 711F);
+ message.WeakAddRepeatedField(f("packed_double"), 712D);
+ message.WeakAddRepeatedField(f("packed_bool"), false);
+ message.WeakAddRepeatedField(f("packed_enum"), foreignBaz);
+ }
+
+ public void AssertPackedFieldsSetViaReflection(IMessage message) {
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_int32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_int64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_uint32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_uint64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sint32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sint64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_fixed32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_fixed64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sfixed32")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_sfixed64")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_float")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_double")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_bool")));
+ Assert.AreEqual(2, message.GetRepeatedFieldCount(f("packed_enum")));
+ Assert.AreEqual(601, message[f("packed_int32"), 0]);
+ Assert.AreEqual(602L, message[f("packed_int64"), 0]);
+ Assert.AreEqual(603, message[f("packed_uint32"), 0]);
+ Assert.AreEqual(604L, message[f("packed_uint64"), 0]);
+ Assert.AreEqual(605, message[f("packed_sint32"), 0]);
+ Assert.AreEqual(606L, message[f("packed_sint64"), 0]);
+ Assert.AreEqual(607, message[f("packed_fixed32"), 0]);
+ Assert.AreEqual(608L, message[f("packed_fixed64"), 0]);
+ Assert.AreEqual(609, message[f("packed_sfixed32"), 0]);
+ Assert.AreEqual(610L, message[f("packed_sfixed64"), 0]);
+ Assert.AreEqual(611F, message[f("packed_float"), 0]);
+ Assert.AreEqual(612D, message[f("packed_double"), 0]);
+ Assert.AreEqual(true, message[f("packed_bool"), 0]);
+ Assert.AreEqual(foreignBar, message[f("packed_enum"), 0]);
+ Assert.AreEqual(701, message[f("packed_int32"), 1]);
+ Assert.AreEqual(702L, message[f("packed_int64"), 1]);
+ Assert.AreEqual(703, message[f("packed_uint32"), 1]);
+ Assert.AreEqual(704L, message[f("packed_uint64"), 1]);
+ Assert.AreEqual(705, message[f("packed_sint32"), 1]);
+ Assert.AreEqual(706L, message[f("packed_sint64"), 1]);
+ Assert.AreEqual(707, message[f("packed_fixed32"), 1]);
+ Assert.AreEqual(708L, message[f("packed_fixed64"), 1]);
+ Assert.AreEqual(709, message[f("packed_sfixed32"), 1]);
+ Assert.AreEqual(710L, message[f("packed_sfixed64"), 1]);
+ Assert.AreEqual(711F, message[f("packed_float"), 1]);
+ Assert.AreEqual(712D, message[f("packed_double"), 1]);
+ Assert.AreEqual(false, message[f("packed_bool"), 1]);
+ Assert.AreEqual(foreignBaz, message[f("packed_enum"), 1]);
+ }
}
}
diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs
index df8d79981a..2eaeb05cc6 100644
--- a/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs
+++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs
@@ -17,101 +17,97 @@ namespace Google.ProtocolBuffers.TestProtos {
"Ci1nb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfY3VzdG9tX29wdGlvbnMucHJv" +
"dG8SEXByb3RvYnVmX3VuaXR0ZXN0GiRnb29nbGUvcHJvdG9idWYvY3NoYXJw" +
"X29wdGlvbnMucHJvdG8aIGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlwdG9yLnBy" +
- "b3RvIpoBChxUZXN0TWVzc2FnZVdpdGhDdXN0b21PcHRpb25zEioKBmZpZWxk" +
- "MRgBIAEoCUIaCAHB4MMdLeF1CgIAAADB4MMdLeF1CgIAAAAiPAoGQW5FbnVt" +
- "Eg8KC0FORU5VTV9WQUwxEAESDwoLQU5FTlVNX1ZBTDIQAhoQxfbJHev8///F" +
- "9skd6/z//zoQCADg6cIdyP//////////ASIYChZDdXN0b21PcHRpb25Gb29S" +
- "ZXF1ZXN0IhkKF0N1c3RvbU9wdGlvbkZvb1Jlc3BvbnNlIm0KGkR1bW15TWVz" +
- "c2FnZUNvbnRhaW5pbmdFbnVtIk8KDFRlc3RFbnVtVHlwZRIaChZURVNUX09Q" +
- "VElPTl9FTlVNX1RZUEUxEBYSIwoWVEVTVF9PUFRJT05fRU5VTV9UWVBFMhDp" +
- "//////////8BIiEKH0R1bW15TWVzc2FnZUludmFsaWRBc09wdGlvblR5cGUi" +
- "swEKHEN1c3RvbU9wdGlvbk1pbkludGVnZXJWYWx1ZXM6kgGZ1qgdAAAAAAAA" +
- "AICZ1qgdAAAAAAAAAICtja8dAAAAgK2Nrx0AAACAke6vHQAAAAAAAAAAke6v" +
- "HQAAAAAAAAAAnfWvHQAAAACd9a8dAAAAAPiXsB3///////////8BgMSwHf//" +
- "//8P+PWwHQCAk7IdALC8sh2AgICAgICAgIAB6MayHYCAgID4/////wHQ3rId" +
- "ACK6AQocQ3VzdG9tT3B0aW9uTWF4SW50ZWdlclZhbHVlczqZAZnWqB3/////" +
- "////f5nWqB3/////////f62Nrx3///9/rY2vHf///3+R7q8d//////////+R" +
- "7q8d//////////+d9a8d/////531rx3/////+JewHf7//////////wGAxLAd" +
- "/v///w/49bAd////////////AYCTsh3/////D7C8sh3//////////3/oxrId" +
- "/////wfQ3rIdASKCAQoXQ3VzdG9tT3B0aW9uT3RoZXJWYWx1ZXM6Z4jZoh3p" +
- "//////////8BstmiHQtIZWxsbwBXb3JsZKrcoh0OSGVsbG8sICJXb3JsZCLp" +
- "3KId+1mMQsrA8z/p3KId+1mMQsrA8z/136Md54dFQfXfox3nh0VB6MayHZz/" +
- "/////////wEiSAocU2V0dGluZ1JlYWxzRnJvbVBvc2l0aXZlSW50czoo6dyi" +
- "HQAAAAAAQGNA6dyiHQAAAAAAQGNA9d+jHQAAQEH136MdAABAQSJIChxTZXR0" +
- "aW5nUmVhbHNGcm9tTmVnYXRpdmVJbnRzOijp3KIdAAAAAABAY8Dp3KIdAAAA" +
- "AABAY8D136MdAABAwfXfox0AAEDBIisKEkNvbXBsZXhPcHRpb25UeXBlMRIL" +
- "CgNmb28YASABKAUqCAhkEICAgIACIsECChJDb21wbGV4T3B0aW9uVHlwZTIS" +
- "MgoDYmFyGAEgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlv" +
- "blR5cGUxEgsKA2JhehgCIAEoBRJGCgRmcmVkGAMgASgLMjgucHJvdG9idWZf" +
- "dW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUyLkNvbXBsZXhPcHRpb25UeXBl" +
- "NBqXAQoSQ29tcGxleE9wdGlvblR5cGU0Eg0KBXdhbGRvGAEgASgFMnIKDGNv" +
- "bXBsZXhfb3B0NBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiK" +
- "9dEDIAEoCzI4LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBl" +
- "Mi5Db21wbGV4T3B0aW9uVHlwZTQqCAhkEICAgIACIpwBChJDb21wbGV4T3B0" +
- "aW9uVHlwZTMSCwoDcXV4GAEgASgFElQKEmNvbXBsZXhvcHRpb250eXBlNRgC" +
- "IAEoCjI4LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMy5D" +
- "b21wbGV4T3B0aW9uVHlwZTUaIwoSQ29tcGxleE9wdGlvblR5cGU1Eg0KBXBs" +
- "dWdoGAMgASgFIh8KC0NvbXBsZXhPcHQ2EhAKBXh5enp5GN+/zwMgASgFItAB" +
- "ChVWYXJpb3VzQ29tcGxleE9wdGlvbnM6tgHj3Pwc+P37HBjk3Pwc0qiPHQMI" +
- "sw/63pAdAggJ+t6QHQQTGBYUqv2QHQMQ2weq/ZAdBvjmlx2OBar9kB0FCgMI" +
- "5wWq/ZAdCAoG2IWeHc8Pqv2QHQoKCJL1nR0DCNgPqv2QHQjCrJcdAwjlBar9" +
- "kB0LwqyXHQbYhZ4dzg+q/ZAdDcKslx0IkvWdHQMIyRCq/ZAdBRoDCMECouKV" +
- "HQIIKqLilR0G2IWeHcQCouKVHQiS9Z0dAwjsBio2CgpNZXRob2RPcHQxEhMK" +
- "D01FVEhPRE9QVDFfVkFMMRABEhMKD01FVEhPRE9QVDFfVkFMMhACMo4BChxU" +
- "ZXN0U2VydmljZVdpdGhDdXN0b21PcHRpb25zEmMKA0ZvbxIpLnByb3RvYnVm" +
- "X3VuaXR0ZXN0LkN1c3RvbU9wdGlvbkZvb1JlcXVlc3QaKi5wcm90b2J1Zl91" +
- "bml0dGVzdC5DdXN0b21PcHRpb25Gb29SZXNwb25zZSIF4PqMHgIaCZCyix7T" +
- "24DLSToyCglmaWxlX29wdDESHC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlv" +
- "bnMYjp3YAyABKAQ6OAoMbWVzc2FnZV9vcHQxEh8uZ29vZ2xlLnByb3RvYnVm" +
- "Lk1lc3NhZ2VPcHRpb25zGJyt2AMgASgFOjQKCmZpZWxkX29wdDESHS5nb29n" +
- "bGUucHJvdG9idWYuRmllbGRPcHRpb25zGIi82AMgASgGOjgKCmZpZWxkX29w" +
- "dDISHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGLmh2QMgASgFOgI0" +
- "MjoyCgllbnVtX29wdDESHC5nb29nbGUucHJvdG9idWYuRW51bU9wdGlvbnMY" +
- "6J7ZAyABKA86OAoMc2VydmljZV9vcHQxEh8uZ29vZ2xlLnByb3RvYnVmLlNl" +
- "cnZpY2VPcHRpb25zGKK24QMgASgSOlUKC21ldGhvZF9vcHQxEh4uZ29vZ2xl" +
- "LnByb3RvYnVmLk1ldGhvZE9wdGlvbnMYrM/hAyABKA4yHS5wcm90b2J1Zl91" +
- "bml0dGVzdC5NZXRob2RPcHQxOjQKCGJvb2xfb3B0Eh8uZ29vZ2xlLnByb3Rv" +
- "YnVmLk1lc3NhZ2VPcHRpb25zGOqr1gMgASgIOjUKCWludDMyX29wdBIfLmdv" +
- "b2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjtqNYDIAEoBTo1CglpbnQ2" +
- "NF9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYxqfWAyAB" +
- "KAM6NgoKdWludDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0" +
- "aW9ucxiwotYDIAEoDTo2Cgp1aW50NjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVm" +
- "Lk1lc3NhZ2VPcHRpb25zGN+O1gMgASgEOjYKCnNpbnQzMl9vcHQSHy5nb29n" +
- "bGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYwIjWAyABKBE6NgoKc2ludDY0" +
- "X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxj/gtYDIAEo" +
- "Ejo3CgtmaXhlZDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0" +
- "aW9ucxjT/tUDIAEoBzo3CgtmaXhlZDY0X29wdBIfLmdvb2dsZS5wcm90b2J1" +
- "Zi5NZXNzYWdlT3B0aW9ucxji/dUDIAEoBjo4CgxzZml4ZWQzMl9vcHQSHy5n" +
- "b29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY1fHVAyABKA86OAoMc2Zp" +
- "eGVkNjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGOOK" +
- "1QMgASgQOjUKCWZsb2F0X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdl" +
- "T3B0aW9ucxj+u9QDIAEoAjo2Cgpkb3VibGVfb3B0Eh8uZ29vZ2xlLnByb3Rv" +
- "YnVmLk1lc3NhZ2VPcHRpb25zGM2r1AMgASgBOjYKCnN0cmluZ19vcHQSHy5n" +
- "b29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYxavUAyABKAk6NQoJYnl0" +
- "ZXNfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGJar1AMg" +
- "ASgMOnAKCGVudW1fb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRp" +
- "b25zGJGr1AMgASgOMjoucHJvdG9idWZfdW5pdHRlc3QuRHVtbXlNZXNzYWdl" +
- "Q29udGFpbmluZ0VudW0uVGVzdEVudW1UeXBlOnAKEG1lc3NhZ2VfdHlwZV9v" +
- "cHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYr/LTAyABKAsy" +
- "Mi5wcm90b2J1Zl91bml0dGVzdC5EdW1teU1lc3NhZ2VJbnZhbGlkQXNPcHRp" +
- "b25UeXBlOjYKBHF1dXgSJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0" +
- "aW9uVHlwZTEY2+DTAyABKAU6XgoFY29yZ2USJS5wcm90b2J1Zl91bml0dGVz" +
- "dC5Db21wbGV4T3B0aW9uVHlwZTEY0t7TAyABKAsyJS5wcm90b2J1Zl91bml0" +
- "dGVzdC5Db21wbGV4T3B0aW9uVHlwZTM6OAoGZ3JhdWx0EiUucHJvdG9idWZf" +
- "dW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUyGO/80gMgASgFOl8KBmdhcnBs" +
- "eRIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMhjI9dID" +
- "IAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMTpf" +
- "Cgxjb21wbGV4X29wdDESHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlv" +
- "bnMYpNzSAyABKAsyJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9u" +
- "VHlwZTE6XwoMY29tcGxleF9vcHQyEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3Nh" +
- "Z2VPcHRpb25zGNWP0gMgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxl" +
- "eE9wdGlvblR5cGUyOl8KDGNvbXBsZXhfb3B0MxIfLmdvb2dsZS5wcm90b2J1" +
- "Zi5NZXNzYWdlT3B0aW9ucxjvi9IDIAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0" +
- "LkNvbXBsZXhPcHRpb25UeXBlMzpXCgtjb21wbGV4b3B0NhIfLmdvb2dsZS5w" +
- "cm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjMy88DIAEoCjIeLnByb3RvYnVmX3Vu" +
- "aXR0ZXN0LkNvbXBsZXhPcHQ2Qk/CPkMKIUdvb2dsZS5Qcm90b2NvbEJ1ZmZl" +
- "cnMuVGVzdFByb3RvcxIeVW5pdFRlc3RDdXN0b21PcHRpb25zUHJvdG9GaWxl" +
- "8OjBHeqtwOUk"),
+ "b3RvIoYBChxUZXN0TWVzc2FnZVdpdGhDdXN0b21PcHRpb25zEh4KBmZpZWxk" +
+ "MRgBIAEoCUIOCAHB4MMdLeF1CgIAAAAiNAoGQW5FbnVtEg8KC0FORU5VTV9W" +
+ "QUwxEAESDwoLQU5FTlVNX1ZBTDIQAhoIxfbJHev8//86EAgA4OnCHcj/////" +
+ "/////wEiGAoWQ3VzdG9tT3B0aW9uRm9vUmVxdWVzdCIZChdDdXN0b21PcHRp" +
+ "b25Gb29SZXNwb25zZSJtChpEdW1teU1lc3NhZ2VDb250YWluaW5nRW51bSJP" +
+ "CgxUZXN0RW51bVR5cGUSGgoWVEVTVF9PUFRJT05fRU5VTV9UWVBFMRAWEiMK" +
+ "FlRFU1RfT1BUSU9OX0VOVU1fVFlQRTIQ6f//////////ASIhCh9EdW1teU1l" +
+ "c3NhZ2VJbnZhbGlkQXNPcHRpb25UeXBlIooBChxDdXN0b21PcHRpb25NaW5J" +
+ "bnRlZ2VyVmFsdWVzOmqZ1qgdAAAAAAAAAICtja8dAAAAgJHurx0AAAAAAAAA" +
+ "AJ31rx0AAAAA+JewHf///////////wGAxLAd/////w/49bAdAICTsh0AsLyy" +
+ "HYCAgICAgICAgAHoxrIdgICAgPj/////AdDesh0AIpEBChxDdXN0b21PcHRp" +
+ "b25NYXhJbnRlZ2VyVmFsdWVzOnGZ1qgd/////////3+tja8d////f5Hurx3/" +
+ "/////////531rx3/////+JewHf7//////////wGAxLAd/v///w/49bAd////" +
+ "////////AYCTsh3/////D7C8sh3//////////3/oxrId/////wfQ3rIdASJu" +
+ "ChdDdXN0b21PcHRpb25PdGhlclZhbHVlczpTiNmiHen//////////wGy2aId" +
+ "C0hlbGxvAFdvcmxkqtyiHQ5IZWxsbywgIldvcmxkIuncoh37WYxCysDzP/Xf" +
+ "ox3nh0VB6MayHZz//////////wEiNAocU2V0dGluZ1JlYWxzRnJvbVBvc2l0" +
+ "aXZlSW50czoU6dyiHQAAAAAAQGNA9d+jHQAAQEEiNAocU2V0dGluZ1JlYWxz" +
+ "RnJvbU5lZ2F0aXZlSW50czoU6dyiHQAAAAAAQGPA9d+jHQAAQMEiKwoSQ29t" +
+ "cGxleE9wdGlvblR5cGUxEgsKA2ZvbxgBIAEoBSoICGQQgICAgAIiwQIKEkNv" +
+ "bXBsZXhPcHRpb25UeXBlMhIyCgNiYXIYASABKAsyJS5wcm90b2J1Zl91bml0" +
+ "dGVzdC5Db21wbGV4T3B0aW9uVHlwZTESCwoDYmF6GAIgASgFEkYKBGZyZWQY" +
+ "AyABKAsyOC5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlwZTIu" +
+ "Q29tcGxleE9wdGlvblR5cGU0GpcBChJDb21wbGV4T3B0aW9uVHlwZTQSDQoF" +
+ "d2FsZG8YASABKAUycgoMY29tcGxleF9vcHQ0Eh8uZ29vZ2xlLnByb3RvYnVm" +
+ "Lk1lc3NhZ2VPcHRpb25zGIr10QMgASgLMjgucHJvdG9idWZfdW5pdHRlc3Qu" +
+ "Q29tcGxleE9wdGlvblR5cGUyLkNvbXBsZXhPcHRpb25UeXBlNCoICGQQgICA" +
+ "gAIinAEKEkNvbXBsZXhPcHRpb25UeXBlMxILCgNxdXgYASABKAUSVAoSY29t" +
+ "cGxleG9wdGlvbnR5cGU1GAIgASgKMjgucHJvdG9idWZfdW5pdHRlc3QuQ29t" +
+ "cGxleE9wdGlvblR5cGUzLkNvbXBsZXhPcHRpb25UeXBlNRojChJDb21wbGV4" +
+ "T3B0aW9uVHlwZTUSDQoFcGx1Z2gYAyABKAUiHwoLQ29tcGxleE9wdDYSEAoF" +
+ "eHl6enkY37/PAyABKAUi0AEKFVZhcmlvdXNDb21wbGV4T3B0aW9uczq2AePc" +
+ "/Bz4/fscGOTc/BzSqI8dAwizD/rekB0CCAn63pAdBBMYFhSq/ZAdAxDbB6r9" +
+ "kB0G+OaXHY4Fqv2QHQUKAwjnBar9kB0ICgbYhZ4dzw+q/ZAdCgoIkvWdHQMI" +
+ "2A+q/ZAdCMKslx0DCOUFqv2QHQvCrJcdBtiFnh3OD6r9kB0NwqyXHQiS9Z0d" +
+ "AwjJEKr9kB0FGgMIwQKi4pUdAggqouKVHQbYhZ4dxAKi4pUdCJL1nR0DCOwG" +
+ "KjYKCk1ldGhvZE9wdDESEwoPTUVUSE9ET1BUMV9WQUwxEAESEwoPTUVUSE9E" +
+ "T1BUMV9WQUwyEAIyjgEKHFRlc3RTZXJ2aWNlV2l0aEN1c3RvbU9wdGlvbnMS" +
+ "YwoDRm9vEikucHJvdG9idWZfdW5pdHRlc3QuQ3VzdG9tT3B0aW9uRm9vUmVx" +
+ "dWVzdBoqLnByb3RvYnVmX3VuaXR0ZXN0LkN1c3RvbU9wdGlvbkZvb1Jlc3Bv" +
+ "bnNlIgXg+oweAhoJkLKLHtPbgMtJOjIKCWZpbGVfb3B0MRIcLmdvb2dsZS5w" +
+ "cm90b2J1Zi5GaWxlT3B0aW9ucxiOndgDIAEoBDo4CgxtZXNzYWdlX29wdDES" +
+ "Hy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYnK3YAyABKAU6NAoK" +
+ "ZmllbGRfb3B0MRIdLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlvbnMYiLzY" +
+ "AyABKAY6OAoKZmllbGRfb3B0MhIdLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9w" +
+ "dGlvbnMYuaHZAyABKAU6AjQyOjIKCWVudW1fb3B0MRIcLmdvb2dsZS5wcm90" +
+ "b2J1Zi5FbnVtT3B0aW9ucxjontkDIAEoDzo4CgxzZXJ2aWNlX29wdDESHy5n" +
+ "b29nbGUucHJvdG9idWYuU2VydmljZU9wdGlvbnMYorbhAyABKBI6VQoLbWV0" +
+ "aG9kX29wdDESHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucxisz+ED" +
+ "IAEoDjIdLnByb3RvYnVmX3VuaXR0ZXN0Lk1ldGhvZE9wdDE6NAoIYm9vbF9v" +
+ "cHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY6qvWAyABKAg6" +
+ "NQoJaW50MzJfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25z" +
+ "GO2o1gMgASgFOjUKCWludDY0X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNz" +
+ "YWdlT3B0aW9ucxjGp9YDIAEoAzo2Cgp1aW50MzJfb3B0Eh8uZ29vZ2xlLnBy" +
+ "b3RvYnVmLk1lc3NhZ2VPcHRpb25zGLCi1gMgASgNOjYKCnVpbnQ2NF9vcHQS" +
+ "Hy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY347WAyABKAQ6NgoK" +
+ "c2ludDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjA" +
+ "iNYDIAEoETo2CgpzaW50NjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3Nh" +
+ "Z2VPcHRpb25zGP+C1gMgASgSOjcKC2ZpeGVkMzJfb3B0Eh8uZ29vZ2xlLnBy" +
+ "b3RvYnVmLk1lc3NhZ2VPcHRpb25zGNP+1QMgASgHOjcKC2ZpeGVkNjRfb3B0" +
+ "Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGOL91QMgASgGOjgK" +
+ "DHNmaXhlZDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9u" +
+ "cxjV8dUDIAEoDzo4CgxzZml4ZWQ2NF9vcHQSHy5nb29nbGUucHJvdG9idWYu" +
+ "TWVzc2FnZU9wdGlvbnMY44rVAyABKBA6NQoJZmxvYXRfb3B0Eh8uZ29vZ2xl" +
+ "LnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGP671AMgASgCOjYKCmRvdWJsZV9v" +
+ "cHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYzavUAyABKAE6" +
+ "NgoKc3RyaW5nX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9u" +
+ "cxjFq9QDIAEoCTo1CglieXRlc19vcHQSHy5nb29nbGUucHJvdG9idWYuTWVz" +
+ "c2FnZU9wdGlvbnMYlqvUAyABKAw6cAoIZW51bV9vcHQSHy5nb29nbGUucHJv" +
+ "dG9idWYuTWVzc2FnZU9wdGlvbnMYkavUAyABKA4yOi5wcm90b2J1Zl91bml0" +
+ "dGVzdC5EdW1teU1lc3NhZ2VDb250YWluaW5nRW51bS5UZXN0RW51bVR5cGU6" +
+ "cAoQbWVzc2FnZV90eXBlX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdl" +
+ "T3B0aW9ucxiv8tMDIAEoCzIyLnByb3RvYnVmX3VuaXR0ZXN0LkR1bW15TWVz" +
+ "c2FnZUludmFsaWRBc09wdGlvblR5cGU6NgoEcXV1eBIlLnByb3RvYnVmX3Vu" +
+ "aXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMRjb4NMDIAEoBTpeCgVjb3JnZRIl" +
+ "LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMRjS3tMDIAEo" +
+ "CzIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMzo4CgZn" +
+ "cmF1bHQSJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlwZTIY" +
+ "7/zSAyABKAU6XwoGZ2FycGx5EiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxl" +
+ "eE9wdGlvblR5cGUyGMj10gMgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29t" +
+ "cGxleE9wdGlvblR5cGUxOl8KDGNvbXBsZXhfb3B0MRIfLmdvb2dsZS5wcm90" +
+ "b2J1Zi5NZXNzYWdlT3B0aW9ucxik3NIDIAEoCzIlLnByb3RvYnVmX3VuaXR0" +
+ "ZXN0LkNvbXBsZXhPcHRpb25UeXBlMTpfCgxjb21wbGV4X29wdDISHy5nb29n" +
+ "bGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY1Y/SAyABKAsyJS5wcm90b2J1" +
+ "Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlwZTI6XwoMY29tcGxleF9vcHQz" +
+ "Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGO+L0gMgASgLMiUu" +
+ "cHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUzOlcKC2NvbXBs" +
+ "ZXhvcHQ2Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGMzLzwMg" +
+ "ASgKMh4ucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdDZCT8I+QwohR29v" +
+ "Z2xlLlByb3RvY29sQnVmZmVycy5UZXN0UHJvdG9zEh5Vbml0VGVzdEN1c3Rv" +
+ "bU9wdGlvbnNQcm90b0ZpbGXw6MEd6q3A5SQ="),
new pbd::FileDescriptor[] {
global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor,
global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor,
diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs
index 3d3e699c9e..f8c2a7ccea 100644
--- a/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs
+++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs
@@ -139,153 +139,189 @@ namespace Google.ProtocolBuffers.TestProtos {
"Z2VfdWludDMyGAIgASgNOgo0Mjk0OTY3Mjk1EioKDGxhcmdlX3VpbnQ2NBgD" +
"IAEoBDoUMTg0NDY3NDQwNzM3MDk1NTE2MTUSIAoLc21hbGxfaW50MzIYBCAB" +
"KAU6Cy0yMTQ3NDgzNjQ3EikKC3NtYWxsX2ludDY0GAUgASgDOhQtOTIyMzM3" +
- "MjAzNjg1NDc3NTgwNxIYCgt1dGY4X3N0cmluZxgGIAEoCToD4Yi0IgwKCkZv" +
- "b1JlcXVlc3QiDQoLRm9vUmVzcG9uc2UiDAoKQmFyUmVxdWVzdCINCgtCYXJS" +
- "ZXNwb25zZSpACgtGb3JlaWduRW51bRIPCgtGT1JFSUdOX0ZPTxAEEg8KC0ZP" +
- "UkVJR05fQkFSEAUSDwoLRk9SRUlHTl9CQVoQBipHChRUZXN0RW51bVdpdGhE" +
- "dXBWYWx1ZRIICgRGT08xEAESCAoEQkFSMRACEgcKA0JBWhADEggKBEZPTzIQ" +
- "ARIICgRCQVIyEAIqiQEKDlRlc3RTcGFyc2VFbnVtEgwKCFNQQVJTRV9BEHsS" +
- "DgoIU1BBUlNFX0IQpucDEg8KCFNQQVJTRV9DELKxgAYSFQoIU1BBUlNFX0QQ" +
- "8f//////////ARIVCghTUEFSU0VfRRC03vz///////8BEgwKCFNQQVJTRV9G" +
- "EAASDAoIU1BBUlNFX0cQAjKZAQoLVGVzdFNlcnZpY2USRAoDRm9vEh0ucHJv" +
- "dG9idWZfdW5pdHRlc3QuRm9vUmVxdWVzdBoeLnByb3RvYnVmX3VuaXR0ZXN0" +
- "LkZvb1Jlc3BvbnNlEkQKA0JhchIdLnByb3RvYnVmX3VuaXR0ZXN0LkJhclJl" +
- "cXVlc3QaHi5wcm90b2J1Zl91bml0dGVzdC5CYXJSZXNwb25zZTpGChhvcHRp" +
- "b25hbF9pbnQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0" +
- "QWxsRXh0ZW5zaW9ucxgBIAEoBTpGChhvcHRpb25hbF9pbnQ2NF9leHRlbnNp" +
- "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgCIAEo" +
- "AzpHChlvcHRpb25hbF91aW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" +
- "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYAyABKA06RwoZb3B0aW9uYWxfdWlu" +
- "dDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl" +
- "bnNpb25zGAQgASgEOkcKGW9wdGlvbmFsX3NpbnQzMl9leHRlbnNpb24SJC5w" +
- "cm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgFIAEoETpHChlv" +
- "cHRpb25hbF9zaW50NjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu" +
- "VGVzdEFsbEV4dGVuc2lvbnMYBiABKBI6SAoab3B0aW9uYWxfZml4ZWQzMl9l" +
- "eHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9u" +
- "cxgHIAEoBzpIChpvcHRpb25hbF9maXhlZDY0X2V4dGVuc2lvbhIkLnByb3Rv" +
- "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGAggASgGOkkKG29wdGlv" +
- "bmFsX3NmaXhlZDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRl" +
- "c3RBbGxFeHRlbnNpb25zGAkgASgPOkkKG29wdGlvbmFsX3NmaXhlZDY0X2V4" +
- "dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z" +
- "GAogASgQOkYKGG9wdGlvbmFsX2Zsb2F0X2V4dGVuc2lvbhIkLnByb3RvYnVm" +
- "X3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGAsgASgCOkcKGW9wdGlvbmFs" +
- "X2RvdWJsZV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" +
- "RXh0ZW5zaW9ucxgMIAEoATpFChdvcHRpb25hbF9ib29sX2V4dGVuc2lvbhIk" +
- "LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGA0gASgIOkcK" +
- "GW9wdGlvbmFsX3N0cmluZ19leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVz" +
- "dC5UZXN0QWxsRXh0ZW5zaW9ucxgOIAEoCTpGChhvcHRpb25hbF9ieXRlc19l" +
+ "MjAzNjg1NDc3NTgwNxIYCgt1dGY4X3N0cmluZxgGIAEoCToD4Yi0IqoDCg9U" +
+ "ZXN0UGFja2VkVHlwZXMSGAoMcGFja2VkX2ludDMyGFogAygFQgIQARIYCgxw" +
+ "YWNrZWRfaW50NjQYWyADKANCAhABEhkKDXBhY2tlZF91aW50MzIYXCADKA1C" +
+ "AhABEhkKDXBhY2tlZF91aW50NjQYXSADKARCAhABEhkKDXBhY2tlZF9zaW50" +
+ "MzIYXiADKBFCAhABEhkKDXBhY2tlZF9zaW50NjQYXyADKBJCAhABEhoKDnBh" +
+ "Y2tlZF9maXhlZDMyGGAgAygHQgIQARIaCg5wYWNrZWRfZml4ZWQ2NBhhIAMo" +
+ "BkICEAESGwoPcGFja2VkX3NmaXhlZDMyGGIgAygPQgIQARIbCg9wYWNrZWRf" +
+ "c2ZpeGVkNjQYYyADKBBCAhABEhgKDHBhY2tlZF9mbG9hdBhkIAMoAkICEAES" +
+ "GQoNcGFja2VkX2RvdWJsZRhlIAMoAUICEAESFwoLcGFja2VkX2Jvb2wYZiAD" +
+ "KAhCAhABEjcKC3BhY2tlZF9lbnVtGGcgAygOMh4ucHJvdG9idWZfdW5pdHRl" +
+ "c3QuRm9yZWlnbkVudW1CAhABIiAKFFRlc3RQYWNrZWRFeHRlbnNpb25zKggI" +
+ "ARCAgICAAiIMCgpGb29SZXF1ZXN0Ig0KC0Zvb1Jlc3BvbnNlIgwKCkJhclJl" +
+ "cXVlc3QiDQoLQmFyUmVzcG9uc2UqQAoLRm9yZWlnbkVudW0SDwoLRk9SRUlH" +
+ "Tl9GT08QBBIPCgtGT1JFSUdOX0JBUhAFEg8KC0ZPUkVJR05fQkFaEAYqRwoU" +
+ "VGVzdEVudW1XaXRoRHVwVmFsdWUSCAoERk9PMRABEggKBEJBUjEQAhIHCgNC" +
+ "QVoQAxIICgRGT08yEAESCAoEQkFSMhACKokBCg5UZXN0U3BhcnNlRW51bRIM" +
+ "CghTUEFSU0VfQRB7Eg4KCFNQQVJTRV9CEKbnAxIPCghTUEFSU0VfQxCysYAG" +
+ "EhUKCFNQQVJTRV9EEPH//////////wESFQoIU1BBUlNFX0UQtN78////////" +
+ "ARIMCghTUEFSU0VfRhAAEgwKCFNQQVJTRV9HEAIymQEKC1Rlc3RTZXJ2aWNl" +
+ "EkQKA0ZvbxIdLnByb3RvYnVmX3VuaXR0ZXN0LkZvb1JlcXVlc3QaHi5wcm90" +
+ "b2J1Zl91bml0dGVzdC5Gb29SZXNwb25zZRJECgNCYXISHS5wcm90b2J1Zl91" +
+ "bml0dGVzdC5CYXJSZXF1ZXN0Gh4ucHJvdG9idWZfdW5pdHRlc3QuQmFyUmVz" +
+ "cG9uc2U6RgoYb3B0aW9uYWxfaW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZf" +
+ "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYASABKAU6RgoYb3B0aW9uYWxf" +
+ "aW50NjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4" +
+ "dGVuc2lvbnMYAiABKAM6RwoZb3B0aW9uYWxfdWludDMyX2V4dGVuc2lvbhIk" +
+ "LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGAMgASgNOkcK" +
+ "GW9wdGlvbmFsX3VpbnQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVz" +
+ "dC5UZXN0QWxsRXh0ZW5zaW9ucxgEIAEoBDpHChlvcHRpb25hbF9zaW50MzJf" +
+ "ZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lv" +
+ "bnMYBSABKBE6RwoZb3B0aW9uYWxfc2ludDY0X2V4dGVuc2lvbhIkLnByb3Rv" +
+ "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGAYgASgSOkgKGm9wdGlv" +
+ "bmFsX2ZpeGVkMzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" +
+ "dEFsbEV4dGVuc2lvbnMYByABKAc6SAoab3B0aW9uYWxfZml4ZWQ2NF9leHRl" +
+ "bnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgI" +
+ "IAEoBjpJChtvcHRpb25hbF9zZml4ZWQzMl9leHRlbnNpb24SJC5wcm90b2J1" +
+ "Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgJIAEoDzpJChtvcHRpb25h" +
+ "bF9zZml4ZWQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0" +
+ "QWxsRXh0ZW5zaW9ucxgKIAEoEDpGChhvcHRpb25hbF9mbG9hdF9leHRlbnNp" +
+ "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgLIAEo" +
+ "AjpHChlvcHRpb25hbF9kb3VibGVfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" +
+ "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYDCABKAE6RQoXb3B0aW9uYWxfYm9v" +
+ "bF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" +
+ "aW9ucxgNIAEoCDpHChlvcHRpb25hbF9zdHJpbmdfZXh0ZW5zaW9uEiQucHJv" +
+ "dG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYDiABKAk6RgoYb3B0" +
+ "aW9uYWxfYnl0ZXNfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" +
+ "dEFsbEV4dGVuc2lvbnMYDyABKAw6cQoXb3B0aW9uYWxncm91cF9leHRlbnNp" +
+ "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgQIAEo" +
+ "CjIqLnByb3RvYnVmX3VuaXR0ZXN0Lk9wdGlvbmFsR3JvdXBfZXh0ZW5zaW9u" +
+ "On4KIW9wdGlvbmFsX25lc3RlZF9tZXNzYWdlX2V4dGVuc2lvbhIkLnByb3Rv" +
+ "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBIgASgLMi0ucHJvdG9i" +
+ "dWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzLk5lc3RlZE1lc3NhZ2U6cwoib3B0" +
+ "aW9uYWxfZm9yZWlnbl9tZXNzYWdlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3Vu" +
+ "aXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBMgASgLMiEucHJvdG9idWZfdW5p" +
+ "dHRlc3QuRm9yZWlnbk1lc3NhZ2U6eAohb3B0aW9uYWxfaW1wb3J0X21lc3Nh" +
+ "Z2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVu" +
+ "c2lvbnMYFCABKAsyJy5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0" +
+ "TWVzc2FnZTp4Ch5vcHRpb25hbF9uZXN0ZWRfZW51bV9leHRlbnNpb24SJC5w" +
+ "cm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgVIAEoDjIqLnBy" +
+ "b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlcy5OZXN0ZWRFbnVtOm0KH29w" +
+ "dGlvbmFsX2ZvcmVpZ25fZW51bV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0" +
+ "dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgWIAEoDjIeLnByb3RvYnVmX3VuaXR0" +
+ "ZXN0LkZvcmVpZ25FbnVtOnIKHm9wdGlvbmFsX2ltcG9ydF9lbnVtX2V4dGVu" +
+ "c2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBcg" +
+ "ASgOMiQucHJvdG9idWZfdW5pdHRlc3RfaW1wb3J0LkltcG9ydEVudW06UQof" +
+ "b3B0aW9uYWxfc3RyaW5nX3BpZWNlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3Vu" +
+ "aXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBggASgJQgIIAjpJChdvcHRpb25h" +
+ "bF9jb3JkX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF" +
+ "eHRlbnNpb25zGBkgASgJQgIIATpGChhyZXBlYXRlZF9pbnQzMl9leHRlbnNp" +
+ "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgfIAMo" +
+ "BTpGChhyZXBlYXRlZF9pbnQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0" +
+ "dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxggIAMoAzpHChlyZXBlYXRlZF91aW50" +
+ "MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVu" +
+ "c2lvbnMYISADKA06RwoZcmVwZWF0ZWRfdWludDY0X2V4dGVuc2lvbhIkLnBy" +
+ "b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCIgAygEOkcKGXJl" +
+ "cGVhdGVkX3NpbnQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" +
+ "ZXN0QWxsRXh0ZW5zaW9ucxgjIAMoETpHChlyZXBlYXRlZF9zaW50NjRfZXh0" +
+ "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" +
+ "JCADKBI6SAoacmVwZWF0ZWRfZml4ZWQzMl9leHRlbnNpb24SJC5wcm90b2J1" +
+ "Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxglIAMoBzpIChpyZXBlYXRl" +
+ "ZF9maXhlZDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB" +
+ "bGxFeHRlbnNpb25zGCYgAygGOkkKG3JlcGVhdGVkX3NmaXhlZDMyX2V4dGVu" +
+ "c2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCcg" +
+ "AygPOkkKG3JlcGVhdGVkX3NmaXhlZDY0X2V4dGVuc2lvbhIkLnByb3RvYnVm" +
+ "X3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCggAygQOkYKGHJlcGVhdGVk" +
+ "X2Zsb2F0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF" +
+ "eHRlbnNpb25zGCkgAygCOkcKGXJlcGVhdGVkX2RvdWJsZV9leHRlbnNpb24S" +
+ "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgqIAMoATpF" +
+ "ChdyZXBlYXRlZF9ib29sX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0" +
+ "LlRlc3RBbGxFeHRlbnNpb25zGCsgAygIOkcKGXJlcGVhdGVkX3N0cmluZ19l" +
"eHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9u" +
- "cxgPIAEoDDpxChdvcHRpb25hbGdyb3VwX2V4dGVuc2lvbhIkLnByb3RvYnVm" +
- "X3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBAgASgKMioucHJvdG9idWZf" +
- "dW5pdHRlc3QuT3B0aW9uYWxHcm91cF9leHRlbnNpb246fgohb3B0aW9uYWxf" +
- "bmVzdGVkX21lc3NhZ2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu" +
- "VGVzdEFsbEV4dGVuc2lvbnMYEiABKAsyLS5wcm90b2J1Zl91bml0dGVzdC5U" +
- "ZXN0QWxsVHlwZXMuTmVzdGVkTWVzc2FnZTpzCiJvcHRpb25hbF9mb3JlaWdu" +
- "X21lc3NhZ2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs" +
- "bEV4dGVuc2lvbnMYEyABKAsyIS5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWdu" +
- "TWVzc2FnZTp4CiFvcHRpb25hbF9pbXBvcnRfbWVzc2FnZV9leHRlbnNpb24S" +
- "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgUIAEoCzIn" +
- "LnByb3RvYnVmX3VuaXR0ZXN0X2ltcG9ydC5JbXBvcnRNZXNzYWdlOngKHm9w" +
- "dGlvbmFsX25lc3RlZF9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0" +
- "ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBUgASgOMioucHJvdG9idWZfdW5pdHRl" +
- "c3QuVGVzdEFsbFR5cGVzLk5lc3RlZEVudW06bQofb3B0aW9uYWxfZm9yZWln" +
- "bl9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF" +
- "eHRlbnNpb25zGBYgASgOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVu" +
- "dW06cgoeb3B0aW9uYWxfaW1wb3J0X2VudW1fZXh0ZW5zaW9uEiQucHJvdG9i" +
- "dWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYFyABKA4yJC5wcm90b2J1" +
- "Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bTpRCh9vcHRpb25hbF9zdHJp" +
- "bmdfcGllY2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs" +
- "bEV4dGVuc2lvbnMYGCABKAlCAggCOkkKF29wdGlvbmFsX2NvcmRfZXh0ZW5z" +
- "aW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYGSAB" +
- "KAlCAggBOkYKGHJlcGVhdGVkX2ludDMyX2V4dGVuc2lvbhIkLnByb3RvYnVm" +
- "X3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGB8gAygFOkYKGHJlcGVhdGVk" +
- "X2ludDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF" +
- "eHRlbnNpb25zGCAgAygDOkcKGXJlcGVhdGVkX3VpbnQzMl9leHRlbnNpb24S" +
- "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxghIAMoDTpH" +
- "ChlyZXBlYXRlZF91aW50NjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl" +
- "c3QuVGVzdEFsbEV4dGVuc2lvbnMYIiADKAQ6RwoZcmVwZWF0ZWRfc2ludDMy" +
- "X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNp" +
- "b25zGCMgAygROkcKGXJlcGVhdGVkX3NpbnQ2NF9leHRlbnNpb24SJC5wcm90" +
- "b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgkIAMoEjpIChpyZXBl" +
- "YXRlZF9maXhlZDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRl" +
- "c3RBbGxFeHRlbnNpb25zGCUgAygHOkgKGnJlcGVhdGVkX2ZpeGVkNjRfZXh0" +
+ "cxgsIAMoCTpGChhyZXBlYXRlZF9ieXRlc19leHRlbnNpb24SJC5wcm90b2J1" +
+ "Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgtIAMoDDpxChdyZXBlYXRl" +
+ "ZGdyb3VwX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF" +
+ "eHRlbnNpb25zGC4gAygKMioucHJvdG9idWZfdW5pdHRlc3QuUmVwZWF0ZWRH" +
+ "cm91cF9leHRlbnNpb246fgohcmVwZWF0ZWRfbmVzdGVkX21lc3NhZ2VfZXh0" +
"ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" +
- "JiADKAY6SQobcmVwZWF0ZWRfc2ZpeGVkMzJfZXh0ZW5zaW9uEiQucHJvdG9i" +
- "dWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYJyADKA86SQobcmVwZWF0" +
- "ZWRfc2ZpeGVkNjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" +
- "dEFsbEV4dGVuc2lvbnMYKCADKBA6RgoYcmVwZWF0ZWRfZmxvYXRfZXh0ZW5z" +
- "aW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYKSAD" +
- "KAI6RwoZcmVwZWF0ZWRfZG91YmxlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3Vu" +
- "aXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCogAygBOkUKF3JlcGVhdGVkX2Jv" +
- "b2xfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVu" +
- "c2lvbnMYKyADKAg6RwoZcmVwZWF0ZWRfc3RyaW5nX2V4dGVuc2lvbhIkLnBy" +
- "b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCwgAygJOkYKGHJl" +
- "cGVhdGVkX2J5dGVzX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRl" +
- "c3RBbGxFeHRlbnNpb25zGC0gAygMOnEKF3JlcGVhdGVkZ3JvdXBfZXh0ZW5z" +
- "aW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYLiAD" +
- "KAoyKi5wcm90b2J1Zl91bml0dGVzdC5SZXBlYXRlZEdyb3VwX2V4dGVuc2lv" +
- "bjp+CiFyZXBlYXRlZF9uZXN0ZWRfbWVzc2FnZV9leHRlbnNpb24SJC5wcm90" +
- "b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgwIAMoCzItLnByb3Rv" +
- "YnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlcy5OZXN0ZWRNZXNzYWdlOnMKInJl" +
- "cGVhdGVkX2ZvcmVpZ25fbWVzc2FnZV9leHRlbnNpb24SJC5wcm90b2J1Zl91" +
- "bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgxIAMoCzIhLnByb3RvYnVmX3Vu" +
- "aXR0ZXN0LkZvcmVpZ25NZXNzYWdlOngKIXJlcGVhdGVkX2ltcG9ydF9tZXNz" +
- "YWdlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl" +
- "bnNpb25zGDIgAygLMicucHJvdG9idWZfdW5pdHRlc3RfaW1wb3J0LkltcG9y" +
- "dE1lc3NhZ2U6eAoecmVwZWF0ZWRfbmVzdGVkX2VudW1fZXh0ZW5zaW9uEiQu" +
- "cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYMyADKA4yKi5w" +
- "cm90b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXMuTmVzdGVkRW51bTptCh9y" +
- "ZXBlYXRlZF9mb3JlaWduX2VudW1fZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" +
- "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYNCADKA4yHi5wcm90b2J1Zl91bml0" +
- "dGVzdC5Gb3JlaWduRW51bTpyCh5yZXBlYXRlZF9pbXBvcnRfZW51bV9leHRl" +
- "bnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxg1" +
- "IAMoDjIkLnByb3RvYnVmX3VuaXR0ZXN0X2ltcG9ydC5JbXBvcnRFbnVtOlEK" +
- "H3JlcGVhdGVkX3N0cmluZ19waWVjZV9leHRlbnNpb24SJC5wcm90b2J1Zl91" +
- "bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxg2IAMoCUICCAI6SQoXcmVwZWF0" +
- "ZWRfY29yZF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" +
- "RXh0ZW5zaW9ucxg3IAMoCUICCAE6SQoXZGVmYXVsdF9pbnQzMl9leHRlbnNp" +
- "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxg9IAEo" +
- "BToCNDE6SQoXZGVmYXVsdF9pbnQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91" +
- "bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxg+IAEoAzoCNDI6SgoYZGVmYXVs" +
- "dF91aW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs" +
- "bEV4dGVuc2lvbnMYPyABKA06AjQzOkoKGGRlZmF1bHRfdWludDY0X2V4dGVu" +
- "c2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGEAg" +
- "ASgEOgI0NDpLChhkZWZhdWx0X3NpbnQzMl9leHRlbnNpb24SJC5wcm90b2J1" +
- "Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhBIAEoEToDLTQ1OkoKGGRl" +
- "ZmF1bHRfc2ludDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRl" +
- "c3RBbGxFeHRlbnNpb25zGEIgASgSOgI0NjpLChlkZWZhdWx0X2ZpeGVkMzJf" +
- "ZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lv" +
- "bnMYQyABKAc6AjQ3OksKGWRlZmF1bHRfZml4ZWQ2NF9leHRlbnNpb24SJC5w" +
- "cm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhEIAEoBjoCNDg6" +
- "TAoaZGVmYXVsdF9zZml4ZWQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0" +
- "dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhFIAEoDzoCNDk6TQoaZGVmYXVsdF9z" +
- "Zml4ZWQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" +
- "RXh0ZW5zaW9ucxhGIAEoEDoDLTUwOksKF2RlZmF1bHRfZmxvYXRfZXh0ZW5z" +
- "aW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYRyAB" +
- "KAI6BDUxLjU6TQoYZGVmYXVsdF9kb3VibGVfZXh0ZW5zaW9uEiQucHJvdG9i" +
- "dWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYSCABKAE6BTUyMDAwOkoK" +
- "FmRlZmF1bHRfYm9vbF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" +
- "ZXN0QWxsRXh0ZW5zaW9ucxhJIAEoCDoEdHJ1ZTpNChhkZWZhdWx0X3N0cmlu" +
- "Z19leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" +
- "aW9ucxhKIAEoCToFaGVsbG86TAoXZGVmYXVsdF9ieXRlc19leHRlbnNpb24S" +
- "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhLIAEoDDoF" +
- "d29ybGQ6fAodZGVmYXVsdF9uZXN0ZWRfZW51bV9leHRlbnNpb24SJC5wcm90" +
- "b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhRIAEoDjIqLnByb3Rv" +
- "YnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlcy5OZXN0ZWRFbnVtOgNCQVI6eQoe" +
- "ZGVmYXVsdF9mb3JlaWduX2VudW1fZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" +
- "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYUiABKA4yHi5wcm90b2J1Zl91bml0" +
- "dGVzdC5Gb3JlaWduRW51bToLRk9SRUlHTl9CQVI6fQodZGVmYXVsdF9pbXBv" +
- "cnRfZW51bV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" +
- "RXh0ZW5zaW9ucxhTIAEoDjIkLnByb3RvYnVmX3VuaXR0ZXN0X2ltcG9ydC5J" +
- "bXBvcnRFbnVtOgpJTVBPUlRfQkFSOlUKHmRlZmF1bHRfc3RyaW5nX3BpZWNl" +
+ "MCADKAsyLS5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXMuTmVzdGVk" +
+ "TWVzc2FnZTpzCiJyZXBlYXRlZF9mb3JlaWduX21lc3NhZ2VfZXh0ZW5zaW9u" +
+ "EiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYMSADKAsy" +
+ "IS5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduTWVzc2FnZTp4CiFyZXBlYXRl" +
+ "ZF9pbXBvcnRfbWVzc2FnZV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVz" +
+ "dC5UZXN0QWxsRXh0ZW5zaW9ucxgyIAMoCzInLnByb3RvYnVmX3VuaXR0ZXN0" +
+ "X2ltcG9ydC5JbXBvcnRNZXNzYWdlOngKHnJlcGVhdGVkX25lc3RlZF9lbnVt" +
"X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNp" +
- "b25zGFQgASgJOgNhYmNCAggCOk0KFmRlZmF1bHRfY29yZF9leHRlbnNpb24S" +
- "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhVIAEoCToD" +
- "MTIzQgIIATpCChNteV9leHRlbnNpb25fc3RyaW5nEiUucHJvdG9idWZfdW5p" +
- "dHRlc3QuVGVzdEZpZWxkT3JkZXJpbmdzGDIgASgJOj8KEG15X2V4dGVuc2lv" +
- "bl9pbnQSJS5wcm90b2J1Zl91bml0dGVzdC5UZXN0RmllbGRPcmRlcmluZ3MY" +
- "BSABKAVCSkINVW5pdHRlc3RQcm90b0gBwj42CiFHb29nbGUuUHJvdG9jb2xC" +
- "dWZmZXJzLlRlc3RQcm90b3MSEVVuaXRUZXN0UHJvdG9GaWxl"),
+ "b25zGDMgAygOMioucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzLk5l" +
+ "c3RlZEVudW06bQofcmVwZWF0ZWRfZm9yZWlnbl9lbnVtX2V4dGVuc2lvbhIk" +
+ "LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGDQgAygOMh4u" +
+ "cHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW06cgoecmVwZWF0ZWRfaW1w" +
+ "b3J0X2VudW1fZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs" +
+ "bEV4dGVuc2lvbnMYNSADKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQu" +
+ "SW1wb3J0RW51bTpRCh9yZXBlYXRlZF9zdHJpbmdfcGllY2VfZXh0ZW5zaW9u" +
+ "EiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYNiADKAlC" +
+ "AggCOkkKF3JlcGVhdGVkX2NvcmRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" +
+ "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYNyADKAlCAggBOkkKF2RlZmF1bHRf" +
+ "aW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4" +
+ "dGVuc2lvbnMYPSABKAU6AjQxOkkKF2RlZmF1bHRfaW50NjRfZXh0ZW5zaW9u" +
+ "EiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYPiABKAM6" +
+ "AjQyOkoKGGRlZmF1bHRfdWludDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3Vu" +
+ "aXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGD8gASgNOgI0MzpKChhkZWZhdWx0" +
+ "X3VpbnQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" +
+ "RXh0ZW5zaW9ucxhAIAEoBDoCNDQ6SwoYZGVmYXVsdF9zaW50MzJfZXh0ZW5z" +
+ "aW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYQSAB" +
+ "KBE6Ay00NTpKChhkZWZhdWx0X3NpbnQ2NF9leHRlbnNpb24SJC5wcm90b2J1" +
+ "Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhCIAEoEjoCNDY6SwoZZGVm" +
+ "YXVsdF9maXhlZDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRl" +
+ "c3RBbGxFeHRlbnNpb25zGEMgASgHOgI0NzpLChlkZWZhdWx0X2ZpeGVkNjRf" +
+ "ZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lv" +
+ "bnMYRCABKAY6AjQ4OkwKGmRlZmF1bHRfc2ZpeGVkMzJfZXh0ZW5zaW9uEiQu" +
+ "cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYRSABKA86AjQ5" +
+ "Ok0KGmRlZmF1bHRfc2ZpeGVkNjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" +
+ "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYRiABKBA6Ay01MDpLChdkZWZhdWx0" +
+ "X2Zsb2F0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF" +
+ "eHRlbnNpb25zGEcgASgCOgQ1MS41Ok0KGGRlZmF1bHRfZG91YmxlX2V4dGVu" +
+ "c2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGEgg" +
+ "ASgBOgU1MjAwMDpKChZkZWZhdWx0X2Jvb2xfZXh0ZW5zaW9uEiQucHJvdG9i" +
+ "dWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYSSABKAg6BHRydWU6TQoY" +
+ "ZGVmYXVsdF9zdHJpbmdfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu" +
+ "VGVzdEFsbEV4dGVuc2lvbnMYSiABKAk6BWhlbGxvOkwKF2RlZmF1bHRfYnl0" +
+ "ZXNfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVu" +
+ "c2lvbnMYSyABKAw6BXdvcmxkOnwKHWRlZmF1bHRfbmVzdGVkX2VudW1fZXh0" +
+ "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" +
+ "USABKA4yKi5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXMuTmVzdGVk" +
+ "RW51bToDQkFSOnkKHmRlZmF1bHRfZm9yZWlnbl9lbnVtX2V4dGVuc2lvbhIk" +
+ "LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGFIgASgOMh4u" +
+ "cHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW06C0ZPUkVJR05fQkFSOn0K" +
+ "HWRlZmF1bHRfaW1wb3J0X2VudW1fZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" +
+ "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYUyABKA4yJC5wcm90b2J1Zl91bml0" +
+ "dGVzdF9pbXBvcnQuSW1wb3J0RW51bToKSU1QT1JUX0JBUjpVCh5kZWZhdWx0" +
+ "X3N0cmluZ19waWVjZV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" +
+ "ZXN0QWxsRXh0ZW5zaW9ucxhUIAEoCToDYWJjQgIIAjpNChZkZWZhdWx0X2Nv" +
+ "cmRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVu" +
+ "c2lvbnMYVSABKAk6AzEyM0ICCAE6QgoTbXlfZXh0ZW5zaW9uX3N0cmluZxIl" +
+ "LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RGaWVsZE9yZGVyaW5ncxgyIAEoCTo/" +
+ "ChBteV9leHRlbnNpb25faW50EiUucHJvdG9idWZfdW5pdHRlc3QuVGVzdEZp" +
+ "ZWxkT3JkZXJpbmdzGAUgASgFOksKFnBhY2tlZF9pbnQzMl9leHRlbnNpb24S" +
+ "Jy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UGFja2VkRXh0ZW5zaW9ucxhaIAMo" +
+ "BUICEAE6SwoWcGFja2VkX2ludDY0X2V4dGVuc2lvbhInLnByb3RvYnVmX3Vu" +
+ "aXR0ZXN0LlRlc3RQYWNrZWRFeHRlbnNpb25zGFsgAygDQgIQATpMChdwYWNr" +
+ "ZWRfdWludDMyX2V4dGVuc2lvbhInLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RQ" +
+ "YWNrZWRFeHRlbnNpb25zGFwgAygNQgIQATpMChdwYWNrZWRfdWludDY0X2V4" +
+ "dGVuc2lvbhInLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RQYWNrZWRFeHRlbnNp" +
+ "b25zGF0gAygEQgIQATpMChdwYWNrZWRfc2ludDMyX2V4dGVuc2lvbhInLnBy" +
+ "b3RvYnVmX3VuaXR0ZXN0LlRlc3RQYWNrZWRFeHRlbnNpb25zGF4gAygRQgIQ" +
+ "ATpMChdwYWNrZWRfc2ludDY0X2V4dGVuc2lvbhInLnByb3RvYnVmX3VuaXR0" +
+ "ZXN0LlRlc3RQYWNrZWRFeHRlbnNpb25zGF8gAygSQgIQATpNChhwYWNrZWRf" +
+ "Zml4ZWQzMl9leHRlbnNpb24SJy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UGFj" +
+ "a2VkRXh0ZW5zaW9ucxhgIAMoB0ICEAE6TQoYcGFja2VkX2ZpeGVkNjRfZXh0" +
+ "ZW5zaW9uEicucHJvdG9idWZfdW5pdHRlc3QuVGVzdFBhY2tlZEV4dGVuc2lv" +
+ "bnMYYSADKAZCAhABOk4KGXBhY2tlZF9zZml4ZWQzMl9leHRlbnNpb24SJy5w" +
+ "cm90b2J1Zl91bml0dGVzdC5UZXN0UGFja2VkRXh0ZW5zaW9ucxhiIAMoD0IC" +
+ "EAE6TgoZcGFja2VkX3NmaXhlZDY0X2V4dGVuc2lvbhInLnByb3RvYnVmX3Vu" +
+ "aXR0ZXN0LlRlc3RQYWNrZWRFeHRlbnNpb25zGGMgAygQQgIQATpLChZwYWNr" +
+ "ZWRfZmxvYXRfZXh0ZW5zaW9uEicucHJvdG9idWZfdW5pdHRlc3QuVGVzdFBh" +
+ "Y2tlZEV4dGVuc2lvbnMYZCADKAJCAhABOkwKF3BhY2tlZF9kb3VibGVfZXh0" +
+ "ZW5zaW9uEicucHJvdG9idWZfdW5pdHRlc3QuVGVzdFBhY2tlZEV4dGVuc2lv" +
+ "bnMYZSADKAFCAhABOkoKFXBhY2tlZF9ib29sX2V4dGVuc2lvbhInLnByb3Rv" +
+ "YnVmX3VuaXR0ZXN0LlRlc3RQYWNrZWRFeHRlbnNpb25zGGYgAygIQgIQATpq" +
+ "ChVwYWNrZWRfZW51bV9leHRlbnNpb24SJy5wcm90b2J1Zl91bml0dGVzdC5U" +
+ "ZXN0UGFja2VkRXh0ZW5zaW9ucxhnIAMoDjIeLnByb3RvYnVmX3VuaXR0ZXN0" +
+ "LkZvcmVpZ25FbnVtQgIQAUJKQg1Vbml0dGVzdFByb3RvSAHCPjYKIUdvb2ds" +
+ "ZS5Qcm90b2NvbEJ1ZmZlcnMuVGVzdFByb3RvcxIRVW5pdFRlc3RQcm90b0Zp" +
+ "bGU="),
new pbd::FileDescriptor[] {
global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor,
global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.Descriptor,
@@ -457,6 +493,48 @@ namespace Google.ProtocolBuffers.TestProtos {
pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[68]);
public static readonly pb::GeneratedExtensionBase MyExtensionInt =
pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[69]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedInt32Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[70]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedInt64Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[71]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedUint32Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[72]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedUint64Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[73]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedSint32Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[74]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedSint64Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[75]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedFixed32Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[76]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedFixed64Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[77]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedSfixed32Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[78]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedSfixed64Extension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[79]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedFloatExtension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[80]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedDoubleExtension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[81]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedBoolExtension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[82]);
+ public static readonly
+ pb::GeneratedExtensionBase> PackedEnumExtension =
+ pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[83]);
#endregion
#region Static variables
@@ -585,23 +663,33 @@ namespace Google.ProtocolBuffers.TestProtos {
internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestExtremeDefaultValues__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestExtremeDefaultValues__Descriptor,
new string[] { "EscapedBytes", "LargeUint32", "LargeUint64", "SmallInt32", "SmallInt64", "Utf8String", });
- internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_FooRequest__Descriptor
+ internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestPackedTypes__Descriptor
= Descriptor.MessageTypes[19];
+ internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestPackedTypes__FieldAccessorTable
+ = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestPackedTypes__Descriptor,
+ new string[] { "PackedInt32", "PackedInt64", "PackedUint32", "PackedUint64", "PackedSint32", "PackedSint64", "PackedFixed32", "PackedFixed64", "PackedSfixed32", "PackedSfixed64", "PackedFloat", "PackedDouble", "PackedBool", "PackedEnum", });
+ internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestPackedExtensions__Descriptor
+ = Descriptor.MessageTypes[20];
+ internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestPackedExtensions__FieldAccessorTable
+ = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestPackedExtensions__Descriptor,
+ new string[] { });
+ internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_FooRequest__Descriptor
+ = Descriptor.MessageTypes[21];
internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_FooRequest__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_FooRequest__Descriptor,
new string[] { });
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_FooResponse__Descriptor
- = Descriptor.MessageTypes[20];
+ = Descriptor.MessageTypes[22];
internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_FooResponse__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_FooResponse__Descriptor,
new string[] { });
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_BarRequest__Descriptor
- = Descriptor.MessageTypes[21];
+ = Descriptor.MessageTypes[23];
internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_BarRequest__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_BarRequest__Descriptor,
new string[] { });
internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_BarResponse__Descriptor
- = Descriptor.MessageTypes[22];
+ = Descriptor.MessageTypes[24];
internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_BarResponse__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_BarResponse__Descriptor,
new string[] { });
@@ -1983,50 +2071,80 @@ namespace Google.ProtocolBuffers.TestProtos {
if (HasOptionalCord) {
output.WriteString(25, OptionalCord);
}
- foreach (int element in RepeatedInt32List) {
- output.WriteInt32(31, element);
+ if (repeatedInt32_.Count > 0) {
+ foreach (int element in repeatedInt32_) {
+ output.WriteInt32(31, element);
+ }
}
- foreach (long element in RepeatedInt64List) {
- output.WriteInt64(32, element);
+ if (repeatedInt64_.Count > 0) {
+ foreach (long element in repeatedInt64_) {
+ output.WriteInt64(32, element);
+ }
}
- foreach (uint element in RepeatedUint32List) {
- output.WriteUInt32(33, element);
+ if (repeatedUint32_.Count > 0) {
+ foreach (uint element in repeatedUint32_) {
+ output.WriteUInt32(33, element);
+ }
}
- foreach (ulong element in RepeatedUint64List) {
- output.WriteUInt64(34, element);
+ if (repeatedUint64_.Count > 0) {
+ foreach (ulong element in repeatedUint64_) {
+ output.WriteUInt64(34, element);
+ }
}
- foreach (int element in RepeatedSint32List) {
- output.WriteSInt32(35, element);
+ if (repeatedSint32_.Count > 0) {
+ foreach (int element in repeatedSint32_) {
+ output.WriteSInt32(35, element);
+ }
}
- foreach (long element in RepeatedSint64List) {
- output.WriteSInt64(36, element);
+ if (repeatedSint64_.Count > 0) {
+ foreach (long element in repeatedSint64_) {
+ output.WriteSInt64(36, element);
+ }
}
- foreach (uint element in RepeatedFixed32List) {
- output.WriteFixed32(37, element);
+ if (repeatedFixed32_.Count > 0) {
+ foreach (uint element in repeatedFixed32_) {
+ output.WriteFixed32(37, element);
+ }
}
- foreach (ulong element in RepeatedFixed64List) {
- output.WriteFixed64(38, element);
+ if (repeatedFixed64_.Count > 0) {
+ foreach (ulong element in repeatedFixed64_) {
+ output.WriteFixed64(38, element);
+ }
}
- foreach (int element in RepeatedSfixed32List) {
- output.WriteSFixed32(39, element);
+ if (repeatedSfixed32_.Count > 0) {
+ foreach (int element in repeatedSfixed32_) {
+ output.WriteSFixed32(39, element);
+ }
}
- foreach (long element in RepeatedSfixed64List) {
- output.WriteSFixed64(40, element);
+ if (repeatedSfixed64_.Count > 0) {
+ foreach (long element in repeatedSfixed64_) {
+ output.WriteSFixed64(40, element);
+ }
}
- foreach (float element in RepeatedFloatList) {
- output.WriteFloat(41, element);
+ if (repeatedFloat_.Count > 0) {
+ foreach (float element in repeatedFloat_) {
+ output.WriteFloat(41, element);
+ }
}
- foreach (double element in RepeatedDoubleList) {
- output.WriteDouble(42, element);
+ if (repeatedDouble_.Count > 0) {
+ foreach (double element in repeatedDouble_) {
+ output.WriteDouble(42, element);
+ }
}
- foreach (bool element in RepeatedBoolList) {
- output.WriteBool(43, element);
+ if (repeatedBool_.Count > 0) {
+ foreach (bool element in repeatedBool_) {
+ output.WriteBool(43, element);
+ }
}
- foreach (string element in RepeatedStringList) {
- output.WriteString(44, element);
+ if (repeatedString_.Count > 0) {
+ foreach (string element in repeatedString_) {
+ output.WriteString(44, element);
+ }
}
- foreach (pb::ByteString element in RepeatedBytesList) {
- output.WriteBytes(45, element);
+ if (repeatedBytes_.Count > 0) {
+ foreach (pb::ByteString element in repeatedBytes_) {
+ output.WriteBytes(45, element);
+ }
}
foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup element in RepeatedGroupList) {
output.WriteGroup(46, element);
@@ -2040,20 +2158,30 @@ namespace Google.ProtocolBuffers.TestProtos {
foreach (global::Google.ProtocolBuffers.TestProtos.ImportMessage element in RepeatedImportMessageList) {
output.WriteMessage(50, element);
}
- foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum element in RepeatedNestedEnumList) {
- output.WriteEnum(51, (int) element);
+ if (repeatedNestedEnum_.Count > 0) {
+ foreach (int element in repeatedNestedEnum_) {
+ output.WriteEnum(51, element);
+ }
}
- foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedForeignEnumList) {
- output.WriteEnum(52, (int) element);
+ if (repeatedForeignEnum_.Count > 0) {
+ foreach (int element in repeatedForeignEnum_) {
+ output.WriteEnum(52, element);
+ }
}
- foreach (global::Google.ProtocolBuffers.TestProtos.ImportEnum element in RepeatedImportEnumList) {
- output.WriteEnum(53, (int) element);
+ if (repeatedImportEnum_.Count > 0) {
+ foreach (int element in repeatedImportEnum_) {
+ output.WriteEnum(53, element);
+ }
}
- foreach (string element in RepeatedStringPieceList) {
- output.WriteString(54, element);
+ if (repeatedStringPiece_.Count > 0) {
+ foreach (string element in repeatedStringPiece_) {
+ output.WriteString(54, element);
+ }
}
- foreach (string element in RepeatedCordList) {
- output.WriteString(55, element);
+ if (repeatedCord_.Count > 0) {
+ foreach (string element in repeatedCord_) {
+ output.WriteString(55, element);
+ }
}
if (HasDefaultInt32) {
output.WriteInt32(61, DefaultInt32);
@@ -2197,50 +2325,111 @@ namespace Google.ProtocolBuffers.TestProtos {
if (HasOptionalCord) {
size += pb::CodedOutputStream.ComputeStringSize(25, OptionalCord);
}
- foreach (int element in RepeatedInt32List) {
- size += pb::CodedOutputStream.ComputeInt32Size(31, element);
- }
- foreach (long element in RepeatedInt64List) {
- size += pb::CodedOutputStream.ComputeInt64Size(32, element);
- }
- foreach (uint element in RepeatedUint32List) {
- size += pb::CodedOutputStream.ComputeUInt32Size(33, element);
- }
- foreach (ulong element in RepeatedUint64List) {
- size += pb::CodedOutputStream.ComputeUInt64Size(34, element);
- }
- foreach (int element in RepeatedSint32List) {
- size += pb::CodedOutputStream.ComputeSInt32Size(35, element);
- }
- foreach (long element in RepeatedSint64List) {
- size += pb::CodedOutputStream.ComputeSInt64Size(36, element);
- }
- foreach (uint element in RepeatedFixed32List) {
- size += pb::CodedOutputStream.ComputeFixed32Size(37, element);
- }
- foreach (ulong element in RepeatedFixed64List) {
- size += pb::CodedOutputStream.ComputeFixed64Size(38, element);
- }
- foreach (int element in RepeatedSfixed32List) {
- size += pb::CodedOutputStream.ComputeSFixed32Size(39, element);
- }
- foreach (long element in RepeatedSfixed64List) {
- size += pb::CodedOutputStream.ComputeSFixed64Size(40, element);
- }
- foreach (float element in RepeatedFloatList) {
- size += pb::CodedOutputStream.ComputeFloatSize(41, element);
- }
- foreach (double element in RepeatedDoubleList) {
- size += pb::CodedOutputStream.ComputeDoubleSize(42, element);
- }
- foreach (bool element in RepeatedBoolList) {
- size += pb::CodedOutputStream.ComputeBoolSize(43, element);
- }
- foreach (string element in RepeatedStringList) {
- size += pb::CodedOutputStream.ComputeStringSize(44, element);
- }
- foreach (pb::ByteString element in RepeatedBytesList) {
- size += pb::CodedOutputStream.ComputeBytesSize(45, element);
+ {
+ int dataSize = 0;
+ foreach (int element in RepeatedInt32List) {
+ dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedInt32_.Count;
+ }
+ {
+ int dataSize = 0;
+ foreach (long element in RepeatedInt64List) {
+ dataSize += pb::CodedOutputStream.ComputeInt64SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedInt64_.Count;
+ }
+ {
+ int dataSize = 0;
+ foreach (uint element in RepeatedUint32List) {
+ dataSize += pb::CodedOutputStream.ComputeUInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedUint32_.Count;
+ }
+ {
+ int dataSize = 0;
+ foreach (ulong element in RepeatedUint64List) {
+ dataSize += pb::CodedOutputStream.ComputeUInt64SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedUint64_.Count;
+ }
+ {
+ int dataSize = 0;
+ foreach (int element in RepeatedSint32List) {
+ dataSize += pb::CodedOutputStream.ComputeSInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedSint32_.Count;
+ }
+ {
+ int dataSize = 0;
+ foreach (long element in RepeatedSint64List) {
+ dataSize += pb::CodedOutputStream.ComputeSInt64SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedSint64_.Count;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 4 * repeatedFixed32_.Count;
+ size += dataSize;
+ size += 2 * repeatedFixed32_.Count;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 8 * repeatedFixed64_.Count;
+ size += dataSize;
+ size += 2 * repeatedFixed64_.Count;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 4 * repeatedSfixed32_.Count;
+ size += dataSize;
+ size += 2 * repeatedSfixed32_.Count;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 8 * repeatedSfixed64_.Count;
+ size += dataSize;
+ size += 2 * repeatedSfixed64_.Count;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 4 * repeatedFloat_.Count;
+ size += dataSize;
+ size += 2 * repeatedFloat_.Count;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 8 * repeatedDouble_.Count;
+ size += dataSize;
+ size += 2 * repeatedDouble_.Count;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 1 * repeatedBool_.Count;
+ size += dataSize;
+ size += 2 * repeatedBool_.Count;
+ }
+ {
+ int dataSize = 0;
+ foreach (string element in RepeatedStringList) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedString_.Count;
+ }
+ {
+ int dataSize = 0;
+ foreach (pb::ByteString element in RepeatedBytesList) {
+ dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedBytes_.Count;
}
foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup element in RepeatedGroupList) {
size += pb::CodedOutputStream.ComputeGroupSize(46, element);
@@ -2254,20 +2443,51 @@ namespace Google.ProtocolBuffers.TestProtos {
foreach (global::Google.ProtocolBuffers.TestProtos.ImportMessage element in RepeatedImportMessageList) {
size += pb::CodedOutputStream.ComputeMessageSize(50, element);
}
- foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum element in RepeatedNestedEnumList) {
- size += pb::CodedOutputStream.ComputeEnumSize(51, (int) element);
+ {
+ int dataSize = 0;
+ if (repeatedNestedEnum_.Count > 0) {
+ foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum element in repeatedNestedEnum_) {
+ dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element);
+ }
+ size += dataSize;
+ size += 2 * repeatedNestedEnum_.Count;
+ }
}
- foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedForeignEnumList) {
- size += pb::CodedOutputStream.ComputeEnumSize(52, (int) element);
+ {
+ int dataSize = 0;
+ if (repeatedForeignEnum_.Count > 0) {
+ foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in repeatedForeignEnum_) {
+ dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element);
+ }
+ size += dataSize;
+ size += 2 * repeatedForeignEnum_.Count;
+ }
}
- foreach (global::Google.ProtocolBuffers.TestProtos.ImportEnum element in RepeatedImportEnumList) {
- size += pb::CodedOutputStream.ComputeEnumSize(53, (int) element);
+ {
+ int dataSize = 0;
+ if (repeatedImportEnum_.Count > 0) {
+ foreach (global::Google.ProtocolBuffers.TestProtos.ImportEnum element in repeatedImportEnum_) {
+ dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element);
+ }
+ size += dataSize;
+ size += 2 * repeatedImportEnum_.Count;
+ }
}
- foreach (string element in RepeatedStringPieceList) {
- size += pb::CodedOutputStream.ComputeStringSize(54, element);
+ {
+ int dataSize = 0;
+ foreach (string element in RepeatedStringPieceList) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedStringPiece_.Count;
}
- foreach (string element in RepeatedCordList) {
- size += pb::CodedOutputStream.ComputeStringSize(55, element);
+ {
+ int dataSize = 0;
+ foreach (string element in RepeatedCordList) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2 * repeatedCord_.Count;
}
if (HasDefaultInt32) {
size += pb::CodedOutputStream.ComputeInt32Size(61, DefaultInt32);
@@ -9369,8 +9589,10 @@ namespace Google.ProtocolBuffers.TestProtos {
}
public override void WriteTo(pb::CodedOutputStream output) {
- foreach (int element in NestedmessageRepeatedInt32List) {
- output.WriteInt32(1, element);
+ if (nestedmessageRepeatedInt32_.Count > 0) {
+ foreach (int element in nestedmessageRepeatedInt32_) {
+ output.WriteInt32(1, element);
+ }
}
foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in NestedmessageRepeatedForeignmessageList) {
output.WriteMessage(2, element);
@@ -9385,8 +9607,13 @@ namespace Google.ProtocolBuffers.TestProtos {
if (size != -1) return size;
size = 0;
- foreach (int element in NestedmessageRepeatedInt32List) {
- size += pb::CodedOutputStream.ComputeInt32Size(1, element);
+ {
+ int dataSize = 0;
+ foreach (int element in NestedmessageRepeatedInt32List) {
+ dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 1 * nestedmessageRepeatedInt32_.Count;
}
foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in NestedmessageRepeatedForeignmessageList) {
size += pb::CodedOutputStream.ComputeMessageSize(2, element);
@@ -9949,23 +10176,33 @@ namespace Google.ProtocolBuffers.TestProtos {
if (HasCordField) {
output.WriteString(6, CordField);
}
- foreach (int element in RepeatedPrimitiveFieldList) {
- output.WriteInt32(7, element);
+ if (repeatedPrimitiveField_.Count > 0) {
+ foreach (int element in repeatedPrimitiveField_) {
+ output.WriteInt32(7, element);
+ }
}
- foreach (string element in RepeatedStringFieldList) {
- output.WriteString(8, element);
+ if (repeatedStringField_.Count > 0) {
+ foreach (string element in repeatedStringField_) {
+ output.WriteString(8, element);
+ }
}
- foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedEnumFieldList) {
- output.WriteEnum(9, (int) element);
+ if (repeatedEnumField_.Count > 0) {
+ foreach (int element in repeatedEnumField_) {
+ output.WriteEnum(9, element);
+ }
}
foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedMessageFieldList) {
output.WriteMessage(10, element);
}
- foreach (string element in RepeatedStringPieceFieldList) {
- output.WriteString(11, element);
+ if (repeatedStringPieceField_.Count > 0) {
+ foreach (string element in repeatedStringPieceField_) {
+ output.WriteString(11, element);
+ }
}
- foreach (string element in RepeatedCordFieldList) {
- output.WriteString(12, element);
+ if (repeatedCordField_.Count > 0) {
+ foreach (string element in repeatedCordField_) {
+ output.WriteString(12, element);
+ }
}
UnknownFields.WriteTo(output);
}
@@ -9995,23 +10232,50 @@ namespace Google.ProtocolBuffers.TestProtos {
if (HasCordField) {
size += pb::CodedOutputStream.ComputeStringSize(6, CordField);
}
- foreach (int element in RepeatedPrimitiveFieldList) {
- size += pb::CodedOutputStream.ComputeInt32Size(7, element);
+ {
+ int dataSize = 0;
+ foreach (int element in RepeatedPrimitiveFieldList) {
+ dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 1 * repeatedPrimitiveField_.Count;
}
- foreach (string element in RepeatedStringFieldList) {
- size += pb::CodedOutputStream.ComputeStringSize(8, element);
+ {
+ int dataSize = 0;
+ foreach (string element in RepeatedStringFieldList) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 1 * repeatedStringField_.Count;
}
- foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedEnumFieldList) {
- size += pb::CodedOutputStream.ComputeEnumSize(9, (int) element);
+ {
+ int dataSize = 0;
+ if (repeatedEnumField_.Count > 0) {
+ foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in repeatedEnumField_) {
+ dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element);
+ }
+ size += dataSize;
+ size += 1 * repeatedEnumField_.Count;
+ }
}
foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedMessageFieldList) {
size += pb::CodedOutputStream.ComputeMessageSize(10, element);
}
- foreach (string element in RepeatedStringPieceFieldList) {
- size += pb::CodedOutputStream.ComputeStringSize(11, element);
+ {
+ int dataSize = 0;
+ foreach (string element in RepeatedStringPieceFieldList) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 1 * repeatedStringPieceField_.Count;
}
- foreach (string element in RepeatedCordFieldList) {
- size += pb::CodedOutputStream.ComputeStringSize(12, element);
+ {
+ int dataSize = 0;
+ foreach (string element in RepeatedCordFieldList) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 1 * repeatedCordField_.Count;
}
size += UnknownFields.SerializedSize;
memoizedSerializedSize = size;
@@ -11209,6 +11473,1260 @@ namespace Google.ProtocolBuffers.TestProtos {
}
}
+ public sealed partial class TestPackedTypes : pb::GeneratedMessage {
+ private static readonly TestPackedTypes defaultInstance = new Builder().BuildPartial();
+ public static TestPackedTypes DefaultInstance {
+ get { return defaultInstance; }
+ }
+
+ public override TestPackedTypes DefaultInstanceForType {
+ get { return defaultInstance; }
+ }
+
+ protected override TestPackedTypes ThisMessage {
+ get { return this; }
+ }
+
+ public static pbd::MessageDescriptor Descriptor {
+ get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestPackedTypes__Descriptor; }
+ }
+
+ protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors {
+ get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestPackedTypes__FieldAccessorTable; }
+ }
+
+ private int packedInt32MemoizedSerializedSize;
+ private pbc::PopsicleList packedInt32_ = new pbc::PopsicleList();
+ public scg::IList PackedInt32List {
+ get { return pbc::Lists.AsReadOnly(packedInt32_); }
+ }
+ public int PackedInt32Count {
+ get { return packedInt32_.Count; }
+ }
+ public int GetPackedInt32(int index) {
+ return packedInt32_[index];
+ }
+
+ private int packedInt64MemoizedSerializedSize;
+ private pbc::PopsicleList packedInt64_ = new pbc::PopsicleList();
+ public scg::IList PackedInt64List {
+ get { return pbc::Lists.AsReadOnly(packedInt64_); }
+ }
+ public int PackedInt64Count {
+ get { return packedInt64_.Count; }
+ }
+ public long GetPackedInt64(int index) {
+ return packedInt64_[index];
+ }
+
+ private int packedUint32MemoizedSerializedSize;
+ private pbc::PopsicleList packedUint32_ = new pbc::PopsicleList();
+ public scg::IList PackedUint32List {
+ get { return pbc::Lists.AsReadOnly(packedUint32_); }
+ }
+ public int PackedUint32Count {
+ get { return packedUint32_.Count; }
+ }
+ public uint GetPackedUint32(int index) {
+ return packedUint32_[index];
+ }
+
+ private int packedUint64MemoizedSerializedSize;
+ private pbc::PopsicleList packedUint64_ = new pbc::PopsicleList();
+ public scg::IList PackedUint64List {
+ get { return pbc::Lists.AsReadOnly(packedUint64_); }
+ }
+ public int PackedUint64Count {
+ get { return packedUint64_.Count; }
+ }
+ public ulong GetPackedUint64(int index) {
+ return packedUint64_[index];
+ }
+
+ private int packedSint32MemoizedSerializedSize;
+ private pbc::PopsicleList packedSint32_ = new pbc::PopsicleList();
+ public scg::IList PackedSint32List {
+ get { return pbc::Lists.AsReadOnly(packedSint32_); }
+ }
+ public int PackedSint32Count {
+ get { return packedSint32_.Count; }
+ }
+ public int GetPackedSint32(int index) {
+ return packedSint32_[index];
+ }
+
+ private int packedSint64MemoizedSerializedSize;
+ private pbc::PopsicleList packedSint64_ = new pbc::PopsicleList();
+ public scg::IList PackedSint64List {
+ get { return pbc::Lists.AsReadOnly(packedSint64_); }
+ }
+ public int PackedSint64Count {
+ get { return packedSint64_.Count; }
+ }
+ public long GetPackedSint64(int index) {
+ return packedSint64_[index];
+ }
+
+ private int packedFixed32MemoizedSerializedSize;
+ private pbc::PopsicleList packedFixed32_ = new pbc::PopsicleList();
+ public scg::IList PackedFixed32List {
+ get { return pbc::Lists.AsReadOnly(packedFixed32_); }
+ }
+ public int PackedFixed32Count {
+ get { return packedFixed32_.Count; }
+ }
+ public uint GetPackedFixed32(int index) {
+ return packedFixed32_[index];
+ }
+
+ private int packedFixed64MemoizedSerializedSize;
+ private pbc::PopsicleList packedFixed64_ = new pbc::PopsicleList();
+ public scg::IList PackedFixed64List {
+ get { return pbc::Lists.AsReadOnly(packedFixed64_); }
+ }
+ public int PackedFixed64Count {
+ get { return packedFixed64_.Count; }
+ }
+ public ulong GetPackedFixed64(int index) {
+ return packedFixed64_[index];
+ }
+
+ private int packedSfixed32MemoizedSerializedSize;
+ private pbc::PopsicleList packedSfixed32_ = new pbc::PopsicleList();
+ public scg::IList PackedSfixed32List {
+ get { return pbc::Lists.AsReadOnly(packedSfixed32_); }
+ }
+ public int PackedSfixed32Count {
+ get { return packedSfixed32_.Count; }
+ }
+ public int GetPackedSfixed32(int index) {
+ return packedSfixed32_[index];
+ }
+
+ private int packedSfixed64MemoizedSerializedSize;
+ private pbc::PopsicleList packedSfixed64_ = new pbc::PopsicleList();
+ public scg::IList PackedSfixed64List {
+ get { return pbc::Lists.AsReadOnly(packedSfixed64_); }
+ }
+ public int PackedSfixed64Count {
+ get { return packedSfixed64_.Count; }
+ }
+ public long GetPackedSfixed64(int index) {
+ return packedSfixed64_[index];
+ }
+
+ private int packedFloatMemoizedSerializedSize;
+ private pbc::PopsicleList packedFloat_ = new pbc::PopsicleList();
+ public scg::IList PackedFloatList {
+ get { return pbc::Lists.AsReadOnly(packedFloat_); }
+ }
+ public int PackedFloatCount {
+ get { return packedFloat_.Count; }
+ }
+ public float GetPackedFloat(int index) {
+ return packedFloat_[index];
+ }
+
+ private int packedDoubleMemoizedSerializedSize;
+ private pbc::PopsicleList packedDouble_ = new pbc::PopsicleList();
+ public scg::IList PackedDoubleList {
+ get { return pbc::Lists.AsReadOnly(packedDouble_); }
+ }
+ public int PackedDoubleCount {
+ get { return packedDouble_.Count; }
+ }
+ public double GetPackedDouble(int index) {
+ return packedDouble_[index];
+ }
+
+ private int packedBoolMemoizedSerializedSize;
+ private pbc::PopsicleList packedBool_ = new pbc::PopsicleList();
+ public scg::IList PackedBoolList {
+ get { return pbc::Lists.AsReadOnly(packedBool_); }
+ }
+ public int PackedBoolCount {
+ get { return packedBool_.Count; }
+ }
+ public bool GetPackedBool(int index) {
+ return packedBool_[index];
+ }
+
+ private int packedEnumMemoizedSerializedSize;
+ private pbc::PopsicleList packedEnum_ = new pbc::PopsicleList();
+ public scg::IList PackedEnumList {
+ get { return pbc::Lists.AsReadOnly(packedEnum_); }
+ }
+ public int PackedEnumCount {
+ get { return packedEnum_.Count; }
+ }
+ public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetPackedEnum(int index) {
+ return packedEnum_[index];
+ }
+
+ public override bool IsInitialized {
+ get {
+ return true;
+ }
+ }
+
+ public override void WriteTo(pb::CodedOutputStream output) {
+ if (packedInt32_.Count > 0) {
+ output.WriteRawVarint32(722);
+ output.WriteRawVarint32((uint) packedInt32MemoizedSerializedSize);
+ foreach (int element in packedInt32_) {
+ output.WriteInt32NoTag(element);
+ }
+ }
+ if (packedInt64_.Count > 0) {
+ output.WriteRawVarint32(730);
+ output.WriteRawVarint32((uint) packedInt64MemoizedSerializedSize);
+ foreach (long element in packedInt64_) {
+ output.WriteInt64NoTag(element);
+ }
+ }
+ if (packedUint32_.Count > 0) {
+ output.WriteRawVarint32(738);
+ output.WriteRawVarint32((uint) packedUint32MemoizedSerializedSize);
+ foreach (uint element in packedUint32_) {
+ output.WriteUInt32NoTag(element);
+ }
+ }
+ if (packedUint64_.Count > 0) {
+ output.WriteRawVarint32(746);
+ output.WriteRawVarint32((uint) packedUint64MemoizedSerializedSize);
+ foreach (ulong element in packedUint64_) {
+ output.WriteUInt64NoTag(element);
+ }
+ }
+ if (packedSint32_.Count > 0) {
+ output.WriteRawVarint32(754);
+ output.WriteRawVarint32((uint) packedSint32MemoizedSerializedSize);
+ foreach (int element in packedSint32_) {
+ output.WriteSInt32NoTag(element);
+ }
+ }
+ if (packedSint64_.Count > 0) {
+ output.WriteRawVarint32(762);
+ output.WriteRawVarint32((uint) packedSint64MemoizedSerializedSize);
+ foreach (long element in packedSint64_) {
+ output.WriteSInt64NoTag(element);
+ }
+ }
+ if (packedFixed32_.Count > 0) {
+ output.WriteRawVarint32(770);
+ output.WriteRawVarint32((uint) packedFixed32MemoizedSerializedSize);
+ foreach (uint element in packedFixed32_) {
+ output.WriteFixed32NoTag(element);
+ }
+ }
+ if (packedFixed64_.Count > 0) {
+ output.WriteRawVarint32(778);
+ output.WriteRawVarint32((uint) packedFixed64MemoizedSerializedSize);
+ foreach (ulong element in packedFixed64_) {
+ output.WriteFixed64NoTag(element);
+ }
+ }
+ if (packedSfixed32_.Count > 0) {
+ output.WriteRawVarint32(786);
+ output.WriteRawVarint32((uint) packedSfixed32MemoizedSerializedSize);
+ foreach (int element in packedSfixed32_) {
+ output.WriteSFixed32NoTag(element);
+ }
+ }
+ if (packedSfixed64_.Count > 0) {
+ output.WriteRawVarint32(794);
+ output.WriteRawVarint32((uint) packedSfixed64MemoizedSerializedSize);
+ foreach (long element in packedSfixed64_) {
+ output.WriteSFixed64NoTag(element);
+ }
+ }
+ if (packedFloat_.Count > 0) {
+ output.WriteRawVarint32(802);
+ output.WriteRawVarint32((uint) packedFloatMemoizedSerializedSize);
+ foreach (float element in packedFloat_) {
+ output.WriteFloatNoTag(element);
+ }
+ }
+ if (packedDouble_.Count > 0) {
+ output.WriteRawVarint32(810);
+ output.WriteRawVarint32((uint) packedDoubleMemoizedSerializedSize);
+ foreach (double element in packedDouble_) {
+ output.WriteDoubleNoTag(element);
+ }
+ }
+ if (packedBool_.Count > 0) {
+ output.WriteRawVarint32(818);
+ output.WriteRawVarint32((uint) packedBoolMemoizedSerializedSize);
+ foreach (bool element in packedBool_) {
+ output.WriteBoolNoTag(element);
+ }
+ }
+ if (packedEnum_.Count > 0) {
+ output.WriteRawVarint32(826);
+ output.WriteRawVarint32((uint) packedEnumMemoizedSerializedSize);
+ foreach (int element in packedEnum_) {
+ output.WriteEnumNoTag(element);
+ }
+ }
+ UnknownFields.WriteTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public override int SerializedSize {
+ get {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ {
+ int dataSize = 0;
+ foreach (int element in PackedInt32List) {
+ dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedInt32MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ foreach (long element in PackedInt64List) {
+ dataSize += pb::CodedOutputStream.ComputeInt64SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedInt64MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ foreach (uint element in PackedUint32List) {
+ dataSize += pb::CodedOutputStream.ComputeUInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedUint32MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ foreach (ulong element in PackedUint64List) {
+ dataSize += pb::CodedOutputStream.ComputeUInt64SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedUint64MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ foreach (int element in PackedSint32List) {
+ dataSize += pb::CodedOutputStream.ComputeSInt32SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedSint32MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ foreach (long element in PackedSint64List) {
+ dataSize += pb::CodedOutputStream.ComputeSInt64SizeNoTag(element);
+ }
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedSint64MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 4 * packedFixed32_.Count;
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedFixed32MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 8 * packedFixed64_.Count;
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedFixed64MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 4 * packedSfixed32_.Count;
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedSfixed32MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 8 * packedSfixed64_.Count;
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedSfixed64MemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 4 * packedFloat_.Count;
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedFloatMemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 8 * packedDouble_.Count;
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedDoubleMemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ dataSize = 1 * packedBool_.Count;
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
+ packedBoolMemoizedSerializedSize = dataSize;
+ }
+ {
+ int dataSize = 0;
+ if (packedEnum_.Count > 0) {
+ foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in packedEnum_) {
+ dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element);
+ }
+ size += dataSize;
+ size += 2;
+ size += pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
+ }
+ packedEnumMemoizedSerializedSize = dataSize;
+ }
+ size += UnknownFields.SerializedSize;
+ memoizedSerializedSize = size;
+ return size;
+ }
+ }
+
+ public static TestPackedTypes ParseFrom(pb::ByteString data) {
+ return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+ }
+ public static TestPackedTypes ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+ return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+ }
+ public static TestPackedTypes ParseFrom(byte[] data) {
+ return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+ }
+ public static TestPackedTypes ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+ return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+ }
+ public static TestPackedTypes ParseFrom(global::System.IO.Stream input) {
+ return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+ }
+ public static TestPackedTypes ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+ return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+ }
+ public static TestPackedTypes ParseFrom(pb::CodedInputStream input) {
+ return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+ }
+ public static TestPackedTypes ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+ return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+ }
+ public static Builder CreateBuilder() { return new Builder(); }
+ public override Builder CreateBuilderForType() { return new Builder(); }
+ public static Builder CreateBuilder(TestPackedTypes prototype) {
+ return (Builder) new Builder().MergeFrom(prototype);
+ }
+
+ public sealed partial class Builder : pb::GeneratedBuilder {
+ protected override Builder ThisBuilder {
+ get { return this; }
+ }
+ public Builder() {}
+
+ TestPackedTypes result = new TestPackedTypes();
+
+ protected override TestPackedTypes MessageBeingBuilt {
+ get { return result; }
+ }
+
+ public override Builder Clear() {
+ result = new TestPackedTypes();
+ return this;
+ }
+
+ public override Builder Clone() {
+ return new Builder().MergeFrom(result);
+ }
+
+ public override pbd::MessageDescriptor DescriptorForType {
+ get { return TestPackedTypes.Descriptor; }
+ }
+
+ public override TestPackedTypes DefaultInstanceForType {
+ get { return TestPackedTypes.DefaultInstance; }
+ }
+
+ public override TestPackedTypes BuildPartial() {
+ result.packedInt32_.MakeReadOnly();
+ result.packedInt64_.MakeReadOnly();
+ result.packedUint32_.MakeReadOnly();
+ result.packedUint64_.MakeReadOnly();
+ result.packedSint32_.MakeReadOnly();
+ result.packedSint64_.MakeReadOnly();
+ result.packedFixed32_.MakeReadOnly();
+ result.packedFixed64_.MakeReadOnly();
+ result.packedSfixed32_.MakeReadOnly();
+ result.packedSfixed64_.MakeReadOnly();
+ result.packedFloat_.MakeReadOnly();
+ result.packedDouble_.MakeReadOnly();
+ result.packedBool_.MakeReadOnly();
+ result.packedEnum_.MakeReadOnly();
+ TestPackedTypes returnMe = result;
+ result = null;
+ return returnMe;
+ }
+
+ public override Builder MergeFrom(pb::IMessage other) {
+ if (other is TestPackedTypes) {
+ return MergeFrom((TestPackedTypes) other);
+ } else {
+ base.MergeFrom(other);
+ return this;
+ }
+ }
+
+ public override Builder MergeFrom(TestPackedTypes other) {
+ if (other == TestPackedTypes.DefaultInstance) return this;
+ if (other.packedInt32_.Count != 0) {
+ base.AddRange(other.packedInt32_, result.packedInt32_);
+ }
+ if (other.packedInt64_.Count != 0) {
+ base.AddRange(other.packedInt64_, result.packedInt64_);
+ }
+ if (other.packedUint32_.Count != 0) {
+ base.AddRange(other.packedUint32_, result.packedUint32_);
+ }
+ if (other.packedUint64_.Count != 0) {
+ base.AddRange(other.packedUint64_, result.packedUint64_);
+ }
+ if (other.packedSint32_.Count != 0) {
+ base.AddRange(other.packedSint32_, result.packedSint32_);
+ }
+ if (other.packedSint64_.Count != 0) {
+ base.AddRange(other.packedSint64_, result.packedSint64_);
+ }
+ if (other.packedFixed32_.Count != 0) {
+ base.AddRange(other.packedFixed32_, result.packedFixed32_);
+ }
+ if (other.packedFixed64_.Count != 0) {
+ base.AddRange(other.packedFixed64_, result.packedFixed64_);
+ }
+ if (other.packedSfixed32_.Count != 0) {
+ base.AddRange(other.packedSfixed32_, result.packedSfixed32_);
+ }
+ if (other.packedSfixed64_.Count != 0) {
+ base.AddRange(other.packedSfixed64_, result.packedSfixed64_);
+ }
+ if (other.packedFloat_.Count != 0) {
+ base.AddRange(other.packedFloat_, result.packedFloat_);
+ }
+ if (other.packedDouble_.Count != 0) {
+ base.AddRange(other.packedDouble_, result.packedDouble_);
+ }
+ if (other.packedBool_.Count != 0) {
+ base.AddRange(other.packedBool_, result.packedBool_);
+ }
+ if (other.packedEnum_.Count != 0) {
+ base.AddRange(other.packedEnum_, result.packedEnum_);
+ }
+ this.MergeUnknownFields(other.UnknownFields);
+ return this;
+ }
+
+ public override Builder MergeFrom(pb::CodedInputStream input) {
+ return MergeFrom(input, pb::ExtensionRegistry.Empty);
+ }
+
+ public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+ pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+ while (true) {
+ uint tag = input.ReadTag();
+ switch (tag) {
+ case 0: {
+ this.UnknownFields = unknownFields.Build();
+ return this;
+ }
+ default: {
+ if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
+ this.UnknownFields = unknownFields.Build();
+ return this;
+ }
+ break;
+ }
+ case 722: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedInt32(input.ReadInt32());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 730: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedInt64(input.ReadInt64());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 738: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedUint32(input.ReadUInt32());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 746: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedUint64(input.ReadUInt64());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 754: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedSint32(input.ReadSInt32());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 762: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedSint64(input.ReadSInt64());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 770: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedFixed32(input.ReadFixed32());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 778: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedFixed64(input.ReadFixed64());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 786: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedSfixed32(input.ReadSFixed32());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 794: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedSfixed64(input.ReadSFixed64());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 802: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedFloat(input.ReadFloat());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 810: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedDouble(input.ReadDouble());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 818: {
+ int length = input.ReadInt32();
+ int limit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ AddPackedBool(input.ReadBool());
+ }
+ input.PopLimit(limit);
+ break;
+ }
+ case 826: {
+ int length = input.ReadInt32();
+ int oldLimit = input.PushLimit(length);
+ while (!input.ReachedLimit) {
+ int rawValue = input.ReadEnum();
+ if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) {
+ unknownFields.MergeVarintField(103, (ulong) rawValue);
+ } else {
+ AddPackedEnum((global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue);
+ }
+ }
+ input.PopLimit(oldLimit);
+ break;
+ }
+ }
+ }
+ }
+
+
+ public scg::IList PackedInt32List {
+ get { return result.packedInt32_; }
+ }
+ public int PackedInt32Count {
+ get { return result.PackedInt32Count; }
+ }
+ public int GetPackedInt32(int index) {
+ return result.GetPackedInt32(index);
+ }
+ public Builder SetPackedInt32(int index, int value) {
+ result.packedInt32_[index] = value;
+ return this;
+ }
+ public Builder AddPackedInt32(int value) {
+ result.packedInt32_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedInt32(scg::IEnumerable values) {
+ base.AddRange(values, result.packedInt32_);
+ return this;
+ }
+ public Builder ClearPackedInt32() {
+ result.packedInt32_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedInt64List {
+ get { return result.packedInt64_; }
+ }
+ public int PackedInt64Count {
+ get { return result.PackedInt64Count; }
+ }
+ public long GetPackedInt64(int index) {
+ return result.GetPackedInt64(index);
+ }
+ public Builder SetPackedInt64(int index, long value) {
+ result.packedInt64_[index] = value;
+ return this;
+ }
+ public Builder AddPackedInt64(long value) {
+ result.packedInt64_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedInt64(scg::IEnumerable values) {
+ base.AddRange(values, result.packedInt64_);
+ return this;
+ }
+ public Builder ClearPackedInt64() {
+ result.packedInt64_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedUint32List {
+ get { return result.packedUint32_; }
+ }
+ public int PackedUint32Count {
+ get { return result.PackedUint32Count; }
+ }
+ public uint GetPackedUint32(int index) {
+ return result.GetPackedUint32(index);
+ }
+ public Builder SetPackedUint32(int index, uint value) {
+ result.packedUint32_[index] = value;
+ return this;
+ }
+ public Builder AddPackedUint32(uint value) {
+ result.packedUint32_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedUint32(scg::IEnumerable values) {
+ base.AddRange(values, result.packedUint32_);
+ return this;
+ }
+ public Builder ClearPackedUint32() {
+ result.packedUint32_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedUint64List {
+ get { return result.packedUint64_; }
+ }
+ public int PackedUint64Count {
+ get { return result.PackedUint64Count; }
+ }
+ public ulong GetPackedUint64(int index) {
+ return result.GetPackedUint64(index);
+ }
+ public Builder SetPackedUint64(int index, ulong value) {
+ result.packedUint64_[index] = value;
+ return this;
+ }
+ public Builder AddPackedUint64(ulong value) {
+ result.packedUint64_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedUint64(scg::IEnumerable values) {
+ base.AddRange(values, result.packedUint64_);
+ return this;
+ }
+ public Builder ClearPackedUint64() {
+ result.packedUint64_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedSint32List {
+ get { return result.packedSint32_; }
+ }
+ public int PackedSint32Count {
+ get { return result.PackedSint32Count; }
+ }
+ public int GetPackedSint32(int index) {
+ return result.GetPackedSint32(index);
+ }
+ public Builder SetPackedSint32(int index, int value) {
+ result.packedSint32_[index] = value;
+ return this;
+ }
+ public Builder AddPackedSint32(int value) {
+ result.packedSint32_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedSint32(scg::IEnumerable values) {
+ base.AddRange(values, result.packedSint32_);
+ return this;
+ }
+ public Builder ClearPackedSint32() {
+ result.packedSint32_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedSint64List {
+ get { return result.packedSint64_; }
+ }
+ public int PackedSint64Count {
+ get { return result.PackedSint64Count; }
+ }
+ public long GetPackedSint64(int index) {
+ return result.GetPackedSint64(index);
+ }
+ public Builder SetPackedSint64(int index, long value) {
+ result.packedSint64_[index] = value;
+ return this;
+ }
+ public Builder AddPackedSint64(long value) {
+ result.packedSint64_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedSint64(scg::IEnumerable values) {
+ base.AddRange(values, result.packedSint64_);
+ return this;
+ }
+ public Builder ClearPackedSint64() {
+ result.packedSint64_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedFixed32List {
+ get { return result.packedFixed32_; }
+ }
+ public int PackedFixed32Count {
+ get { return result.PackedFixed32Count; }
+ }
+ public uint GetPackedFixed32(int index) {
+ return result.GetPackedFixed32(index);
+ }
+ public Builder SetPackedFixed32(int index, uint value) {
+ result.packedFixed32_[index] = value;
+ return this;
+ }
+ public Builder AddPackedFixed32(uint value) {
+ result.packedFixed32_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedFixed32(scg::IEnumerable values) {
+ base.AddRange(values, result.packedFixed32_);
+ return this;
+ }
+ public Builder ClearPackedFixed32() {
+ result.packedFixed32_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedFixed64List {
+ get { return result.packedFixed64_; }
+ }
+ public int PackedFixed64Count {
+ get { return result.PackedFixed64Count; }
+ }
+ public ulong GetPackedFixed64(int index) {
+ return result.GetPackedFixed64(index);
+ }
+ public Builder SetPackedFixed64(int index, ulong value) {
+ result.packedFixed64_[index] = value;
+ return this;
+ }
+ public Builder AddPackedFixed64(ulong value) {
+ result.packedFixed64_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedFixed64(scg::IEnumerable values) {
+ base.AddRange(values, result.packedFixed64_);
+ return this;
+ }
+ public Builder ClearPackedFixed64() {
+ result.packedFixed64_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedSfixed32List {
+ get { return result.packedSfixed32_; }
+ }
+ public int PackedSfixed32Count {
+ get { return result.PackedSfixed32Count; }
+ }
+ public int GetPackedSfixed32(int index) {
+ return result.GetPackedSfixed32(index);
+ }
+ public Builder SetPackedSfixed32(int index, int value) {
+ result.packedSfixed32_[index] = value;
+ return this;
+ }
+ public Builder AddPackedSfixed32(int value) {
+ result.packedSfixed32_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedSfixed32(scg::IEnumerable values) {
+ base.AddRange(values, result.packedSfixed32_);
+ return this;
+ }
+ public Builder ClearPackedSfixed32() {
+ result.packedSfixed32_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedSfixed64List {
+ get { return result.packedSfixed64_; }
+ }
+ public int PackedSfixed64Count {
+ get { return result.PackedSfixed64Count; }
+ }
+ public long GetPackedSfixed64(int index) {
+ return result.GetPackedSfixed64(index);
+ }
+ public Builder SetPackedSfixed64(int index, long value) {
+ result.packedSfixed64_[index] = value;
+ return this;
+ }
+ public Builder AddPackedSfixed64(long value) {
+ result.packedSfixed64_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedSfixed64(scg::IEnumerable values) {
+ base.AddRange(values, result.packedSfixed64_);
+ return this;
+ }
+ public Builder ClearPackedSfixed64() {
+ result.packedSfixed64_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedFloatList {
+ get { return result.packedFloat_; }
+ }
+ public int PackedFloatCount {
+ get { return result.PackedFloatCount; }
+ }
+ public float GetPackedFloat(int index) {
+ return result.GetPackedFloat(index);
+ }
+ public Builder SetPackedFloat(int index, float value) {
+ result.packedFloat_[index] = value;
+ return this;
+ }
+ public Builder AddPackedFloat(float value) {
+ result.packedFloat_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedFloat(scg::IEnumerable values) {
+ base.AddRange(values, result.packedFloat_);
+ return this;
+ }
+ public Builder ClearPackedFloat() {
+ result.packedFloat_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedDoubleList {
+ get { return result.packedDouble_; }
+ }
+ public int PackedDoubleCount {
+ get { return result.PackedDoubleCount; }
+ }
+ public double GetPackedDouble(int index) {
+ return result.GetPackedDouble(index);
+ }
+ public Builder SetPackedDouble(int index, double value) {
+ result.packedDouble_[index] = value;
+ return this;
+ }
+ public Builder AddPackedDouble(double value) {
+ result.packedDouble_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedDouble(scg::IEnumerable values) {
+ base.AddRange(values, result.packedDouble_);
+ return this;
+ }
+ public Builder ClearPackedDouble() {
+ result.packedDouble_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedBoolList {
+ get { return result.packedBool_; }
+ }
+ public int PackedBoolCount {
+ get { return result.PackedBoolCount; }
+ }
+ public bool GetPackedBool(int index) {
+ return result.GetPackedBool(index);
+ }
+ public Builder SetPackedBool(int index, bool value) {
+ result.packedBool_[index] = value;
+ return this;
+ }
+ public Builder AddPackedBool(bool value) {
+ result.packedBool_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedBool(scg::IEnumerable values) {
+ base.AddRange(values, result.packedBool_);
+ return this;
+ }
+ public Builder ClearPackedBool() {
+ result.packedBool_.Clear();
+ return this;
+ }
+
+ public scg::IList PackedEnumList {
+ get { return result.packedEnum_; }
+ }
+ public int PackedEnumCount {
+ get { return result.PackedEnumCount; }
+ }
+ public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetPackedEnum(int index) {
+ return result.GetPackedEnum(index);
+ }
+ public Builder SetPackedEnum(int index, global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) {
+ result.packedEnum_[index] = value;
+ return this;
+ }
+ public Builder AddPackedEnum(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) {
+ result.packedEnum_.Add(value);
+ return this;
+ }
+ public Builder AddRangePackedEnum(scg::IEnumerable values) {
+ base.AddRange(values, result.packedEnum_);
+ return this;
+ }
+ public Builder ClearPackedEnum() {
+ result.packedEnum_.Clear();
+ return this;
+ }
+ }
+ }
+
+ public sealed partial class TestPackedExtensions : pb::ExtendableMessage {
+ private static readonly TestPackedExtensions defaultInstance = new Builder().BuildPartial();
+ public static TestPackedExtensions DefaultInstance {
+ get { return defaultInstance; }
+ }
+
+ public override TestPackedExtensions DefaultInstanceForType {
+ get { return defaultInstance; }
+ }
+
+ protected override TestPackedExtensions ThisMessage {
+ get { return this; }
+ }
+
+ public static pbd::MessageDescriptor Descriptor {
+ get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestPackedExtensions__Descriptor; }
+ }
+
+ protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors {
+ get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestPackedExtensions__FieldAccessorTable; }
+ }
+
+ public override bool IsInitialized {
+ get {
+ if (!ExtensionsAreInitialized) return false;
+ return true;
+ }
+ }
+
+ public override void WriteTo(pb::CodedOutputStream output) {
+ pb::ExtendableMessage.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
+ extensionWriter.WriteUntil(536870912, output);
+ UnknownFields.WriteTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public override int SerializedSize {
+ get {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ size += ExtensionsSerializedSize;
+ size += UnknownFields.SerializedSize;
+ memoizedSerializedSize = size;
+ return size;
+ }
+ }
+
+ public static TestPackedExtensions ParseFrom(pb::ByteString data) {
+ return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+ }
+ public static TestPackedExtensions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+ return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+ }
+ public static TestPackedExtensions ParseFrom(byte[] data) {
+ return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+ }
+ public static TestPackedExtensions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+ return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+ }
+ public static TestPackedExtensions ParseFrom(global::System.IO.Stream input) {
+ return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+ }
+ public static TestPackedExtensions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+ return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+ }
+ public static TestPackedExtensions ParseFrom(pb::CodedInputStream input) {
+ return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+ }
+ public static TestPackedExtensions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+ return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+ }
+ public static Builder CreateBuilder() { return new Builder(); }
+ public override Builder CreateBuilderForType() { return new Builder(); }
+ public static Builder CreateBuilder(TestPackedExtensions prototype) {
+ return (Builder) new Builder().MergeFrom(prototype);
+ }
+
+ public sealed partial class Builder : pb::ExtendableBuilder {
+ protected override Builder ThisBuilder {
+ get { return this; }
+ }
+ public Builder() {}
+
+ TestPackedExtensions result = new TestPackedExtensions();
+
+ protected override TestPackedExtensions MessageBeingBuilt {
+ get { return result; }
+ }
+
+ public override Builder Clear() {
+ result = new TestPackedExtensions();
+ return this;
+ }
+
+ public override Builder Clone() {
+ return new Builder().MergeFrom(result);
+ }
+
+ public override pbd::MessageDescriptor DescriptorForType {
+ get { return TestPackedExtensions.Descriptor; }
+ }
+
+ public override TestPackedExtensions DefaultInstanceForType {
+ get { return TestPackedExtensions.DefaultInstance; }
+ }
+
+ public override TestPackedExtensions BuildPartial() {
+ TestPackedExtensions returnMe = result;
+ result = null;
+ return returnMe;
+ }
+
+ public override Builder MergeFrom(pb::IMessage other) {
+ if (other is TestPackedExtensions) {
+ return MergeFrom((TestPackedExtensions) other);
+ } else {
+ base.MergeFrom(other);
+ return this;
+ }
+ }
+
+ public override Builder MergeFrom(TestPackedExtensions other) {
+ if (other == TestPackedExtensions.DefaultInstance) return this;
+ this.MergeExtensionFields(other);
+ this.MergeUnknownFields(other.UnknownFields);
+ return this;
+ }
+
+ public override Builder MergeFrom(pb::CodedInputStream input) {
+ return MergeFrom(input, pb::ExtensionRegistry.Empty);
+ }
+
+ public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+ pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+ while (true) {
+ uint tag = input.ReadTag();
+ switch (tag) {
+ case 0: {
+ this.UnknownFields = unknownFields.Build();
+ return this;
+ }
+ default: {
+ if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
+ this.UnknownFields = unknownFields.Build();
+ return this;
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ }
+ }
+
public sealed partial class FooRequest : pb::GeneratedMessage {
private static readonly FooRequest defaultInstance = new Builder().BuildPartial();
public static FooRequest DefaultInstance {
diff --git a/src/ProtocolBuffers.Test/TestUtil.cs b/src/ProtocolBuffers.Test/TestUtil.cs
index 47262ff9b9..3e89dd7514 100644
--- a/src/ProtocolBuffers.Test/TestUtil.cs
+++ b/src/ProtocolBuffers.Test/TestUtil.cs
@@ -158,6 +158,21 @@ namespace Google.ProtocolBuffers {
registry.Add(UnitTestProtoFile.DefaultImportEnumExtension);
registry.Add(UnitTestProtoFile.DefaultStringPieceExtension);
registry.Add(UnitTestProtoFile.DefaultCordExtension);
+
+ registry.Add(UnitTestProtoFile.PackedInt32Extension);
+ registry.Add(UnitTestProtoFile.PackedInt64Extension);
+ registry.Add(UnitTestProtoFile.PackedUint32Extension);
+ registry.Add(UnitTestProtoFile.PackedUint64Extension);
+ registry.Add(UnitTestProtoFile.PackedSint32Extension);
+ registry.Add(UnitTestProtoFile.PackedSint64Extension);
+ registry.Add(UnitTestProtoFile.PackedFixed32Extension);
+ registry.Add(UnitTestProtoFile.PackedFixed64Extension);
+ registry.Add(UnitTestProtoFile.PackedSfixed32Extension);
+ registry.Add(UnitTestProtoFile.PackedSfixed64Extension);
+ registry.Add(UnitTestProtoFile.PackedFloatExtension);
+ registry.Add(UnitTestProtoFile.PackedDoubleExtension);
+ registry.Add(UnitTestProtoFile.PackedBoolExtension);
+ registry.Add(UnitTestProtoFile.PackedEnumExtension);
}
internal static string ReadTextFromFile(string filePath) {
@@ -653,6 +668,18 @@ namespace Google.ProtocolBuffers {
return builder.Build();
}
+ public static TestPackedTypes GetPackedSet() {
+ TestPackedTypes.Builder builder = TestPackedTypes.CreateBuilder();
+ SetPackedFields(builder);
+ return builder.Build();
+ }
+
+ public static TestPackedExtensions GetPackedExtensionsSet() {
+ TestPackedExtensions.Builder builder = TestPackedExtensions.CreateBuilder();
+ SetPackedExtensions(builder);
+ return builder.Build();
+ }
+
///
/// Sets every field of the specified builder to the values expected by
/// AssertAllExtensionsSet.
@@ -1373,6 +1400,184 @@ namespace Google.ProtocolBuffers {
Assert.AreEqual("123", message.GetExtension(UnitTestProtoFile.DefaultCordExtension));
}
+ ///
+ /// Set every field of the specified message to a unique value.
+ ///
+ public static void SetPackedFields(TestPackedTypes.Builder message) {
+ message.AddPackedInt32(601);
+ message.AddPackedInt64(602);
+ message.AddPackedUint32(603);
+ message.AddPackedUint64(604);
+ message.AddPackedSint32(605);
+ message.AddPackedSint64(606);
+ message.AddPackedFixed32(607);
+ message.AddPackedFixed64(608);
+ message.AddPackedSfixed32(609);
+ message.AddPackedSfixed64(610);
+ message.AddPackedFloat(611);
+ message.AddPackedDouble(612);
+ message.AddPackedBool(true);
+ message.AddPackedEnum(ForeignEnum.FOREIGN_BAR);
+ // Add a second one of each field.
+ message.AddPackedInt32(701);
+ message.AddPackedInt64(702);
+ message.AddPackedUint32(703);
+ message.AddPackedUint64(704);
+ message.AddPackedSint32(705);
+ message.AddPackedSint64(706);
+ message.AddPackedFixed32(707);
+ message.AddPackedFixed64(708);
+ message.AddPackedSfixed32(709);
+ message.AddPackedSfixed64(710);
+ message.AddPackedFloat(711);
+ message.AddPackedDouble(712);
+ message.AddPackedBool(false);
+ message.AddPackedEnum(ForeignEnum.FOREIGN_BAZ);
+ }
+
+ ///
+ /// Asserts that all the fields of the specified message are set to the values assigned
+ /// in SetPackedFields.
+ ///
+ public static void AssertPackedFieldsSet(TestPackedTypes message) {
+ Assert.AreEqual(2, message.PackedInt32Count);
+ Assert.AreEqual(2, message.PackedInt64Count);
+ Assert.AreEqual(2, message.PackedUint32Count);
+ Assert.AreEqual(2, message.PackedUint64Count);
+ Assert.AreEqual(2, message.PackedSint32Count);
+ Assert.AreEqual(2, message.PackedSint64Count);
+ Assert.AreEqual(2, message.PackedFixed32Count);
+ Assert.AreEqual(2, message.PackedFixed64Count);
+ Assert.AreEqual(2, message.PackedSfixed32Count);
+ Assert.AreEqual(2, message.PackedSfixed64Count);
+ Assert.AreEqual(2, message.PackedFloatCount);
+ Assert.AreEqual(2, message.PackedDoubleCount);
+ Assert.AreEqual(2, message.PackedBoolCount);
+ Assert.AreEqual(2, message.PackedEnumCount);
+ Assert.AreEqual(601, message.GetPackedInt32(0));
+ Assert.AreEqual(602, message.GetPackedInt64(0));
+ Assert.AreEqual(603, message.GetPackedUint32(0));
+ Assert.AreEqual(604, message.GetPackedUint64(0));
+ Assert.AreEqual(605, message.GetPackedSint32(0));
+ Assert.AreEqual(606, message.GetPackedSint64(0));
+ Assert.AreEqual(607, message.GetPackedFixed32(0));
+ Assert.AreEqual(608, message.GetPackedFixed64(0));
+ Assert.AreEqual(609, message.GetPackedSfixed32(0));
+ Assert.AreEqual(610, message.GetPackedSfixed64(0));
+ Assert.AreEqual(611, message.GetPackedFloat(0), 0.0);
+ Assert.AreEqual(612, message.GetPackedDouble(0), 0.0);
+ Assert.AreEqual(true, message.GetPackedBool(0));
+ Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetPackedEnum(0));
+ Assert.AreEqual(701, message.GetPackedInt32(1));
+ Assert.AreEqual(702, message.GetPackedInt64(1));
+ Assert.AreEqual(703, message.GetPackedUint32(1));
+ Assert.AreEqual(704, message.GetPackedUint64(1));
+ Assert.AreEqual(705, message.GetPackedSint32(1));
+ Assert.AreEqual(706, message.GetPackedSint64(1));
+ Assert.AreEqual(707, message.GetPackedFixed32(1));
+ Assert.AreEqual(708, message.GetPackedFixed64(1));
+ Assert.AreEqual(709, message.GetPackedSfixed32(1));
+ Assert.AreEqual(710, message.GetPackedSfixed64(1));
+ Assert.AreEqual(711, message.GetPackedFloat(1), 0.0);
+ Assert.AreEqual(712, message.GetPackedDouble(1), 0.0);
+ Assert.AreEqual(false, message.GetPackedBool(1));
+ Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetPackedEnum(1));
+ }
+
+ public static void SetPackedExtensions(TestPackedExtensions.Builder message) {
+ message.AddExtension(UnitTestProtoFile.PackedInt32Extension, 601);
+ message.AddExtension(UnitTestProtoFile.PackedInt64Extension, 602L);
+ message.AddExtension(UnitTestProtoFile.PackedUint32Extension, 603U);
+ message.AddExtension(UnitTestProtoFile.PackedUint64Extension, 604UL);
+ message.AddExtension(UnitTestProtoFile.PackedSint32Extension, 605);
+ message.AddExtension(UnitTestProtoFile.PackedSint64Extension, 606L);
+ message.AddExtension(UnitTestProtoFile.PackedFixed32Extension, 607U);
+ message.AddExtension(UnitTestProtoFile.PackedFixed64Extension, 608UL);
+ message.AddExtension(UnitTestProtoFile.PackedSfixed32Extension, 609);
+ message.AddExtension(UnitTestProtoFile.PackedSfixed64Extension, 610L);
+ message.AddExtension(UnitTestProtoFile.PackedFloatExtension, 611F);
+ message.AddExtension(UnitTestProtoFile.PackedDoubleExtension, 612D);
+ message.AddExtension(UnitTestProtoFile.PackedBoolExtension, true);
+ message.AddExtension(UnitTestProtoFile.PackedEnumExtension, ForeignEnum.FOREIGN_BAR);
+ // Add a second one of each field.
+ message.AddExtension(UnitTestProtoFile.PackedInt32Extension, 701);
+ message.AddExtension(UnitTestProtoFile.PackedInt64Extension, 702L);
+ message.AddExtension(UnitTestProtoFile.PackedUint32Extension, 703U);
+ message.AddExtension(UnitTestProtoFile.PackedUint64Extension, 704UL);
+ message.AddExtension(UnitTestProtoFile.PackedSint32Extension, 705);
+ message.AddExtension(UnitTestProtoFile.PackedSint64Extension, 706L);
+ message.AddExtension(UnitTestProtoFile.PackedFixed32Extension, 707U);
+ message.AddExtension(UnitTestProtoFile.PackedFixed64Extension, 708UL);
+ message.AddExtension(UnitTestProtoFile.PackedSfixed32Extension, 709);
+ message.AddExtension(UnitTestProtoFile.PackedSfixed64Extension, 710L);
+ message.AddExtension(UnitTestProtoFile.PackedFloatExtension, 711F);
+ message.AddExtension(UnitTestProtoFile.PackedDoubleExtension, 712D);
+ message.AddExtension(UnitTestProtoFile.PackedBoolExtension, false);
+ message.AddExtension(UnitTestProtoFile.PackedEnumExtension, ForeignEnum.FOREIGN_BAZ);
+ }
+
+ public static void AssertPackedExtensionsSet(TestPackedExtensions message) {
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedInt32Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedInt64Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedUint32Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedUint64Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedSint32Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedSint64Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedFixed32Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedFixed64Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedSfixed32Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedSfixed64Extension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedFloatExtension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedDoubleExtension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedBoolExtension));
+ Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.PackedEnumExtension));
+ Assert.AreEqual(601, message.GetExtension(UnitTestProtoFile.PackedInt32Extension, 0));
+ Assert.AreEqual(602L, message.GetExtension(UnitTestProtoFile.PackedInt64Extension, 0));
+ Assert.AreEqual(603, message.GetExtension(UnitTestProtoFile.PackedUint32Extension, 0));
+ Assert.AreEqual(604L, message.GetExtension(UnitTestProtoFile.PackedUint64Extension, 0));
+ Assert.AreEqual(605, message.GetExtension(UnitTestProtoFile.PackedSint32Extension, 0));
+ Assert.AreEqual(606L, message.GetExtension(UnitTestProtoFile.PackedSint64Extension, 0));
+ Assert.AreEqual(607, message.GetExtension(UnitTestProtoFile.PackedFixed32Extension, 0));
+ Assert.AreEqual(608L, message.GetExtension(UnitTestProtoFile.PackedFixed64Extension, 0));
+ Assert.AreEqual(609, message.GetExtension(UnitTestProtoFile.PackedSfixed32Extension, 0));
+ Assert.AreEqual(610L, message.GetExtension(UnitTestProtoFile.PackedSfixed64Extension, 0));
+ Assert.AreEqual(611F, message.GetExtension(UnitTestProtoFile.PackedFloatExtension, 0));
+ Assert.AreEqual(612D, message.GetExtension(UnitTestProtoFile.PackedDoubleExtension, 0));
+ Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.PackedBoolExtension, 0));
+ Assert.AreEqual(ForeignEnum.FOREIGN_BAR,
+ message.GetExtension(UnitTestProtoFile.PackedEnumExtension, 0));
+ Assert.AreEqual(701, message.GetExtension(UnitTestProtoFile.PackedInt32Extension, 1));
+ Assert.AreEqual(702L, message.GetExtension(UnitTestProtoFile.PackedInt64Extension, 1));
+ Assert.AreEqual(703, message.GetExtension(UnitTestProtoFile.PackedUint32Extension, 1));
+ Assert.AreEqual(704L, message.GetExtension(UnitTestProtoFile.PackedUint64Extension, 1));
+ Assert.AreEqual(705, message.GetExtension(UnitTestProtoFile.PackedSint32Extension, 1));
+ Assert.AreEqual(706L, message.GetExtension(UnitTestProtoFile.PackedSint64Extension, 1));
+ Assert.AreEqual(707, message.GetExtension(UnitTestProtoFile.PackedFixed32Extension, 1));
+ Assert.AreEqual(708L, message.GetExtension(UnitTestProtoFile.PackedFixed64Extension, 1));
+ Assert.AreEqual(709, message.GetExtension(UnitTestProtoFile.PackedSfixed32Extension, 1));
+ Assert.AreEqual(710L, message.GetExtension(UnitTestProtoFile.PackedSfixed64Extension, 1));
+ Assert.AreEqual(711F, message.GetExtension(UnitTestProtoFile.PackedFloatExtension, 1));
+ Assert.AreEqual(712D, message.GetExtension(UnitTestProtoFile.PackedDoubleExtension, 1));
+ Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.PackedBoolExtension, 1));
+ Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(UnitTestProtoFile.PackedEnumExtension, 1));
+ }
+
+ private static ByteString goldenPackedFieldsMessage = null;
+
+ ///
+ /// Get the bytes of the "golden packed fields message". This is a serialized
+ /// TestPackedTypes with all fields set as they would be by SetPackedFields,
+ /// but it is loaded from a file on disk rather than generated dynamically.
+ /// The file is actually generated by C++ code, so testing against it verifies compatibility
+ /// with C++.
+ ///
+ public static ByteString GetGoldenPackedFieldsMessage() {
+ if (goldenPackedFieldsMessage == null) {
+ goldenPackedFieldsMessage = ReadBytesFromFile("golden_packed_fields_message");
+ }
+ return goldenPackedFieldsMessage;
+ }
+
///
/// Helper to construct a byte array from a bunch of bytes.
///
diff --git a/src/ProtocolBuffers.Test/WireFormatTest.cs b/src/ProtocolBuffers.Test/WireFormatTest.cs
index 891cf357d8..b519d7a710 100644
--- a/src/ProtocolBuffers.Test/WireFormatTest.cs
+++ b/src/ProtocolBuffers.Test/WireFormatTest.cs
@@ -62,12 +62,20 @@ namespace Google.ProtocolBuffers {
TestUtil.AssertAllFieldsSet(message2);
}
+ [Test]
+ public void SerializationPacked() {
+ TestPackedTypes message = TestUtil.GetPackedSet();
+ ByteString rawBytes = message.ToByteString();
+ Assert.AreEqual(rawBytes.Length, message.SerializedSize);
+ TestPackedTypes message2 = TestPackedTypes.ParseFrom(rawBytes);
+ TestUtil.AssertPackedFieldsSet(message2);
+ }
+
[Test]
public void SerializeExtensions() {
// TestAllTypes and TestAllExtensions should have compatible wire formats,
- // so if we serealize a TestAllExtensions then parse it as TestAllTypes
+ // so if we serialize a TestAllExtensions then parse it as TestAllTypes
// it should work.
-
TestAllExtensions message = TestUtil.GetAllExtensionsSet();
ByteString rawBytes = message.ToByteString();
Assert.AreEqual(rawBytes.Length, message.SerializedSize);
@@ -77,6 +85,19 @@ namespace Google.ProtocolBuffers {
TestUtil.AssertAllFieldsSet(message2);
}
+ [Test]
+ public void SerializePackedExtensions() {
+ // TestPackedTypes and TestPackedExtensions should have compatible wire
+ // formats; check that they serialize to the same string.
+ TestPackedExtensions message = TestUtil.GetPackedExtensionsSet();
+ ByteString rawBytes = message.ToByteString();
+
+ TestPackedTypes message2 = TestUtil.GetPackedSet();
+ ByteString rawBytes2 = message2.ToByteString();
+
+ Assert.AreEqual(rawBytes, rawBytes2);
+ }
+
[Test]
public void ParseExtensions() {
// TestAllTypes and TestAllExtensions should have compatible wire formats,
@@ -90,12 +111,23 @@ namespace Google.ProtocolBuffers {
TestUtil.RegisterAllExtensions(registry);
registry = registry.AsReadOnly();
- TestAllExtensions message2 =
- TestAllExtensions.ParseFrom(rawBytes, registry);
+ TestAllExtensions message2 = TestAllExtensions.ParseFrom(rawBytes, registry);
TestUtil.AssertAllExtensionsSet(message2);
}
+ [Test]
+ public void ParsePackedExtensions() {
+ // Ensure that packed extensions can be properly parsed.
+ TestPackedExtensions message = TestUtil.GetPackedExtensionsSet();
+ ByteString rawBytes = message.ToByteString();
+
+ ExtensionRegistry registry = TestUtil.CreateExtensionRegistry();
+
+ TestPackedExtensions message2 = TestPackedExtensions.ParseFrom(rawBytes, registry);
+ TestUtil.AssertPackedExtensionsSet(message2);
+ }
+
[Test]
public void ExtensionsSerializedSize() {
Assert.AreEqual(TestUtil.GetAllSet().SerializedSize, TestUtil.GetAllExtensionsSet().SerializedSize);
diff --git a/src/ProtocolBuffers/AbstractMessage.cs b/src/ProtocolBuffers/AbstractMessage.cs
index 9787e159d0..0a69f2947f 100644
--- a/src/ProtocolBuffers/AbstractMessage.cs
+++ b/src/ProtocolBuffers/AbstractMessage.cs
@@ -110,8 +110,21 @@ namespace Google.ProtocolBuffers {
if (field.IsRepeated) {
// We know it's an IList, but not the exact type - so
// IEnumerable is the best we can do. (C# generics aren't covariant yet.)
- foreach (object element in (IEnumerable)entry.Value) {
- output.WriteField(field.FieldType, field.FieldNumber, element);
+ IEnumerable valueList = (IEnumerable) entry.Value;
+ if (field.IsPacked) {
+ output.WriteTag(field.FieldNumber, WireFormat.WireType.LengthDelimited);
+ int dataSize = 0;
+ foreach (object element in valueList) {
+ dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element);
+ }
+ output.WriteRawVarint32((uint)dataSize);
+ foreach (object element in valueList) {
+ output.WriteFieldNoTag(field.FieldType, element);
+ }
+ } else {
+ foreach (object element in valueList) {
+ output.WriteField(field.FieldType, field.FieldNumber, element);
+ }
}
} else {
output.WriteField(field.FieldType, field.FieldNumber, entry.Value);
@@ -136,8 +149,19 @@ namespace Google.ProtocolBuffers {
foreach (KeyValuePair entry in AllFields) {
FieldDescriptor field = entry.Key;
if (field.IsRepeated) {
- foreach (object element in (IEnumerable) entry.Value) {
- size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, element);
+ IEnumerable valueList = (IEnumerable) entry.Value;
+ if (field.IsPacked) {
+ int dataSize = 0;
+ foreach (object element in valueList) {
+ dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element);
+ }
+ size += dataSize;
+ size += CodedOutputStream.ComputeTagSize(field.FieldNumber);
+ size += CodedOutputStream.ComputeRawVarint32Size((uint)dataSize);
+ } else {
+ foreach (object element in valueList) {
+ size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, element);
+ }
}
} else {
size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, entry.Value);
diff --git a/src/ProtocolBuffers/CodedInputStream.cs b/src/ProtocolBuffers/CodedInputStream.cs
index 78d9251946..59d510618e 100644
--- a/src/ProtocolBuffers/CodedInputStream.cs
+++ b/src/ProtocolBuffers/CodedInputStream.cs
@@ -608,6 +608,20 @@ namespace Google.ProtocolBuffers {
RecomputeBufferSizeAfterLimit();
}
+ ///
+ /// Returns whether or not all the data before the limit has been read.
+ ///
+ ///
+ public bool ReachedLimit {
+ get {
+ if (currentLimit == int.MaxValue) {
+ return false;
+ }
+ int currentAbsolutePosition = totalBytesRetired + bufferPos;
+ return currentAbsolutePosition >= currentLimit;
+ }
+ }
+
///
/// Called when buffer is empty to read more bytes from the
/// input. If is true, RefillBuffer() gurantees that
diff --git a/src/ProtocolBuffers/CodedOutputStream.cs b/src/ProtocolBuffers/CodedOutputStream.cs
index df80780a18..7cc5ff461d 100644
--- a/src/ProtocolBuffers/CodedOutputStream.cs
+++ b/src/ProtocolBuffers/CodedOutputStream.cs
@@ -298,6 +298,156 @@ namespace Google.ProtocolBuffers {
}
}
+ public void WriteFieldNoTag(FieldType fieldType, object value) {
+ switch (fieldType) {
+ case FieldType.Double: WriteDoubleNoTag((double)value); break;
+ case FieldType.Float: WriteFloatNoTag((float)value); break;
+ case FieldType.Int64: WriteInt64NoTag((long)value); break;
+ case FieldType.UInt64: WriteUInt64NoTag((ulong)value); break;
+ case FieldType.Int32: WriteInt32NoTag((int)value); break;
+ case FieldType.Fixed64: WriteFixed64NoTag((ulong)value); break;
+ case FieldType.Fixed32: WriteFixed32NoTag((uint)value); break;
+ case FieldType.Bool: WriteBoolNoTag((bool)value); break;
+ case FieldType.String: WriteStringNoTag((string)value); break;
+ case FieldType.Group: WriteGroupNoTag((IMessage)value); break;
+ case FieldType.Message: WriteMessageNoTag((IMessage)value); break;
+ case FieldType.Bytes: WriteBytesNoTag((ByteString)value); break;
+ case FieldType.UInt32: WriteUInt32NoTag((uint)value); break;
+ case FieldType.SFixed32: WriteSFixed32NoTag((int)value); break;
+ case FieldType.SFixed64: WriteSFixed64NoTag((long)value); break;
+ case FieldType.SInt32: WriteSInt32NoTag((int)value); break;
+ case FieldType.SInt64: WriteSInt64NoTag((long)value); break;
+ case FieldType.Enum: WriteEnumNoTag(((EnumValueDescriptor)value).Number);
+ break;
+ }
+ }
+ #endregion
+
+ #region Writing of values without tags
+ ///
+ /// Writes a double field value, including tag, to the stream.
+ ///
+ public void WriteDoubleNoTag(double value) {
+ WriteRawLittleEndian64((ulong)BitConverter.DoubleToInt64Bits(value));
+ }
+
+ ///
+ /// Writes a float field value, without a tag, to the stream.
+ ///
+ public void WriteFloatNoTag(float value) {
+ // TODO(jonskeet): Test this on different endiannesses
+ byte[] rawBytes = BitConverter.GetBytes(value);
+ uint asInteger = BitConverter.ToUInt32(rawBytes, 0);
+ WriteRawLittleEndian32(asInteger);
+ }
+
+ ///
+ /// Writes a uint64 field value, without a tag, to the stream.
+ ///
+ public void WriteUInt64NoTag(ulong value) {
+ WriteRawVarint64(value);
+ }
+
+ ///
+ /// Writes an int64 field value, without a tag, to the stream.
+ ///
+ public void WriteInt64NoTag(long value) {
+ WriteRawVarint64((ulong)value);
+ }
+
+ ///
+ /// Writes an int32 field value, without a tag, to the stream.
+ ///
+ public void WriteInt32NoTag(int value) {
+ if (value >= 0) {
+ WriteRawVarint32((uint)value);
+ } else {
+ // Must sign-extend.
+ WriteRawVarint64((ulong)value);
+ }
+ }
+
+ ///
+ /// Writes a fixed64 field value, without a tag, to the stream.
+ ///
+ public void WriteFixed64NoTag(ulong value) {
+ WriteRawLittleEndian64(value);
+ }
+
+ ///
+ /// Writes a fixed32 field value, without a tag, to the stream.
+ ///
+ public void WriteFixed32NoTag(uint value) {
+ WriteRawLittleEndian32(value);
+ }
+
+ ///
+ /// Writes a bool field value, without a tag, to the stream.
+ ///
+ public void WriteBoolNoTag(bool value) {
+ WriteRawByte(value ? (byte)1 : (byte)0);
+ }
+
+ ///
+ /// Writes a string field value, without a tag, to the stream.
+ ///
+ public void WriteStringNoTag(string value) {
+ // Optimise the case where we have enough space to write
+ // the string directly to the buffer, which should be common.
+ int length = Encoding.UTF8.GetByteCount(value);
+ WriteRawVarint32((uint)length);
+ if (limit - position >= length) {
+ Encoding.UTF8.GetBytes(value, 0, value.Length, buffer, position);
+ position += length;
+ } else {
+ byte[] bytes = Encoding.UTF8.GetBytes(value);
+ WriteRawBytes(bytes);
+ }
+ }
+
+ ///
+ /// Writes a group field value, without a tag, to the stream.
+ ///
+ public void WriteGroupNoTag(IMessage value) {
+ value.WriteTo(this);
+ }
+
+ public void WriteMessageNoTag(IMessage value) {
+ WriteRawVarint32((uint)value.SerializedSize);
+ value.WriteTo(this);
+ }
+
+ public void WriteBytesNoTag(ByteString value) {
+ // TODO(jonskeet): Optimise this! (No need to copy the bytes twice.)
+ byte[] bytes = value.ToByteArray();
+ WriteRawVarint32((uint)bytes.Length);
+ WriteRawBytes(bytes);
+ }
+
+ public void WriteUInt32NoTag(uint value) {
+ WriteRawVarint32(value);
+ }
+
+ public void WriteEnumNoTag(int value) {
+ WriteRawVarint32((uint)value);
+ }
+
+ public void WriteSFixed32NoTag(int value) {
+ WriteRawLittleEndian32((uint)value);
+ }
+
+ public void WriteSFixed64NoTag(long value) {
+ WriteRawLittleEndian64((ulong)value);
+ }
+
+ public void WriteSInt32NoTag(int value) {
+ WriteRawVarint32(EncodeZigZag32(value));
+ }
+
+ public void WriteSInt64NoTag(long value) {
+ WriteRawVarint64(EncodeZigZag64(value));
+ }
+
#endregion
#region Underlying writing primitives
@@ -583,8 +733,7 @@ namespace Google.ProtocolBuffers {
/// sint32 field, including the tag.
///
public static int ComputeSInt32Size(int fieldNumber, int value) {
- return ComputeTagSize(fieldNumber) +
- ComputeRawVarint32Size(EncodeZigZag32(value));
+ return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size(EncodeZigZag32(value));
}
///
@@ -592,8 +741,169 @@ namespace Google.ProtocolBuffers {
/// sint64 field, including the tag.
///
public static int ComputeSInt64Size(int fieldNumber, long value) {
- return ComputeTagSize(fieldNumber) +
- ComputeRawVarint64Size(EncodeZigZag64(value));
+ return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size(EncodeZigZag64(value));
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// double field, including the tag.
+ ///
+ public static int ComputeDoubleSizeNoTag(double value) {
+ return LittleEndian64Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// float field, including the tag.
+ ///
+ public static int ComputeFloatSizeNoTag(float value) {
+ return LittleEndian32Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// uint64 field, including the tag.
+ ///
+ public static int ComputeUInt64SizeNoTag(ulong value) {
+ return ComputeRawVarint64Size(value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// int64 field, including the tag.
+ ///
+ public static int ComputeInt64SizeNoTag(long value) {
+ return ComputeRawVarint64Size((ulong)value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// int32 field, including the tag.
+ ///
+ public static int ComputeInt32SizeNoTag(int value) {
+ if (value >= 0) {
+ return ComputeRawVarint32Size((uint)value);
+ } else {
+ // Must sign-extend.
+ return 10;
+ }
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// fixed64 field, including the tag.
+ ///
+ public static int ComputeFixed64SizeNoTag(ulong value) {
+ return LittleEndian64Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// fixed32 field, including the tag.
+ ///
+ public static int ComputeFixed32SizeNoTag(uint value) {
+ return LittleEndian32Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// bool field, including the tag.
+ ///
+ public static int ComputeBoolSizeNoTag(bool value) {
+ return 1;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// string field, including the tag.
+ ///
+ public static int ComputeStringSizeNoTag(String value) {
+ int byteArraySize = Encoding.UTF8.GetByteCount(value);
+ return ComputeRawVarint32Size((uint)byteArraySize) +
+ byteArraySize;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// group field, including the tag.
+ ///
+ public static int ComputeGroupSizeNoTag(IMessage value) {
+ return value.SerializedSize;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// group field represented by an UnknownFieldSet, including the tag.
+ ///
+ public static int ComputeUnknownGroupSizeNoTag(UnknownFieldSet value) {
+ return value.SerializedSize;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// embedded message field, including the tag.
+ ///
+ public static int ComputeMessageSizeNoTag(IMessage value) {
+ int size = value.SerializedSize;
+ return ComputeRawVarint32Size((uint)size) + size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// bytes field, including the tag.
+ ///
+ public static int ComputeBytesSizeNoTag(ByteString value) {
+ return ComputeRawVarint32Size((uint)value.Length) +
+ value.Length;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// uint32 field, including the tag.
+ ///
+ public static int ComputeUInt32SizeNoTag(uint value) {
+ return ComputeRawVarint32Size(value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// enum field, including the tag. The caller is responsible for
+ /// converting the enum value to its numeric value.
+ ///
+ public static int ComputeEnumSizeNoTag(int value) {
+ return ComputeRawVarint32Size((uint)value);
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// sfixed32 field, including the tag.
+ ///
+ public static int ComputeSFixed32SizeNoTag(int value) {
+ return LittleEndian32Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// sfixed64 field, including the tag.
+ ///
+ public static int ComputeSFixed64SizeNoTag(long value) {
+ return LittleEndian64Size;
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// sint32 field, including the tag.
+ ///
+ public static int ComputeSInt32SizeNoTag(int value) {
+ return ComputeRawVarint32Size(EncodeZigZag32(value));
+ }
+
+ ///
+ /// Compute the number of bytes that would be needed to encode an
+ /// sint64 field, including the tag.
+ ///
+ public static int ComputeSInt64SizeNoTag(long value) {
+ return ComputeRawVarint64Size(EncodeZigZag64(value));
}
/*
@@ -650,18 +960,10 @@ namespace Google.ProtocolBuffers {
return 10;
}
-
- /*
- * Compute the number of bytes that would be needed to encode a
- * field of arbitrary type, including tag, to the stream.
- *
- * @param type The field's type.
- * @param number The field's number.
- * @param value Object representing the field's value. Must be of the exact
- * type which would be returned by
- * {@link Message#getField(FieldDescriptor)} for
- * this field.
- */
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// field of arbitrary type, including the tag, to the stream.
+ ///
public static int ComputeFieldSize(FieldType fieldType, int fieldNumber, Object value) {
switch (fieldType) {
case FieldType.Double: return ComputeDoubleSize(fieldNumber, (double)value);
@@ -687,6 +989,35 @@ namespace Google.ProtocolBuffers {
}
}
+ ///
+ /// Compute the number of bytes that would be needed to encode a
+ /// field of arbitrary type, excluding the tag, to the stream.
+ ///
+ public static int ComputeFieldSizeNoTag(FieldType fieldType, Object value) {
+ switch (fieldType) {
+ case FieldType.Double: return ComputeDoubleSizeNoTag((double)value);
+ case FieldType.Float: return ComputeFloatSizeNoTag((float)value);
+ case FieldType.Int64: return ComputeInt64SizeNoTag((long)value);
+ case FieldType.UInt64: return ComputeUInt64SizeNoTag((ulong)value);
+ case FieldType.Int32: return ComputeInt32SizeNoTag((int)value);
+ case FieldType.Fixed64: return ComputeFixed64SizeNoTag((ulong)value);
+ case FieldType.Fixed32: return ComputeFixed32SizeNoTag((uint)value);
+ case FieldType.Bool: return ComputeBoolSizeNoTag((bool)value);
+ case FieldType.String: return ComputeStringSizeNoTag((string)value);
+ case FieldType.Group: return ComputeGroupSizeNoTag((IMessage)value);
+ case FieldType.Message: return ComputeMessageSizeNoTag((IMessage)value);
+ case FieldType.Bytes: return ComputeBytesSizeNoTag((ByteString)value);
+ case FieldType.UInt32: return ComputeUInt32SizeNoTag((uint)value);
+ case FieldType.SFixed32: return ComputeSFixed32SizeNoTag((int)value);
+ case FieldType.SFixed64: return ComputeSFixed64SizeNoTag((long)value);
+ case FieldType.SInt32: return ComputeSInt32SizeNoTag((int)value);
+ case FieldType.SInt64: return ComputeSInt64SizeNoTag((long)value);
+ case FieldType.Enum: return ComputeEnumSizeNoTag(((EnumValueDescriptor)value).Number);
+ default:
+ throw new ArgumentOutOfRangeException("Invalid field type " + fieldType);
+ }
+ }
+
///
/// Compute the number of bytes that would be needed to encode a tag.
///
diff --git a/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs b/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
index 4206f26192..1fe7928c7c 100644
--- a/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
+++ b/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
@@ -70,27 +70,27 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
"AioJCOgHEICAgIACIogBCg5NZXNzYWdlT3B0aW9ucxImChdtZXNzYWdlX3Nl" +
"dF93aXJlX2Zvcm1hdBgBIAEoCDoFZmFsc2USQwoUdW5pbnRlcnByZXRlZF9v" +
"cHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVmLlVuaW50ZXJwcmV0ZWRP" +
- "cHRpb24qCQjoBxCAgICAAiLVAQoMRmllbGRPcHRpb25zEjIKBWN0eXBlGAEg" +
- "ASgOMiMuZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucy5DVHlwZRIcChRl" +
- "eHBlcmltZW50YWxfbWFwX2tleRgJIAEoCRJDChR1bmludGVycHJldGVkX29w" +
- "dGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9w" +
- "dGlvbiIjCgVDVHlwZRIICgRDT1JEEAESEAoMU1RSSU5HX1BJRUNFEAIqCQjo" +
- "BxCAgICAAiJdCgtFbnVtT3B0aW9ucxJDChR1bmludGVycHJldGVkX29wdGlv" +
- "bhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9wdGlv" +
- "bioJCOgHEICAgIACImIKEEVudW1WYWx1ZU9wdGlvbnMSQwoUdW5pbnRlcnBy" +
- "ZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVmLlVuaW50ZXJw" +
- "cmV0ZWRPcHRpb24qCQjoBxCAgICAAiJgCg5TZXJ2aWNlT3B0aW9ucxJDChR1" +
- "bmludGVycHJldGVkX29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYu" +
- "VW5pbnRlcnByZXRlZE9wdGlvbioJCOgHEICAgIACIl8KDU1ldGhvZE9wdGlv" +
- "bnMSQwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnBy" +
- "b3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAiKFAgoTVW5p" +
- "bnRlcnByZXRlZE9wdGlvbhI7CgRuYW1lGAIgAygLMi0uZ29vZ2xlLnByb3Rv" +
- "YnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24uTmFtZVBhcnQSGAoQaWRlbnRpZmll" +
- "cl92YWx1ZRgDIAEoCRIaChJwb3NpdGl2ZV9pbnRfdmFsdWUYBCABKAQSGgoS" +
- "bmVnYXRpdmVfaW50X3ZhbHVlGAUgASgDEhQKDGRvdWJsZV92YWx1ZRgGIAEo" +
- "ARIUCgxzdHJpbmdfdmFsdWUYByABKAwaMwoITmFtZVBhcnQSEQoJbmFtZV9w" +
- "YXJ0GAEgAigJEhQKDGlzX2V4dGVuc2lvbhgCIAIoCEIpChNjb20uZ29vZ2xl" +
- "LnByb3RvYnVmQhBEZXNjcmlwdG9yUHJvdG9zSAE="),
+ "cHRpb24qCQjoBxCAgICAAiLlAQoMRmllbGRPcHRpb25zEjIKBWN0eXBlGAEg" +
+ "ASgOMiMuZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucy5DVHlwZRIOCgZw" +
+ "YWNrZWQYAiABKAgSHAoUZXhwZXJpbWVudGFsX21hcF9rZXkYCSABKAkSQwoU" +
+ "dW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVm" +
+ "LlVuaW50ZXJwcmV0ZWRPcHRpb24iIwoFQ1R5cGUSCAoEQ09SRBABEhAKDFNU" +
+ "UklOR19QSUVDRRACKgkI6AcQgICAgAIiXQoLRW51bU9wdGlvbnMSQwoUdW5p" +
+ "bnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVmLlVu" +
+ "aW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAiJiChBFbnVtVmFsdWVPcHRp" +
+ "b25zEkMKFHVuaW50ZXJwcmV0ZWRfb3B0aW9uGOcHIAMoCzIkLmdvb2dsZS5w" +
+ "cm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uKgkI6AcQgICAgAIiYAoOU2Vy" +
+ "dmljZU9wdGlvbnMSQwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQu" +
+ "Z29vZ2xlLnByb3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICA" +
+ "AiJfCg1NZXRob2RPcHRpb25zEkMKFHVuaW50ZXJwcmV0ZWRfb3B0aW9uGOcH" +
+ "IAMoCzIkLmdvb2dsZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uKgkI" +
+ "6AcQgICAgAIihQIKE1VuaW50ZXJwcmV0ZWRPcHRpb24SOwoEbmFtZRgCIAMo" +
+ "CzItLmdvb2dsZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uLk5hbWVQ" +
+ "YXJ0EhgKEGlkZW50aWZpZXJfdmFsdWUYAyABKAkSGgoScG9zaXRpdmVfaW50" +
+ "X3ZhbHVlGAQgASgEEhoKEm5lZ2F0aXZlX2ludF92YWx1ZRgFIAEoAxIUCgxk" +
+ "b3VibGVfdmFsdWUYBiABKAESFAoMc3RyaW5nX3ZhbHVlGAcgASgMGjMKCE5h" +
+ "bWVQYXJ0EhEKCW5hbWVfcGFydBgBIAIoCRIUCgxpc19leHRlbnNpb24YAiAC" +
+ "KAhCKQoTY29tLmdvb2dsZS5wcm90b2J1ZkIQRGVzY3JpcHRvclByb3Rvc0gB"),
new pbd::FileDescriptor[] {
});
#endregion
@@ -155,7 +155,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
= Descriptor.MessageTypes[10];
internal static pb::FieldAccess.FieldAccessorTable internal__static_google_protobuf_FieldOptions__FieldAccessorTable
= new pb::FieldAccess.FieldAccessorTable(internal__static_google_protobuf_FieldOptions__Descriptor,
- new string[] { "Ctype", "ExperimentalMapKey", "UninterpretedOption", });
+ new string[] { "Ctype", "Packed", "ExperimentalMapKey", "UninterpretedOption", });
internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumOptions__Descriptor
= Descriptor.MessageTypes[11];
internal static pb::FieldAccess.FieldAccessorTable internal__static_google_protobuf_EnumOptions__FieldAccessorTable
@@ -541,8 +541,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
if (HasPackage) {
output.WriteString(2, Package);
}
- foreach (string element in DependencyList) {
- output.WriteString(3, element);
+ if (dependency_.Count > 0) {
+ foreach (string element in dependency_) {
+ output.WriteString(3, element);
+ }
}
foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) {
output.WriteMessage(4, element);
@@ -575,8 +577,13 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
if (HasPackage) {
size += pb::CodedOutputStream.ComputeStringSize(2, Package);
}
- foreach (string element in DependencyList) {
- size += pb::CodedOutputStream.ComputeStringSize(3, element);
+ {
+ int dataSize = 0;
+ foreach (string element in DependencyList) {
+ dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
+ }
+ size += dataSize;
+ size += 1 * dependency_.Count;
}
foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) {
size += pb::CodedOutputStream.ComputeMessageSize(4, element);
@@ -4413,6 +4420,15 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
get { return ctype_; }
}
+ private bool hasPacked;
+ private bool packed_ = false;
+ public bool HasPacked {
+ get { return hasPacked; }
+ }
+ public bool Packed {
+ get { return packed_; }
+ }
+
private bool hasExperimentalMapKey;
private string experimentalMapKey_ = "";
public bool HasExperimentalMapKey {
@@ -4448,6 +4464,9 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
if (HasCtype) {
output.WriteEnum(1, (int) Ctype);
}
+ if (HasPacked) {
+ output.WriteBool(2, Packed);
+ }
if (HasExperimentalMapKey) {
output.WriteString(9, ExperimentalMapKey);
}
@@ -4468,6 +4487,9 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
if (HasCtype) {
size += pb::CodedOutputStream.ComputeEnumSize(1, (int) Ctype);
}
+ if (HasPacked) {
+ size += pb::CodedOutputStream.ComputeBoolSize(2, Packed);
+ }
if (HasExperimentalMapKey) {
size += pb::CodedOutputStream.ComputeStringSize(9, ExperimentalMapKey);
}
@@ -4561,6 +4583,9 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
if (other.HasCtype) {
Ctype = other.Ctype;
}
+ if (other.HasPacked) {
+ Packed = other.Packed;
+ }
if (other.HasExperimentalMapKey) {
ExperimentalMapKey = other.ExperimentalMapKey;
}
@@ -4601,6 +4626,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
}
break;
}
+ case 16: {
+ Packed = input.ReadBool();
+ break;
+ }
case 74: {
ExperimentalMapKey = input.ReadString();
break;
@@ -4634,6 +4663,24 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
return this;
}
+ public bool HasPacked {
+ get { return result.HasPacked; }
+ }
+ public bool Packed {
+ get { return result.Packed; }
+ set { SetPacked(value); }
+ }
+ public Builder SetPacked(bool value) {
+ result.hasPacked = true;
+ result.packed_ = value;
+ return this;
+ }
+ public Builder ClearPacked() {
+ result.hasPacked = false;
+ result.packed_ = false;
+ return this;
+ }
+
public bool HasExperimentalMapKey {
get { return result.HasExperimentalMapKey; }
}
diff --git a/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs b/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs
index 0d0fad76c5..eca3d6d17d 100644
--- a/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs
+++ b/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs
@@ -176,6 +176,10 @@ namespace Google.ProtocolBuffers.Descriptors {
get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REPEATED; }
}
+ public bool IsPacked {
+ get { return Proto.Options.Packed; }
+ }
+
///
/// Indicates whether or not the field had an explicitly-defined default value.
///
diff --git a/src/ProtocolBuffers/FieldSet.cs b/src/ProtocolBuffers/FieldSet.cs
index bc2e2e7098..913dede276 100644
--- a/src/ProtocolBuffers/FieldSet.cs
+++ b/src/ProtocolBuffers/FieldSet.cs
@@ -368,8 +368,23 @@ namespace Google.ProtocolBuffers {
output.WriteMessageSetExtension(field.FieldNumber, (IMessage) value);
} else {
if (field.IsRepeated) {
- foreach (object element in (IEnumerable) value) {
- output.WriteField(field.FieldType, field.FieldNumber, element);
+ IEnumerable valueList = (IEnumerable) value;
+ if (field.IsPacked) {
+ output.WriteTag(field.FieldNumber, WireFormat.WireType.LengthDelimited);
+ // Compute the total data size so the length can be written.
+ int dataSize = 0;
+ foreach (object element in valueList) {
+ dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element);
+ }
+ output.WriteRawVarint32((uint)dataSize);
+ // Write the data itself, without any tags.
+ foreach (object element in valueList) {
+ output.WriteFieldNoTag(field.FieldType, element);
+ }
+ } else {
+ foreach (object element in valueList) {
+ output.WriteField(field.FieldType, field.FieldNumber, element);
+ }
}
} else {
output.WriteField(field.FieldType, field.FieldNumber, value);
@@ -389,11 +404,20 @@ namespace Google.ProtocolBuffers {
object value = entry.Value;
if (field.IsExtension && field.ContainingType.Options.MessageSetWireFormat) {
- size += CodedOutputStream.ComputeMessageSetExtensionSize(field.FieldNumber, (IMessage) value);
+ size += CodedOutputStream.ComputeMessageSetExtensionSize(field.FieldNumber, (IMessage)value);
} else {
if (field.IsRepeated) {
- foreach (object element in (IEnumerable) value) {
- size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, element);
+ IEnumerable valueList = (IEnumerable)value;
+ if (field.IsPacked) {
+ int dataSize = 0;
+ foreach (object element in valueList) {
+ dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element);
+ }
+ size += dataSize + CodedOutputStream.ComputeTagSize(field.FieldNumber) + CodedOutputStream.ComputeRawVarint32Size((uint)dataSize);
+ } else {
+ foreach (object element in valueList) {
+ size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, element);
+ }
}
} else {
size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, value);
diff --git a/src/ProtocolBuffers/UnknownFieldSet.cs b/src/ProtocolBuffers/UnknownFieldSet.cs
index ecae53cec2..aa371fad86 100644
--- a/src/ProtocolBuffers/UnknownFieldSet.cs
+++ b/src/ProtocolBuffers/UnknownFieldSet.cs
@@ -497,50 +497,73 @@ namespace Google.ProtocolBuffers {
}
// Unknown field or wrong wire type. Skip.
- if (field == null || wireType != WireFormat.GetWireType(field.FieldType)) {
+ if (field == null || wireType != WireFormat.GetWireType(field)) {
return MergeFieldFrom(tag, input);
}
- object value;
- switch (field.FieldType) {
- case FieldType.Group:
- case FieldType.Message: {
- IBuilder subBuilder;
- if (defaultFieldInstance != null) {
- subBuilder = defaultFieldInstance.WeakCreateBuilderForType();
- } else {
- subBuilder = builder.CreateBuilderForField(field);
- }
- if (!field.IsRepeated) {
- subBuilder.WeakMergeFrom((IMessage)builder[field]);
- }
- if (field.FieldType == FieldType.Group) {
- input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry);
- } else {
- input.ReadMessage(subBuilder, extensionRegistry);
- }
- value = subBuilder.WeakBuild();
- break;
- }
- case FieldType.Enum: {
+ if (field.IsPacked) {
+ int length = (int)input.ReadRawVarint32();
+ int limit = input.PushLimit(length);
+ if (field.FieldType == FieldType.Enum) {
+ while (!input.ReachedLimit) {
int rawValue = input.ReadEnum();
- value = field.EnumType.FindValueByNumber(rawValue);
- // If the number isn't recognized as a valid value for this enum,
- // drop it.
+ object value = field.EnumType.FindValueByNumber(rawValue);
if (value == null) {
- MergeVarintField(fieldNumber, (ulong)rawValue);
+ // If the number isn't recognized as a valid value for this
+ // enum, drop it (don't even add it to unknownFields).
return true;
}
- break;
+ builder.WeakAddRepeatedField(field, value);
}
- default:
- value = input.ReadPrimitiveField(field.FieldType);
- break;
- }
- if (field.IsRepeated) {
- builder.WeakAddRepeatedField(field, value);
+ } else {
+ while (!input.ReachedLimit) {
+ Object value = input.ReadPrimitiveField(field.FieldType);
+ builder.WeakAddRepeatedField(field, value);
+ }
+ }
+ input.PopLimit(limit);
} else {
- builder[field] = value;
+ object value;
+ switch (field.FieldType) {
+ case FieldType.Group:
+ case FieldType.Message: {
+ IBuilder subBuilder;
+ if (defaultFieldInstance != null) {
+ subBuilder = defaultFieldInstance.WeakCreateBuilderForType();
+ } else {
+ subBuilder = builder.CreateBuilderForField(field);
+ }
+ if (!field.IsRepeated) {
+ subBuilder.WeakMergeFrom((IMessage)builder[field]);
+ }
+ if (field.FieldType == FieldType.Group) {
+ input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry);
+ } else {
+ input.ReadMessage(subBuilder, extensionRegistry);
+ }
+ value = subBuilder.WeakBuild();
+ break;
+ }
+ case FieldType.Enum: {
+ int rawValue = input.ReadEnum();
+ value = field.EnumType.FindValueByNumber(rawValue);
+ // If the number isn't recognized as a valid value for this enum,
+ // drop it.
+ if (value == null) {
+ MergeVarintField(fieldNumber, (ulong)rawValue);
+ return true;
+ }
+ break;
+ }
+ default:
+ value = input.ReadPrimitiveField(field.FieldType);
+ break;
+ }
+ if (field.IsRepeated) {
+ builder.WeakAddRepeatedField(field, value);
+ } else {
+ builder[field] = value;
+ }
}
return true;
}
diff --git a/src/ProtocolBuffers/WireFormat.cs b/src/ProtocolBuffers/WireFormat.cs
index abf47169f3..2bd0a5aa8a 100644
--- a/src/ProtocolBuffers/WireFormat.cs
+++ b/src/ProtocolBuffers/WireFormat.cs
@@ -46,6 +46,19 @@ namespace Google.ProtocolBuffers {
///
///
public static class WireFormat {
+
+#region Fixed sizes.
+ // TODO(jonskeet): Move these somewhere else. They're messy. Consider making FieldType a smarter kind of enum
+ internal const int Fixed32Size = 4;
+ internal const int Fixed64Size = 8;
+ internal const int SFixed32Size = 4;
+ internal const int SFixed64Size = 8;
+ internal const int FloatSize = 4;
+ internal const int DoubleSize = 8;
+ internal const int BoolSize = 1;
+#endregion
+
+
public enum WireType : uint {
Varint = 0,
Fixed64 = 1,
@@ -93,6 +106,18 @@ namespace Google.ProtocolBuffers {
return (uint) (fieldNumber << TagTypeBits) | (uint) wireType;
}
+ public static uint MakeTag(FieldDescriptor field) {
+ return MakeTag(field.FieldNumber, GetWireType(field));
+ }
+
+ ///
+ /// Returns the wire type for the given field descriptor. This differs
+ /// from GetWireType(FieldType) for packed repeated fields.
+ ///
+ internal static WireType GetWireType(FieldDescriptor descriptor) {
+ return descriptor.IsPacked ? WireType.LengthDelimited : GetWireType(descriptor.FieldType);
+ }
+
///
/// Converts a field type to its wire type. Done with a switch for the sake
/// of speed - this is significantly faster than a dictionary lookup.
diff --git a/testdata/golden_packed_fields_message b/testdata/golden_packed_fields_message
new file mode 100644
index 0000000000..ee28d38830
Binary files /dev/null and b/testdata/golden_packed_fields_message differ
diff --git a/todo.txt b/todo.txt
index 041187909e..88bf72f146 100644
--- a/todo.txt
+++ b/todo.txt
@@ -1,10 +1,14 @@
Current task list (not in order)
-- Performance framework
-- Optionally remove dependencies to core and csharp options (2.0.3
- will remove core dependency)
+- Optionally remove dependencies to csharp options
- Remove multifile support
- Mono support
- Docs
- Clean up protogen code
- Add flags to protogen
+- Avoid using reflection for messages which don't need it (is this
+ possible?)
+- Add RegisterAllExtensions
+- Add ToBuilder changes from Google's r92
+- Silverlight changes (as per email to Jon)
+