diff options
author | Jon Skeet <skeet@pobox.com> | 2008-08-14 20:35:24 +0100 |
---|---|---|
committer | Jon Skeet <skeet@pobox.com> | 2008-08-14 20:35:24 +0100 |
commit | ba02091ef822ffa9248fdd6450703e5ff045838e (patch) | |
tree | 9ca66f702a890ec4f8740a69857d87cf6e439280 | |
parent | bef2caf5e49dbcf6b926d01cfb0948dedee49c93 (diff) | |
download | protobuf-ba02091ef822ffa9248fdd6450703e5ff045838e.tar.gz protobuf-ba02091ef822ffa9248fdd6450703e5ff045838e.tar.bz2 protobuf-ba02091ef822ffa9248fdd6450703e5ff045838e.zip |
New unit tests and corresponding bug fixes.
-rw-r--r-- | csharp/ProtocolBuffers.Test/DescriptorsTest.cs | 258 | ||||
-rw-r--r-- | csharp/ProtocolBuffers.Test/DynamicMessageTest.cs | 103 | ||||
-rw-r--r-- | csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj | 2 | ||||
-rw-r--r-- | csharp/ProtocolBuffers.Test/ReflectionTester.cs | 139 | ||||
-rw-r--r-- | csharp/ProtocolBuffers/Descriptors/MessageDescriptor.cs | 7 | ||||
-rw-r--r-- | csharp/ProtocolBuffers/Descriptors/MethodDescriptor.cs | 2 | ||||
-rw-r--r-- | csharp/ProtocolBuffers/Descriptors/ServiceDescriptor.cs | 9 | ||||
-rw-r--r-- | csharp/ProtocolBuffers/DynamicMessage.cs | 4 | ||||
-rw-r--r-- | csharp/ProtocolBuffers/FieldSet.cs | 9 |
9 files changed, 455 insertions, 78 deletions
diff --git a/csharp/ProtocolBuffers.Test/DescriptorsTest.cs b/csharp/ProtocolBuffers.Test/DescriptorsTest.cs new file mode 100644 index 00000000..5f47de1b --- /dev/null +++ b/csharp/ProtocolBuffers.Test/DescriptorsTest.cs @@ -0,0 +1,258 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NUnit.Framework; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Tests for descriptors. (Not in its own namespace or broken up into individual classes as the + /// size doesn't warrant it. On the other hand, this makes me feel a bit dirty...) + /// </summary> + [TestFixture] + public class DescriptorsTest { + + [Test] + public void FileDescriptor() { + FileDescriptor file = UnitTestProtoFile.Descriptor; + + Assert.AreEqual("google/protobuf/unittest.proto", file.Name); + Assert.AreEqual("protobuf_unittest", file.Package); + + Assert.AreEqual("UnittestProto", file.Options.JavaOuterClassname); + Assert.AreEqual("google/protobuf/unittest.proto", file.Proto.Name); + + Assert.AreEqual(1, file.Dependencies.Count); + Assert.AreEqual(UnitTestImportProtoFile.Descriptor, file.Dependencies[0]); + + MessageDescriptor messageType = TestAllTypes.Descriptor; + Assert.AreEqual(messageType, file.MessageTypes[0]); + Assert.AreEqual(messageType, file.FindTypeByName<MessageDescriptor>("TestAllTypes")); + Assert.IsNull(file.FindTypeByName<MessageDescriptor>("NoSuchType")); + Assert.IsNull(file.FindTypeByName<MessageDescriptor>("protobuf_unittest.TestAllTypes")); + for (int i = 0; i < file.MessageTypes.Count; i++) { + Assert.AreEqual(i, file.MessageTypes[i].Index); + } + + Assert.AreEqual(file.EnumTypes[0], file.FindTypeByName<EnumDescriptor>("ForeignEnum")); + Assert.IsNull(file.FindTypeByName<EnumDescriptor>("NoSuchType")); + Assert.IsNull(file.FindTypeByName<EnumDescriptor>("protobuf_unittest.ForeignEnum")); + Assert.AreEqual(1, UnitTestImportProtoFile.Descriptor.EnumTypes.Count); + Assert.AreEqual("ImportEnum", UnitTestImportProtoFile.Descriptor.EnumTypes[0].Name); + for (int i = 0; i < file.EnumTypes.Count; i++) { + Assert.AreEqual(i, file.EnumTypes[i].Index); + } + + ServiceDescriptor service = TestService.Descriptor; + Assert.AreEqual(service, file.Services[0]); + Assert.AreEqual(service, file.FindTypeByName<ServiceDescriptor>("TestService")); + Assert.IsNull(file.FindTypeByName<ServiceDescriptor>("NoSuchType")); + Assert.IsNull(file.FindTypeByName<ServiceDescriptor>("protobuf_unittest.TestService")); + Assert.AreEqual(0, UnitTestImportProtoFile.Descriptor.Services.Count); + for (int i = 0; i < file.Services.Count; i++) { + Assert.AreEqual(i, file.Services[i].Index); + } + + FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor; + Assert.AreEqual(extension, file.Extensions[0]); + Assert.AreEqual(extension, file.FindTypeByName<FieldDescriptor>("optional_int32_extension")); + Assert.IsNull(file.FindTypeByName<FieldDescriptor>("no_such_ext")); + Assert.IsNull(file.FindTypeByName<FieldDescriptor>("protobuf_unittest.optional_int32_extension")); + Assert.AreEqual(0, UnitTestImportProtoFile.Descriptor.Extensions.Count); + for (int i = 0; i < file.Extensions.Count; i++) { + Assert.AreEqual(i, file.Extensions[i].Index); + } + } + + [Test] + public void MessageDescriptor() { + MessageDescriptor messageType = TestAllTypes.Descriptor; + MessageDescriptor nestedType = TestAllTypes.Types.NestedMessage.Descriptor; + + Assert.AreEqual("TestAllTypes", messageType.Name); + Assert.AreEqual("protobuf_unittest.TestAllTypes", messageType.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, messageType.File); + Assert.IsNull(messageType.ContainingType); + Assert.AreEqual(DescriptorProtos.MessageOptions.DefaultInstance, messageType.Options); + Assert.AreEqual("TestAllTypes", messageType.Proto.Name); + + Assert.AreEqual("NestedMessage", nestedType.Name); + Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedMessage", nestedType.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File); + Assert.AreEqual(messageType, nestedType.ContainingType); + + FieldDescriptor field = messageType.Fields[0]; + Assert.AreEqual("optional_int32", field.Name); + Assert.AreEqual(field, messageType.FindDescriptor<FieldDescriptor>("optional_int32")); + Assert.IsNull(messageType.FindDescriptor<FieldDescriptor>("no_such_field")); + Assert.AreEqual(field, messageType.FindFieldByNumber(1)); + Assert.IsNull(messageType.FindFieldByNumber(571283)); + for (int i = 0; i < messageType.Fields.Count; i++) { + Assert.AreEqual(i, messageType.Fields[i].Index); + } + + Assert.AreEqual(nestedType, messageType.NestedTypes[0]); + Assert.AreEqual(nestedType, messageType.FindDescriptor<MessageDescriptor>("NestedMessage")); + Assert.IsNull(messageType.FindDescriptor<MessageDescriptor>("NoSuchType")); + for (int i = 0; i < messageType.NestedTypes.Count; i++) { + Assert.AreEqual(i, messageType.NestedTypes[i].Index); + } + + Assert.AreEqual(messageType.EnumTypes[0], messageType.FindDescriptor<EnumDescriptor>("NestedEnum")); + Assert.IsNull(messageType.FindDescriptor<EnumDescriptor>("NoSuchType")); + for (int i = 0; i < messageType.EnumTypes.Count; i++) { + Assert.AreEqual(i, messageType.EnumTypes[i].Index); + } + } + + [Test] + public void FieldDescriptor() { + MessageDescriptor messageType = TestAllTypes.Descriptor; + FieldDescriptor primitiveField = messageType.FindDescriptor<FieldDescriptor>("optional_int32"); + FieldDescriptor enumField = messageType.FindDescriptor<FieldDescriptor>("optional_nested_enum"); + FieldDescriptor messageField = messageType.FindDescriptor<FieldDescriptor>("optional_foreign_message"); + FieldDescriptor cordField = messageType.FindDescriptor<FieldDescriptor>("optional_cord"); + FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor; + FieldDescriptor nestedExtension = TestRequired.Types.Single.Descriptor; + + Assert.AreEqual("optional_int32", primitiveField.Name); + Assert.AreEqual("protobuf_unittest.TestAllTypes.optional_int32", + primitiveField.FullName); + Assert.AreEqual(1, primitiveField.FieldNumber); + Assert.AreEqual(messageType, primitiveField.ContainingType); + Assert.AreEqual(UnitTestProtoFile.Descriptor, primitiveField.File); + Assert.AreEqual(FieldType.Int32, primitiveField.FieldType); + Assert.AreEqual(MappedType.Int32, primitiveField.MappedType); + Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance, primitiveField.Options); + Assert.IsFalse(primitiveField.IsExtension); + Assert.AreEqual("optional_int32", primitiveField.Proto.Name); + + Assert.AreEqual("optional_nested_enum", enumField.Name); + Assert.AreEqual(FieldType.Enum, enumField.FieldType); + Assert.AreEqual(MappedType.Enum, enumField.MappedType); + // Assert.AreEqual(TestAllTypes.Types.NestedEnum.Descriptor, enumField.EnumType); + + Assert.AreEqual("optional_foreign_message", messageField.Name); + Assert.AreEqual(FieldType.Message, messageField.FieldType); + Assert.AreEqual(MappedType.Message, messageField.MappedType); + Assert.AreEqual(ForeignMessage.Descriptor, messageField.MessageType); + + Assert.AreEqual("optional_cord", cordField.Name); + Assert.AreEqual(FieldType.String, cordField.FieldType); + Assert.AreEqual(MappedType.String, cordField.MappedType); + Assert.AreEqual(DescriptorProtos.FieldOptions.Types.CType.CORD, cordField.Options.Ctype); + + Assert.AreEqual("optional_int32_extension", extension.Name); + Assert.AreEqual("protobuf_unittest.optional_int32_extension", extension.FullName); + Assert.AreEqual(1, extension.FieldNumber); + Assert.AreEqual(TestAllExtensions.Descriptor, extension.ContainingType); + Assert.AreEqual(UnitTestProtoFile.Descriptor, extension.File); + Assert.AreEqual(FieldType.Int32, extension.FieldType); + Assert.AreEqual(MappedType.Int32, extension.MappedType); + Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance, + extension.Options); + Assert.IsTrue(extension.IsExtension); + Assert.AreEqual(null, extension.ExtensionScope); + Assert.AreEqual("optional_int32_extension", extension.Proto.Name); + + Assert.AreEqual("single", nestedExtension.Name); + Assert.AreEqual("protobuf_unittest.TestRequired.single", + nestedExtension.FullName); + Assert.AreEqual(TestRequired.Descriptor, + nestedExtension.ExtensionScope); + } + + [Test] + public void FieldDescriptorLabel() { + FieldDescriptor requiredField = + TestRequired.Descriptor.FindDescriptor<FieldDescriptor>("a"); + FieldDescriptor optionalField = + TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("optional_int32"); + FieldDescriptor repeatedField = + TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("repeated_int32"); + + Assert.IsTrue(requiredField.IsRequired); + Assert.IsFalse(requiredField.IsRepeated); + Assert.IsFalse(optionalField.IsRequired); + Assert.IsFalse(optionalField.IsRepeated); + Assert.IsFalse(repeatedField.IsRequired); + Assert.IsTrue(repeatedField.IsRepeated); + } + + [Test] + public void FieldDescriptorDefault() { + MessageDescriptor d = TestAllTypes.Descriptor; + Assert.IsFalse(d.FindDescriptor<FieldDescriptor>("optional_int32").HasDefaultValue); + Assert.AreEqual(0, d.FindDescriptor<FieldDescriptor>("optional_int32").DefaultValue); + Assert.IsTrue(d.FindDescriptor<FieldDescriptor>("default_int32").HasDefaultValue); + Assert.AreEqual(41, d.FindDescriptor<FieldDescriptor>("default_int32").DefaultValue); + + d = TestExtremeDefaultValues.Descriptor; + Assert.AreEqual(ByteString.CopyFrom("\u0000\u0001\u0007\b\f\n\r\t\u000b\\\'\"\u00fe", Encoding.GetEncoding(28591)), + d.FindDescriptor<FieldDescriptor>("escaped_bytes").DefaultValue); + Assert.AreEqual(uint.MaxValue, d.FindDescriptor<FieldDescriptor>("large_uint32").DefaultValue); + Assert.AreEqual(ulong.MaxValue, d.FindDescriptor<FieldDescriptor>("large_uint64").DefaultValue); + } + + [Test] + public void EnumDescriptor() { + // Note: this test is a bit different to the Java version because there's no static way of getting to the descriptor + EnumDescriptor enumType = UnitTestProtoFile.Descriptor.FindTypeByName<EnumDescriptor>("ForeignEnum"); + EnumDescriptor nestedType = TestAllTypes.Descriptor.FindDescriptor<EnumDescriptor>("NestedEnum"); + + Assert.AreEqual("ForeignEnum", enumType.Name); + Assert.AreEqual("protobuf_unittest.ForeignEnum", enumType.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, enumType.File); + Assert.IsNull(enumType.ContainingType); + Assert.AreEqual(DescriptorProtos.EnumOptions.DefaultInstance, + enumType.Options); + + Assert.AreEqual("NestedEnum", nestedType.Name); + Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedEnum", + nestedType.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File); + Assert.AreEqual(TestAllTypes.Descriptor, nestedType.ContainingType); + + EnumValueDescriptor value = enumType.FindValueByName("FOREIGN_FOO"); + Assert.AreEqual(value, enumType.Values[0]); + Assert.AreEqual("FOREIGN_FOO", value.Name); + Assert.AreEqual(4, value.Number); + Assert.AreEqual((int) ForeignEnum.FOREIGN_FOO, value.Number); + Assert.AreEqual(value, enumType.FindValueByNumber(4)); + Assert.IsNull(enumType.FindValueByName("NO_SUCH_VALUE")); + for (int i = 0; i < enumType.Values.Count; i++) { + Assert.AreEqual(i, enumType.Values[i].Index); + } + } + + [Test] + public void ServiceDescriptor() { + ServiceDescriptor service = TestService.Descriptor; + + Assert.AreEqual("TestService", service.Name); + Assert.AreEqual("protobuf_unittest.TestService", service.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, service.File); + + Assert.AreEqual(2, service.Methods.Count); + + MethodDescriptor fooMethod = service.Methods[0]; + Assert.AreEqual("Foo", fooMethod.Name); + Assert.AreEqual(FooRequest.Descriptor, fooMethod.InputType); + Assert.AreEqual(FooResponse.Descriptor, fooMethod.OutputType); + Assert.AreEqual(fooMethod, service.FindMethodByName("Foo")); + + MethodDescriptor barMethod = service.Methods[1]; + Assert.AreEqual("Bar", barMethod.Name); + Assert.AreEqual(BarRequest.Descriptor, barMethod.InputType); + Assert.AreEqual(BarResponse.Descriptor, barMethod.OutputType); + Assert.AreEqual(barMethod, service.FindMethodByName("Bar")); + + Assert.IsNull(service.FindMethodByName("NoSuchMethod")); + + for (int i = 0; i < service.Methods.Count; i++) { + Assert.AreEqual(i, service.Methods[i].Index); + } + } + } +} diff --git a/csharp/ProtocolBuffers.Test/DynamicMessageTest.cs b/csharp/ProtocolBuffers.Test/DynamicMessageTest.cs new file mode 100644 index 00000000..4a666935 --- /dev/null +++ b/csharp/ProtocolBuffers.Test/DynamicMessageTest.cs @@ -0,0 +1,103 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NUnit.Framework; +using Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class DynamicMessageTest { + + private ReflectionTester reflectionTester; + + private ReflectionTester extensionsReflectionTester; + + [SetUp] + public void SetUp() { + reflectionTester = new ReflectionTester(TestAllTypes.Descriptor, null); + extensionsReflectionTester = new ReflectionTester(TestAllExtensions.Descriptor, TestUtil.CreateExtensionRegistry()); + } + + [Test] + public void DynamicMessageAccessors() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + IMessage message = builder.Build(); + reflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void DynamicMessageExtensionAccessors() { + // We don't need to extensively test DynamicMessage's handling of + // extensions because, frankly, it doesn't do anything special with them. + // It treats them just like any other fields. + IBuilder builder = DynamicMessage.CreateBuilder(TestAllExtensions.Descriptor); + extensionsReflectionTester.SetAllFieldsViaReflection(builder); + IMessage message = builder.Build(); + extensionsReflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void DynamicMessageRepeatedSetters() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + reflectionTester.ModifyRepeatedFieldsViaReflection(builder); + IMessage message = builder.Build(); + reflectionTester.AssertRepeatedFieldsModifiedViaReflection(message); + } + + [Test] + public void DynamicMessageDefaults() { + reflectionTester.AssertClearViaReflection(DynamicMessage.GetDefaultInstance(TestAllTypes.Descriptor)); + reflectionTester.AssertClearViaReflection(DynamicMessage.CreateBuilder(TestAllTypes.Descriptor).Build()); + } + + [Test] + public void DynamicMessageSerializedSize() { + TestAllTypes message = TestUtil.GetAllSet(); + + IBuilder dynamicBuilder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(dynamicBuilder); + IMessage dynamicMessage = dynamicBuilder.Build(); + + Assert.AreEqual(message.SerializedSize, dynamicMessage.SerializedSize); + } + + [Test] + public void DynamicMessageSerialization() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + IMessage message = builder.Build(); + + ByteString rawBytes = message.ToByteString(); + TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); + + TestUtil.AssertAllFieldsSet(message2); + + // In fact, the serialized forms should be exactly the same, byte-for-byte. + Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), rawBytes); + } + + [Test] + public void DynamicMessageParsing() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestAllTypes message = builder.Build(); + + ByteString rawBytes = message.ToByteString(); + + IMessage message2 = DynamicMessage.ParseFrom(TestAllTypes.Descriptor, rawBytes); + reflectionTester.AssertAllFieldsSetViaReflection(message2); + } + + [Test] + public void DynamicMessageCopy() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestAllTypes message = builder.Build(); + + DynamicMessage copy = DynamicMessage.CreateBuilder(message).Build(); + reflectionTester.AssertAllFieldsSetViaReflection(copy); + } + } +} diff --git a/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 87c5bedb..54e07be1 100644 --- a/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -48,6 +48,8 @@ <Compile Include="ByteStringTest.cs" /> <Compile Include="CodedInputStreamTest.cs" /> <Compile Include="CodedOutputStreamTest.cs" /> + <Compile Include="DescriptorsTest.cs" /> + <Compile Include="DynamicMessageTest.cs" /> <Compile Include="Properties\AssemblyInfo.cs" /> <Compile Include="ReflectionTester.cs" /> <Compile Include="TestProtos\UnitTestEmbedOptimizeForProtoFile.cs" /> diff --git a/csharp/ProtocolBuffers.Test/ReflectionTester.cs b/csharp/ProtocolBuffers.Test/ReflectionTester.cs index c7767724..a0d3cec7 100644 --- a/csharp/ProtocolBuffers.Test/ReflectionTester.cs +++ b/csharp/ProtocolBuffers.Test/ReflectionTester.cs @@ -169,12 +169,12 @@ namespace Google.ProtocolBuffers { internal void SetAllFieldsViaReflection(IBuilder message) { message[f("optional_int32" )] = 101 ; message[f("optional_int64" )] = 102L; - message[f("optional_uint32" )] = 103 ; - message[f("optional_uint64" )] = 104L; + message[f("optional_uint32" )] = 103U ; + message[f("optional_uint64" )] = 104UL; message[f("optional_sint32" )] = 105 ; message[f("optional_sint64" )] = 106L; - message[f("optional_fixed32" )] = 107 ; - message[f("optional_fixed64" )] = 108L; + 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; @@ -199,12 +199,12 @@ namespace Google.ProtocolBuffers { message.AddRepeatedField(f("repeated_int32" ), 201 ); message.AddRepeatedField(f("repeated_int64" ), 202L); - message.AddRepeatedField(f("repeated_uint32" ), 203 ); - message.AddRepeatedField(f("repeated_uint64" ), 204L); + message.AddRepeatedField(f("repeated_uint32" ), 203U ); + message.AddRepeatedField(f("repeated_uint64" ), 204UL); message.AddRepeatedField(f("repeated_sint32" ), 205 ); message.AddRepeatedField(f("repeated_sint64" ), 206L); - message.AddRepeatedField(f("repeated_fixed32" ), 207 ); - message.AddRepeatedField(f("repeated_fixed64" ), 208L); + message.AddRepeatedField(f("repeated_fixed32" ), 207U ); + message.AddRepeatedField(f("repeated_fixed64" ), 208UL); message.AddRepeatedField(f("repeated_sfixed32"), 209 ); message.AddRepeatedField(f("repeated_sfixed64"), 210L); message.AddRepeatedField(f("repeated_float" ), 211F); @@ -229,12 +229,12 @@ namespace Google.ProtocolBuffers { // Add a second one of each field. message.AddRepeatedField(f("repeated_int32" ), 301 ); message.AddRepeatedField(f("repeated_int64" ), 302L); - message.AddRepeatedField(f("repeated_uint32" ), 303 ); - message.AddRepeatedField(f("repeated_uint64" ), 304L); + message.AddRepeatedField(f("repeated_uint32" ), 303U ); + message.AddRepeatedField(f("repeated_uint64" ), 304UL); message.AddRepeatedField(f("repeated_sint32" ), 305 ); message.AddRepeatedField(f("repeated_sint64" ), 306L); - message.AddRepeatedField(f("repeated_fixed32" ), 307 ); - message.AddRepeatedField(f("repeated_fixed64" ), 308L); + message.AddRepeatedField(f("repeated_fixed32" ), 307U ); + message.AddRepeatedField(f("repeated_fixed64" ), 308UL); message.AddRepeatedField(f("repeated_sfixed32"), 309 ); message.AddRepeatedField(f("repeated_sfixed64"), 310L); message.AddRepeatedField(f("repeated_float" ), 311F); @@ -267,12 +267,12 @@ namespace Google.ProtocolBuffers { message[f("default_int32" )] = 401 ; message[f("default_int64" )] = 402L; - message[f("default_uint32" )] = 403 ; - message[f("default_uint64" )] = 404L; + message[f("default_uint32" )] = 403U ; + message[f("default_uint64" )] = 404UL; message[f("default_sint32" )] = 405 ; message[f("default_sint64" )] = 406L; - message[f("default_fixed32" )] = 407 ; - message[f("default_fixed64" )] = 408L; + 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; @@ -299,12 +299,12 @@ namespace Google.ProtocolBuffers { internal void ModifyRepeatedFieldsViaReflection(IBuilder message) { message[f("repeated_int32" ), 1] = 501 ; message[f("repeated_int64" ), 1] = 502L; - message[f("repeated_uint32" ), 1] = 503 ; - message[f("repeated_uint64" ), 1] = 504L; + 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] = 507 ; - message[f("repeated_fixed64" ), 1] = 508L; + 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; @@ -332,7 +332,7 @@ namespace Google.ProtocolBuffers { /// Asserts that all fields of the specified message are set to the values /// assigned by SetAllFields, using the IMessage reflection interface. /// </summary> - public void assertAllFieldsSetViaReflection(IMessage message) { + 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" ))); @@ -368,12 +368,12 @@ namespace Google.ProtocolBuffers { Assert.AreEqual(101 , message[f("optional_int32" )]); Assert.AreEqual(102L , message[f("optional_int64" )]); - Assert.AreEqual(103 , message[f("optional_uint32" )]); - Assert.AreEqual(104L , message[f("optional_uint64" )]); + 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(107 , message[f("optional_fixed32" )]); - Assert.AreEqual(108L , message[f("optional_fixed64" )]); + 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" )]); @@ -425,12 +425,12 @@ namespace Google.ProtocolBuffers { Assert.AreEqual(201 , message[f("repeated_int32" ), 0]); Assert.AreEqual(202L , message[f("repeated_int64" ), 0]); - Assert.AreEqual(203 , message[f("repeated_uint32" ), 0]); - Assert.AreEqual(204L , message[f("repeated_uint64" ), 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(207 , message[f("repeated_fixed32" ), 0]); - Assert.AreEqual(208L , message[f("repeated_fixed64" ), 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]); @@ -453,12 +453,12 @@ namespace Google.ProtocolBuffers { Assert.AreEqual(301 , message[f("repeated_int32" ), 1]); Assert.AreEqual(302L , message[f("repeated_int64" ), 1]); - Assert.AreEqual(303 , message[f("repeated_uint32" ), 1]); - Assert.AreEqual(304L , message[f("repeated_uint64" ), 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(307 , message[f("repeated_fixed32" ), 1]); - Assert.AreEqual(308L , message[f("repeated_fixed64" ), 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]); @@ -469,12 +469,8 @@ namespace Google.ProtocolBuffers { 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(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]); @@ -510,12 +506,12 @@ namespace Google.ProtocolBuffers { Assert.AreEqual(401 , message[f("default_int32" )]); Assert.AreEqual(402L , message[f("default_int64" )]); - Assert.AreEqual(403 , message[f("default_uint32" )]); - Assert.AreEqual(404L , message[f("default_uint64" )]); + 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(407 , message[f("default_fixed32" )]); - Assert.AreEqual(408L , message[f("default_fixed64" )]); + 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" )]); @@ -532,14 +528,11 @@ namespace Google.ProtocolBuffers { Assert.AreEqual("425", message[f("default_cord")]); } - // ------------------------------------------------------------------- - - /** - * Assert (using {@code junit.framework.Assert}} that all fields of - * {@code message} are cleared, and that getting the fields returns their - * default values, using the {@link Message} reflection interface. - */ - public void assertClearViaReflection(IMessage message) { + /// <summary> + /// Assert that all fields of the message are cleared, and that + /// getting the fields returns their default values, using the reflection interface. + /// </summary> + 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" ))); @@ -572,12 +565,12 @@ namespace Google.ProtocolBuffers { // 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(0 , message[f("optional_uint32" )]); - Assert.AreEqual(0L , message[f("optional_uint64" )]); + 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(0 , message[f("optional_fixed32" )]); - Assert.AreEqual(0L , message[f("optional_fixed64" )]); + 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" )]); @@ -587,16 +580,12 @@ namespace Google.ProtocolBuffers { Assert.AreEqual(ByteString.Empty, message[f("optional_bytes")]); // Embedded messages should also be clear. - Assert.IsFalse( - ((IMessage)message[f("optionalgroup")]).HasField(groupA)); - Assert.IsFalse( - ((IMessage)message[f("optional_nested_message")]) + Assert.IsFalse(((IMessage)message[f("optionalgroup")]).HasField(groupA)); + Assert.IsFalse(((IMessage)message[f("optional_nested_message")]) .HasField(nestedB)); - Assert.IsFalse( - ((IMessage)message[f("optional_foreign_message")]) + Assert.IsFalse(((IMessage)message[f("optional_foreign_message")]) .HasField(foreignC)); - Assert.IsFalse( - ((IMessage)message[f("optional_import_message")]) + Assert.IsFalse(((IMessage)message[f("optional_import_message")]) .HasField(importD)); Assert.AreEqual(0,((IMessage)message[f("optionalgroup")])[groupA]); @@ -667,12 +656,12 @@ namespace Google.ProtocolBuffers { // Fields with defaults have their default values (duh). Assert.AreEqual( 41 , message[f("default_int32" )]); Assert.AreEqual( 42L , message[f("default_int64" )]); - Assert.AreEqual( 43 , message[f("default_uint32" )]); - Assert.AreEqual( 44L , message[f("default_uint64" )]); + 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( 47 , message[f("default_fixed32" )]); - Assert.AreEqual( 48L , message[f("default_fixed64" )]); + 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" )]); @@ -724,12 +713,12 @@ namespace Google.ProtocolBuffers { Assert.AreEqual(201 , message[f("repeated_int32" ), 0]); Assert.AreEqual(202L , message[f("repeated_int64" ), 0]); - Assert.AreEqual(203 , message[f("repeated_uint32" ), 0]); - Assert.AreEqual(204L , message[f("repeated_uint64" ), 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(207 , message[f("repeated_fixed32" ), 0]); - Assert.AreEqual(208L , message[f("repeated_fixed64" ), 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]); @@ -752,12 +741,12 @@ namespace Google.ProtocolBuffers { Assert.AreEqual(501 , message[f("repeated_int32" ), 1]); Assert.AreEqual(502L , message[f("repeated_int64" ), 1]); - Assert.AreEqual(503 , message[f("repeated_uint32" ), 1]); - Assert.AreEqual(504L , message[f("repeated_uint64" ), 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(507 , message[f("repeated_fixed32" ), 1]); - Assert.AreEqual(508L , message[f("repeated_fixed64" ), 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]); diff --git a/csharp/ProtocolBuffers/Descriptors/MessageDescriptor.cs b/csharp/ProtocolBuffers/Descriptors/MessageDescriptor.cs index b733fb93..02343937 100644 --- a/csharp/ProtocolBuffers/Descriptors/MessageDescriptor.cs +++ b/csharp/ProtocolBuffers/Descriptors/MessageDescriptor.cs @@ -34,6 +34,13 @@ namespace Google.ProtocolBuffers.Descriptors { } /// <value> + /// If this is a nested type, get the outer descriptor, otherwise null. + /// </value> + public MessageDescriptor ContainingType { + get { return containingType; } + } + + /// <value> /// An unmodifiable list of this message type's fields. /// </value> public IList<FieldDescriptor> Fields { diff --git a/csharp/ProtocolBuffers/Descriptors/MethodDescriptor.cs b/csharp/ProtocolBuffers/Descriptors/MethodDescriptor.cs index efc3fa4c..4b4dc707 100644 --- a/csharp/ProtocolBuffers/Descriptors/MethodDescriptor.cs +++ b/csharp/ProtocolBuffers/Descriptors/MethodDescriptor.cs @@ -28,7 +28,7 @@ namespace Google.ProtocolBuffers.Descriptors { /// The method's input type. /// </value> public MessageDescriptor OutputType { - get { return inputType; } + get { return outputType; } } internal MethodDescriptor(MethodDescriptorProto proto, FileDescriptor file, diff --git a/csharp/ProtocolBuffers/Descriptors/ServiceDescriptor.cs b/csharp/ProtocolBuffers/Descriptors/ServiceDescriptor.cs index d7c6f3a3..67ef0418 100644 --- a/csharp/ProtocolBuffers/Descriptors/ServiceDescriptor.cs +++ b/csharp/ProtocolBuffers/Descriptors/ServiceDescriptor.cs @@ -27,6 +27,15 @@ namespace Google.ProtocolBuffers.Descriptors { public IList<MethodDescriptor> Methods { get { return methods; } } + + /// <summary> + /// Finds a method by name. + /// </summary> + /// <param name="name">The unqualified name of the method (e.g. "Foo").</param> + /// <returns>The method's decsriptor, or null if not found.</returns> + public MethodDescriptor FindMethodByName(String name) { + return File.DescriptorPool.FindSymbol<MethodDescriptor>(FullName + "." + name); + } internal void CrossLink() { foreach (MethodDescriptor method in methods) { diff --git a/csharp/ProtocolBuffers/DynamicMessage.cs b/csharp/ProtocolBuffers/DynamicMessage.cs index 5b22d38b..5ffbdfbb 100644 --- a/csharp/ProtocolBuffers/DynamicMessage.cs +++ b/csharp/ProtocolBuffers/DynamicMessage.cs @@ -233,6 +233,10 @@ namespace Google.ProtocolBuffers { this.unknownFields = UnknownFieldSet.DefaultInstance; } + public DynamicMessage Build() { + return (DynamicMessage)((IBuilder)this).Build(); + } + public override IBuilder Clear() { fields.Clear(); return this; diff --git a/csharp/ProtocolBuffers/FieldSet.cs b/csharp/ProtocolBuffers/FieldSet.cs index bca7e5b5..4f660533 100644 --- a/csharp/ProtocolBuffers/FieldSet.cs +++ b/csharp/ProtocolBuffers/FieldSet.cs @@ -325,8 +325,13 @@ namespace Google.ProtocolBuffers { if (fields.TryGetValue(field, out result)) { return result; } - - // This will just do the right thing + if (field.MappedType == MappedType.Message) { + if (field.IsRepeated) { + return new List<object>(); + } else { + return null; + } + } return field.DefaultValue; } set { |