From cabd06d12fd7bd53c1896e8f77617cc00de70c4c Mon Sep 17 00:00:00 2001 From: Jon Skeet Date: Thu, 14 Aug 2008 20:35:25 +0100 Subject: More tests, and implementation of UninitializedMessageException description. --- csharp/ProtocolBuffers.Test/AbstractMessageTest.cs | 22 +- .../ProtocolBuffers.Test/GeneratedMessageTest.cs | 45 +-- csharp/ProtocolBuffers.Test/MessageTest.cs | 286 +++++++++++++++ .../ProtocolBuffers.Test.csproj | 5 + .../TestProtos/EnumWithNoOuter.cs | 16 + .../TestProtos/MessageWithNoOuter.cs | 395 +++++++++++++++++++++ .../TestProtos/MultiFileProto.cs | 85 +++++ .../TestProtos/ServiceWithNoOuter.cs | 103 ++++++ .../UnitTestEmbedOptimizeForProtoFile.cs | 5 +- .../TestProtos/UnitTestImportProtoFile.cs | 5 +- .../TestProtos/UnitTestMessageSetProtoFile.cs | 30 +- .../TestProtos/UnitTestOptimizeForProtoFile.cs | 5 +- .../TestProtos/UnitTestProtoFile.cs | 145 ++------ 13 files changed, 958 insertions(+), 189 deletions(-) create mode 100644 csharp/ProtocolBuffers.Test/MessageTest.cs create mode 100644 csharp/ProtocolBuffers.Test/TestProtos/EnumWithNoOuter.cs create mode 100644 csharp/ProtocolBuffers.Test/TestProtos/MessageWithNoOuter.cs create mode 100644 csharp/ProtocolBuffers.Test/TestProtos/MultiFileProto.cs create mode 100644 csharp/ProtocolBuffers.Test/TestProtos/ServiceWithNoOuter.cs (limited to 'csharp/ProtocolBuffers.Test') diff --git a/csharp/ProtocolBuffers.Test/AbstractMessageTest.cs b/csharp/ProtocolBuffers.Test/AbstractMessageTest.cs index 2c16b5b4..d1af0dca 100644 --- a/csharp/ProtocolBuffers.Test/AbstractMessageTest.cs +++ b/csharp/ProtocolBuffers.Test/AbstractMessageTest.cs @@ -63,13 +63,13 @@ namespace Google.ProtocolBuffers { TestRequired.Builder builder = TestRequired.CreateBuilder(); AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder); - Assert.IsFalse(abstractBuilder.Initialized); + Assert.IsFalse(abstractBuilder.IsInitialized); builder.A = 1; - Assert.IsFalse(abstractBuilder.Initialized); + Assert.IsFalse(abstractBuilder.IsInitialized); builder.B = 1; - Assert.IsFalse(abstractBuilder.Initialized); + Assert.IsFalse(abstractBuilder.IsInitialized); builder.C = 1; - Assert.IsTrue(abstractBuilder.Initialized); + Assert.IsTrue(abstractBuilder.IsInitialized); } [Test] @@ -77,19 +77,19 @@ namespace Google.ProtocolBuffers { TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder(); AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder); - Assert.IsTrue(abstractBuilder.Initialized); + Assert.IsTrue(abstractBuilder.IsInitialized); builder.SetOptionalMessage(TestRequiredUninitialized); - Assert.IsFalse(abstractBuilder.Initialized); + Assert.IsFalse(abstractBuilder.IsInitialized); builder.SetOptionalMessage(TestRequiredInitialized); - Assert.IsTrue(abstractBuilder.Initialized); + Assert.IsTrue(abstractBuilder.IsInitialized); builder.AddRepeatedMessage(TestRequiredUninitialized); - Assert.IsFalse(abstractBuilder.Initialized); + Assert.IsFalse(abstractBuilder.IsInitialized); builder.SetRepeatedMessage(0, TestRequiredInitialized); - Assert.IsTrue(abstractBuilder.Initialized); + Assert.IsTrue(abstractBuilder.IsInitialized); } // ----------------------------------------------------------------- @@ -261,8 +261,8 @@ namespace Google.ProtocolBuffers { this.wrappedBuilder = wrappedBuilder; } - public override bool Initialized { - get { return wrappedBuilder.Initialized; } + public override bool IsInitialized { + get { return wrappedBuilder.IsInitialized; } } public override IDictionary AllFields { diff --git a/csharp/ProtocolBuffers.Test/GeneratedMessageTest.cs b/csharp/ProtocolBuffers.Test/GeneratedMessageTest.cs index 36a63c17..7299b50b 100644 --- a/csharp/ProtocolBuffers.Test/GeneratedMessageTest.cs +++ b/csharp/ProtocolBuffers.Test/GeneratedMessageTest.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Text; +using Google.ProtocolBuffers.Descriptors; using NUnit.Framework; using Google.ProtocolBuffers.TestProtos; @@ -176,49 +177,41 @@ namespace Google.ProtocolBuffers { public void ExtensionReflectionDefaults() { extensionsReflectionTester.AssertClearViaReflection(TestAllExtensions.DefaultInstance); extensionsReflectionTester.AssertClearViaReflection(TestAllExtensions.CreateBuilder().Build()); - } - - public void testClearExtension() { - // clearExtension() is not actually used in TestUtil, so try it manually. + } + + [Test] + public void ClearExtension() { + // ClearExtension() is not actually used in TestUtil, so try it manually. Assert.IsFalse(TestAllExtensions.CreateBuilder() .SetExtension(UnitTestProtoFile.OptionalInt32Extension, 1) .ClearExtension(UnitTestProtoFile.OptionalInt32Extension) .HasExtension(UnitTestProtoFile.OptionalInt32Extension)); - Assert.AreEqual(0, - TestAllExtensions.CreateBuilder() + Assert.AreEqual(0, TestAllExtensions.CreateBuilder() .AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 1) .ClearExtension(UnitTestProtoFile.RepeatedInt32Extension) .GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); } - // ================================================================= - // multiple_files_test - /* FIXME: Find this proto! + [Test] public void MultipleFilesOption() { // We mostly just want to check that things compile. MessageWithNoOuter message = MessageWithNoOuter.CreateBuilder() - .setNested(MessageWithNoOuter.NestedMessage.CreateBuilder().setI(1)) - .addForeign(TestAllTypes.CreateBuilder().setOptionalInt32(1)) - .setNestedEnum(MessageWithNoOuter.NestedEnum.BAZ) - .setForeignEnum(EnumWithNoOuter.BAR) + .SetNested(MessageWithNoOuter.Types.NestedMessage.CreateBuilder().SetI(1)) + .AddForeign(TestAllTypes.CreateBuilder().SetOptionalInt32(1)) + .SetNestedEnum(MessageWithNoOuter.Types.NestedEnum.BAZ) + .SetForeignEnum(EnumWithNoOuter.BAR) .Build(); - Assert.AreEqual(message, MessageWithNoOuter.parseFrom(message.toByteString())); + Assert.AreEqual(message, MessageWithNoOuter.ParseFrom(message.ToByteString())); - Assert.AreEqual(MultipleFilesTestProto.getDescriptor(), - MessageWithNoOuter.getDescriptor().getFile()); + Assert.AreEqual(MultiFileProto.Descriptor, MessageWithNoOuter.Descriptor.File); - Descriptors.FieldDescriptor field = - MessageWithNoOuter.getDescriptor().findFieldByName("foreign_enum"); - Assert.AreEqual(EnumWithNoOuter.BAR.getValueDescriptor(), - message.getField(field)); + FieldDescriptor field = MessageWithNoOuter.Descriptor.FindDescriptor("foreign_enum"); + Assert.AreEqual(MultiFileProto.Descriptor.FindTypeByName("EnumWithNoOuter") + .FindValueByNumber((int)EnumWithNoOuter.BAR), message[field]); - Assert.AreEqual(MultipleFilesTestProto.getDescriptor(), - ServiceWithNoOuter.getDescriptor().getFile()); + Assert.AreEqual(MultiFileProto.Descriptor, ServiceWithNoOuter.Descriptor.File); - assertFalse( - TestAllExtensions.getDefaultInstance().hasExtension( - MultipleFilesTestProto.extensionWithOuter)); + Assert.IsFalse(TestAllExtensions.DefaultInstance.HasExtension(MultiFileProto.ExtensionWithOuter)); } - */ } } diff --git a/csharp/ProtocolBuffers.Test/MessageTest.cs b/csharp/ProtocolBuffers.Test/MessageTest.cs new file mode 100644 index 00000000..60aa3d17 --- /dev/null +++ b/csharp/ProtocolBuffers.Test/MessageTest.cs @@ -0,0 +1,286 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + /// + /// Miscellaneous tests for message operations that apply to both + /// generated and dynamic messages. + /// + [TestFixture] + public class MessageTest { + // ================================================================= + // Message-merging tests. + + private static readonly TestAllTypes MergeSource = new TestAllTypes.Builder { + OptionalInt32 = 1, + OptionalString = "foo", + OptionalForeignMessage = ForeignMessage.DefaultInstance, + }.AddRepeatedString("bar").Build(); + + private static readonly TestAllTypes MergeDest = new TestAllTypes.Builder { + OptionalInt64 = 2, + OptionalString = "baz", + OptionalForeignMessage = new ForeignMessage.Builder { C=3 }.Build(), + }.AddRepeatedString("qux").Build(); + + private const string MergeResultText = + "optional_int32: 1\n" + + "optional_int64: 2\n" + + "optional_string: \"foo\"\n" + + "optional_foreign_message {\n" + + " c: 3\n" + + "}\n" + + "repeated_string: \"qux\"\n" + + "repeated_string: \"bar\"\n"; + + [Test] + public void MergeFrom() { + TestAllTypes result = TestAllTypes.CreateBuilder(MergeDest).MergeFrom(MergeSource).Build(); + + Assert.AreEqual(MergeResultText, result.ToString()); + } + + /// + /// Test merging a DynamicMessage into a GeneratedMessage. + /// As long as they have the same descriptor, this should work, but it is an + /// entirely different code path. + /// + [Test] + public void MergeFromDynamic() { + TestAllTypes result = (TestAllTypes) TestAllTypes.CreateBuilder(MergeDest) + .MergeFrom(DynamicMessage.CreateBuilder(MergeSource).Build()) + .Build(); + + Assert.AreEqual(MergeResultText, result.ToString()); + } + + /** Test merging two DynamicMessages. */ + public void testDynamicMergeFrom() { + DynamicMessage result = (DynamicMessage) DynamicMessage.CreateBuilder(MergeDest) + .MergeFrom((DynamicMessage) DynamicMessage.CreateBuilder(MergeSource).Build()) + .Build(); + + Assert.AreEqual(MergeResultText, result.ToString()); + } + + // ================================================================= + // Required-field-related tests. + + private static readonly TestRequired TestRequiredUninitialized = TestRequired.DefaultInstance; + private static readonly TestRequired TestRequiredInitialized = new TestRequired.Builder { + A = 1, B = 2, C = 3 + }.Build(); + + [Test] + public void Initialization() { + TestRequired.Builder builder = TestRequired.CreateBuilder(); + + Assert.IsFalse(builder.IsInitialized); + builder.A = 1; + Assert.IsFalse(builder.IsInitialized); + builder.B = 1; + Assert.IsFalse(builder.IsInitialized); + builder.C = 1; + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void RequiredForeign() { + TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder(); + + Assert.IsTrue(builder.IsInitialized); + + builder.SetOptionalMessage(TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetOptionalMessage(TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + + builder.AddRepeatedMessage(TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetRepeatedMessage(0, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void RequiredExtension() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + + Assert.IsTrue(builder.IsInitialized); + + builder.SetExtension(TestRequired.Types.Single, TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetExtension(TestRequired.Types.Single, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + + builder.AddExtension(TestRequired.Types.Multi, TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetExtension(TestRequired.Types.Multi, 0, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void RequiredDynamic() { + MessageDescriptor descriptor = TestRequired.Descriptor; + DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor); + + Assert.IsFalse(builder.IsInitialized); + builder[descriptor.FindDescriptor("a")] = 1; + Assert.IsFalse(builder.IsInitialized); + builder[descriptor.FindDescriptor("b")] = 1; + Assert.IsFalse(builder.IsInitialized); + builder[descriptor.FindDescriptor("c")] = 1; + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void RequiredDynamicForeign() { + MessageDescriptor descriptor = TestRequiredForeign.Descriptor; + DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor); + + Assert.IsTrue(builder.IsInitialized); + + builder[descriptor.FindDescriptor("optional_message")] = TestRequiredUninitialized; + Assert.IsFalse(builder.IsInitialized); + + builder[descriptor.FindDescriptor("optional_message")] = TestRequiredInitialized; + Assert.IsTrue(builder.IsInitialized); + + // TODO(jonskeet): Remove this nastiness by making IBuilder always generic. + ((IBuilder) builder).AddRepeatedField(descriptor.FindDescriptor("repeated_message"), TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetRepeatedField(descriptor.FindDescriptor("repeated_message"), 0, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void UninitializedException() { + try { + TestRequired.CreateBuilder().Build(); + Assert.Fail("Should have thrown an exception."); + } catch (UninitializedMessageException e) { + Assert.AreEqual("Message missing required fields: a, b, c", e.Message); + } + } + + [Test] + public void BuildPartial() { + // We're mostly testing that no exception is thrown. + TestRequired message = TestRequired.CreateBuilder().BuildPartial(); + Assert.IsFalse(message.IsInitialized); + } + + [Test] + public void NestedUninitializedException() { + try { + TestRequiredForeign.CreateBuilder() + .SetOptionalMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .Build(); + Assert.Fail("Should have thrown an exception."); + } catch (UninitializedMessageException e) { + Assert.AreEqual( + "Message missing required fields: " + + "optional_message.a, " + + "optional_message.b, " + + "optional_message.c, " + + "repeated_message[0].a, " + + "repeated_message[0].b, " + + "repeated_message[0].c, " + + "repeated_message[1].a, " + + "repeated_message[1].b, " + + "repeated_message[1].c", + e.Message); + } + } + + [Test] + public void BuildNestedPartial() { + // We're mostly testing that no exception is thrown. + TestRequiredForeign message = + TestRequiredForeign.CreateBuilder() + .SetOptionalMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .BuildPartial(); + Assert.IsFalse(message.IsInitialized); + } + + [Test] + public void ParseUnititialized() { + try { + TestRequired.ParseFrom(ByteString.Empty); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual("Message missing required fields: a, b, c", e.Message); + } + } + + [Test] + public void ParseNestedUnititialized() { + ByteString data = + TestRequiredForeign.CreateBuilder() + .SetOptionalMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .BuildPartial().ToByteString(); + + try { + TestRequiredForeign.ParseFrom(data); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual( + "Message missing required fields: " + + "optional_message.a, " + + "optional_message.b, " + + "optional_message.c, " + + "repeated_message[0].a, " + + "repeated_message[0].b, " + + "repeated_message[0].c, " + + "repeated_message[1].a, " + + "repeated_message[1].b, " + + "repeated_message[1].c", + e.Message); + } + } + + [Test] + public void DynamicUninitializedException() { + try { + DynamicMessage.CreateBuilder(TestRequired.Descriptor).Build(); + Assert.Fail("Should have thrown an exception."); + } catch (UninitializedMessageException e) { + Assert.AreEqual("Message missing required fields: a, b, c", e.Message); + } + } + + [Test] + public void DynamicBuildPartial() { + // We're mostly testing that no exception is thrown. + // TODO(jonskeet): Fix this ghastly casting mess + DynamicMessage message = (DynamicMessage) ((IBuilder) DynamicMessage.CreateBuilder(TestRequired.Descriptor)).BuildPartial(); + Assert.IsFalse(message.Initialized); + } + + [Test] + public void DynamicParseUnititialized() { + try { + MessageDescriptor descriptor = TestRequired.Descriptor; + DynamicMessage.ParseFrom(descriptor, ByteString.Empty); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual("Message missing required fields: a, b, c", e.Message); + } + } + } + +} diff --git a/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 314dad34..44e8e3fd 100644 --- a/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -51,8 +51,13 @@ + + + + + diff --git a/csharp/ProtocolBuffers.Test/TestProtos/EnumWithNoOuter.cs b/csharp/ProtocolBuffers.Test/TestProtos/EnumWithNoOuter.cs new file mode 100644 index 00000000..f85d31fe --- /dev/null +++ b/csharp/ProtocolBuffers.Test/TestProtos/EnumWithNoOuter.cs @@ -0,0 +1,16 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +using pb = global::Google.ProtocolBuffers; +using pbc = global::Google.ProtocolBuffers.Collections; +using pbd = global::Google.ProtocolBuffers.Descriptors; +using scg = global::System.Collections.Generic; +using self = global::Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers.TestProtos { + + public enum EnumWithNoOuter { + FOO = 1, + BAR = 2, + } + +} diff --git a/csharp/ProtocolBuffers.Test/TestProtos/MessageWithNoOuter.cs b/csharp/ProtocolBuffers.Test/TestProtos/MessageWithNoOuter.cs new file mode 100644 index 00000000..860b7a03 --- /dev/null +++ b/csharp/ProtocolBuffers.Test/TestProtos/MessageWithNoOuter.cs @@ -0,0 +1,395 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +using pb = global::Google.ProtocolBuffers; +using pbc = global::Google.ProtocolBuffers.Collections; +using pbd = global::Google.ProtocolBuffers.Descriptors; +using scg = global::System.Collections.Generic; +using self = global::Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers.TestProtos { + + public sealed partial class MessageWithNoOuter : pb::GeneratedMessage { + private static readonly MessageWithNoOuter defaultInstance = new MessageWithNoOuter(); + public static MessageWithNoOuter DefaultInstance { + get { return defaultInstance; } + } + + public override MessageWithNoOuter DefaultInstanceForType { + get { return defaultInstance; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return self::MultiFileProto.internal__static_protobuf_unittest_MessageWithNoOuter__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return self::MultiFileProto.internal__static_protobuf_unittest_MessageWithNoOuter__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum NestedEnum { + BAZ = 3, + } + + public sealed partial class NestedMessage : pb::GeneratedMessage { + private static readonly NestedMessage defaultInstance = new NestedMessage(); + public static NestedMessage DefaultInstance { + get { return defaultInstance; } + } + + public override NestedMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return self::MultiFileProto.internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return self::MultiFileProto.internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__FieldAccessorTable; } + } + + // optional int32 i = 1; + private bool hasI; + private int i_ = 0; + public bool HasI { + get { return hasI; } + } + public int I { + get { return i_; } + } + + public static self::MessageWithNoOuter.Types.NestedMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static self::MessageWithNoOuter.Types.NestedMessage ParseFrom(pb::ByteString data, + pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) + .BuildParsed(); + } + public static self::MessageWithNoOuter.Types.NestedMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static self::MessageWithNoOuter.Types.NestedMessage ParseFrom(byte[] data, + pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) + .BuildParsed(); + } + public static self::MessageWithNoOuter.Types.NestedMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static self::MessageWithNoOuter.Types.NestedMessage ParseFrom( + global::System.IO.Stream input, + pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)) + .BuildParsed(); + } + public static self::MessageWithNoOuter.Types.NestedMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static self::MessageWithNoOuter.Types.NestedMessage ParseFrom(pb::CodedInputStream input, + pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)) + .BuildParsed(); + } + + public static Builder CreateBuilder() { return new Builder(); } + public override IBuilder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(self::MessageWithNoOuter.Types.NestedMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + // Construct using self::MessageWithNoOuter.Types.NestedMessage.CreateBuilder() + internal Builder() {} + + self::MessageWithNoOuter.Types.NestedMessage result = new self::MessageWithNoOuter.Types.NestedMessage(); + + protected override self::MessageWithNoOuter.Types.NestedMessage MessageBeingBuilt { + get { return result; } + } + + public override IBuilder Clear() { + result = new self::MessageWithNoOuter.Types.NestedMessage(); + return this; + } + + public override IBuilder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return self::MessageWithNoOuter.Types.NestedMessage.Descriptor; } + } + + public override self::MessageWithNoOuter.Types.NestedMessage DefaultInstanceForType { + get { return self::MessageWithNoOuter.Types.NestedMessage.DefaultInstance; } + } + + public override self::MessageWithNoOuter.Types.NestedMessage BuildPartial() { + self::MessageWithNoOuter.Types.NestedMessage returnMe = result; + result = null; + return returnMe; + } + + + // optional int32 i = 1; + public bool HasI { + get { return result.HasI; } + } + public int I { + get { return result.I; } + set { SetI(value); } + } + public Builder SetI(int value) { + result.hasI = true; + result.i_ = value; + return this; + } + public Builder ClearI() { + result.hasI = false; + result.i_ = 0; + return this; + } + } + } + + } + #endregion + + // optional .protobuf_unittest.MessageWithNoOuter.NestedMessage nested = 1; + private bool hasNested; + private self::MessageWithNoOuter.Types.NestedMessage nested_ = self::MessageWithNoOuter.Types.NestedMessage.DefaultInstance; + public bool HasNested { + get { return hasNested; } + } + public self::MessageWithNoOuter.Types.NestedMessage Nested { + get { return nested_; } + } + + // repeated .protobuf_unittest.TestAllTypes foreign = 2; + private scg::IList foreign_ = pbc::Lists.Empty; + public scg::IList ForeignList { + get { return foreign_; } + } + public int ForeignCount + { get { return foreign_.Count; } + } + public self::TestAllTypes GetForeign(int index) { + return foreign_ [index]; + } + + // optional .protobuf_unittest.MessageWithNoOuter.NestedEnum nested_enum = 3; + private bool hasNestedEnum; + private self::MessageWithNoOuter.Types.NestedEnum nestedEnum_ = self::MessageWithNoOuter.Types.NestedEnum.BAZ; + public bool HasNestedEnum { + get { return hasNestedEnum; } + } + public self::MessageWithNoOuter.Types.NestedEnum NestedEnum { get { return nestedEnum_; }} + + // optional .protobuf_unittest.EnumWithNoOuter foreign_enum = 4; + private bool hasForeignEnum; + private self::EnumWithNoOuter foreignEnum_ = self::EnumWithNoOuter.FOO; + public bool HasForeignEnum { + get { return hasForeignEnum; } + } + public self::EnumWithNoOuter ForeignEnum { get { return foreignEnum_; }} + + public static self::MessageWithNoOuter ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static self::MessageWithNoOuter ParseFrom(pb::ByteString data, + pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) + .BuildParsed(); + } + public static self::MessageWithNoOuter ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static self::MessageWithNoOuter ParseFrom(byte[] data, + pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) + .BuildParsed(); + } + public static self::MessageWithNoOuter ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static self::MessageWithNoOuter ParseFrom( + global::System.IO.Stream input, + pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)) + .BuildParsed(); + } + public static self::MessageWithNoOuter ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static self::MessageWithNoOuter ParseFrom(pb::CodedInputStream input, + pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)) + .BuildParsed(); + } + + public static Builder CreateBuilder() { return new Builder(); } + public override IBuilder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(self::MessageWithNoOuter prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + // Construct using self::MessageWithNoOuter.CreateBuilder() + internal Builder() {} + + self::MessageWithNoOuter result = new self::MessageWithNoOuter(); + + protected override self::MessageWithNoOuter MessageBeingBuilt { + get { return result; } + } + + public override IBuilder Clear() { + result = new self::MessageWithNoOuter(); + return this; + } + + public override IBuilder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return self::MessageWithNoOuter.Descriptor; } + } + + public override self::MessageWithNoOuter DefaultInstanceForType { + get { return self::MessageWithNoOuter.DefaultInstance; } + } + + public override self::MessageWithNoOuter BuildPartial() { + if (result.foreign_ != pbc::Lists.Empty) { + result.foreign_ = pbc::Lists.AsReadOnly(result.foreign_); + } + self::MessageWithNoOuter returnMe = result; + result = null; + return returnMe; + } + + + // optional .protobuf_unittest.MessageWithNoOuter.NestedMessage nested = 1; + public bool HasNested { + get { return result.HasNested; } + } + public self::MessageWithNoOuter.Types.NestedMessage Nested { + get { return result.Nested; } + set { SetNested(value); } + } + public Builder SetNested(self::MessageWithNoOuter.Types.NestedMessage value) { + result.hasNested = true; + result.nested_ = value; + return this; + } + public Builder SetNested(self::MessageWithNoOuter.Types.NestedMessage.Builder builderForValue) { + result.hasNested = true; + result.nested_ = builderForValue.Build(); + return this; + } + public Builder MergeNested(self::MessageWithNoOuter.Types.NestedMessage value) { + if (result.HasNested && + result.nested_ != self::MessageWithNoOuter.Types.NestedMessage.DefaultInstance) { + result.nested_ = + self::MessageWithNoOuter.Types.NestedMessage.CreateBuilder(result.nested_).MergeFrom(value).BuildPartial(); + } else { + result.nested_ = value; + } + result.hasNested = true; + return this; + } + public Builder ClearNested() { + result.hasNested = false; + result.nested_ = self::MessageWithNoOuter.Types.NestedMessage.DefaultInstance; + return this; + } + + // repeated .protobuf_unittest.TestAllTypes foreign = 2; + public scg::IList ForeignList { + get { return pbc::Lists.AsReadOnly(result.foreign_); } + } + public int ForeignCount { + get { return result.ForeignCount; } + } + public self::TestAllTypes GetForeign(int index) { + return result.GetForeign(index); + } + public Builder SetForeign(int index, self::TestAllTypes value) { + result.foreign_[index] = value; + return this; + } + public Builder SetForeign(int index, self::TestAllTypes.Builder builderForValue) { + result.foreign_[index] = builderForValue.Build(); + return this; + } + public Builder AddForeign(self::TestAllTypes value) { + if (result.foreign_ == pbc::Lists.Empty) { + result.foreign_ = new scg::List(); + } + result.foreign_.Add(value); + return this; + } + public Builder AddForeign(self::TestAllTypes.Builder builderForValue) { + if (result.foreign_ == pbc::Lists.Empty) { + result.foreign_ = new scg::List(); + } + result.foreign_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeForeign(scg::IEnumerable values) { + if (result.foreign_ == pbc::Lists.Empty) { + result.foreign_ = new scg::List(); + } + base.AddRange(values, result.foreign_); + return this; + } + public Builder ClearForeign() { + result.foreign_ = pbc::Lists.Empty; + return this; + } + + // optional .protobuf_unittest.MessageWithNoOuter.NestedEnum nested_enum = 3; + public bool HasNestedEnum { + get { return result.HasNestedEnum; } + } + public self::MessageWithNoOuter.Types.NestedEnum NestedEnum { + get { return result.NestedEnum; } + set { SetNestedEnum(value); } + } + public Builder SetNestedEnum(self::MessageWithNoOuter.Types.NestedEnum value) { + result.hasNestedEnum = true; + result.nestedEnum_ = value; + return this; + } + public Builder ClearNestedEnum() { + result.hasNestedEnum = false; + result.nestedEnum_ = self::MessageWithNoOuter.Types.NestedEnum.BAZ; + return this; + } + + // optional .protobuf_unittest.EnumWithNoOuter foreign_enum = 4; + public bool HasForeignEnum { + get { return result.HasForeignEnum; } + } + public self::EnumWithNoOuter ForeignEnum { + get { return result.ForeignEnum; } + set { SetForeignEnum(value); } + } + public Builder SetForeignEnum(self::EnumWithNoOuter value) { + result.hasForeignEnum = true; + result.foreignEnum_ = value; + return this; + } + public Builder ClearForeignEnum() { + result.hasForeignEnum = false; + result.foreignEnum_ = self::EnumWithNoOuter.FOO; + return this; + } + } + } + +} diff --git a/csharp/ProtocolBuffers.Test/TestProtos/MultiFileProto.cs b/csharp/ProtocolBuffers.Test/TestProtos/MultiFileProto.cs new file mode 100644 index 00000000..05a99876 --- /dev/null +++ b/csharp/ProtocolBuffers.Test/TestProtos/MultiFileProto.cs @@ -0,0 +1,85 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +using pb = global::Google.ProtocolBuffers; +using pbc = global::Google.ProtocolBuffers.Collections; +using pbd = global::Google.ProtocolBuffers.Descriptors; +using scg = global::System.Collections.Generic; +using self = global::Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers.TestProtos { + + public static partial class MultiFileProto { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom ( + new byte[] { + 0x0a, 0x3b, 0x73, 0x72, 0x63, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x2f, 0x63, 0x6f, 0x6d, 0x2f, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x6d, 0x75, 0x6c, 0x74, + 0x69, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x11, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, + 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x75, 0x6e, + 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xbf, 0x02, 0x0a, 0x12, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x43, 0x0a, 0x06, 0x6e, + 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x57, + 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x07, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, + 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x45, 0x0a, 0x0b, 0x6e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x30, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x38, 0x0a, 0x0c, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x5f, 0x65, 0x6e, 0x75, + 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, + 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, + 0x74, 0x65, 0x72, 0x1a, 0x1a, 0x0a, 0x0d, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x12, 0x09, 0x0a, 0x01, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x22, 0x15, 0x0a, 0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x5a, 0x10, 0x03, 0x2a, 0x23, 0x0a, 0x0f, 0x45, 0x6e, + 0x75, 0x6d, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x07, 0x0a, 0x03, 0x46, 0x4f, 0x4f, + 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x42, 0x41, 0x52, 0x10, 0x02, 0x32, 0x63, 0x0a, 0x12, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x4d, 0x0a, 0x03, 0x46, 0x6f, 0x6f, + 0x12, 0x25, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, + 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x57, 0x69, 0x74, 0x68, 0x4e, 0x6f, 0x4f, 0x75, 0x74, 0x65, 0x72, 0x1a, + 0x1f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, + 0x54, 0x65, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x54, 0x79, 0x70, 0x65, 0x73, 0x3a, 0x44, 0x0a, 0x14, 0x65, 0x78, 0x74, 0x65, + 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x24, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, + 0x74, 0x41, 0x6c, 0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x87, 0xad, 0x4b, 0x20, 0x01, + 0x28, 0x05, 0x42, 0x58, 0x42, 0x16, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x54, + 0x65, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0xc2, 0x3e, 0x21, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x2e, 0x54, 0x65, 0x73, 0x74, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0xca, 0x3e, 0x0e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x46, 0x69, 0x6c, 0x65, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0xd0, 0x3e, 0x01, 0xd8, 0x3e, 0x00, 0xe0, 0x3e, 0x01, + }, new pbd::FileDescriptor[] { + self::UnitTestProtoFile.Descriptor, + }); + #endregion + + #region Extensions + public static readonly pb::GeneratedExtensionBase ExtensionWithOuter = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[0]); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_MessageWithNoOuter__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_MessageWithNoOuter__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_MessageWithNoOuter__Descriptor, + new string[] { "Nested", "Foreign", "NestedEnum", "ForeignEnum", }, + typeof (self::MessageWithNoOuter), + typeof (self::MessageWithNoOuter.Builder)); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__Descriptor + = internal__static_protobuf_unittest_MessageWithNoOuter__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_MessageWithNoOuter_NestedMessage__Descriptor, + new string[] { "I", }, + typeof (self::MessageWithNoOuter.Types.NestedMessage), + typeof (self::MessageWithNoOuter.Types.NestedMessage.Builder)); + #endregion + + } + +} diff --git a/csharp/ProtocolBuffers.Test/TestProtos/ServiceWithNoOuter.cs b/csharp/ProtocolBuffers.Test/TestProtos/ServiceWithNoOuter.cs new file mode 100644 index 00000000..61dfcc3c --- /dev/null +++ b/csharp/ProtocolBuffers.Test/TestProtos/ServiceWithNoOuter.cs @@ -0,0 +1,103 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +using pb = global::Google.ProtocolBuffers; +using pbc = global::Google.ProtocolBuffers.Collections; +using pbd = global::Google.ProtocolBuffers.Descriptors; +using scg = global::System.Collections.Generic; +using self = global::Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers.TestProtos { + + public abstract class ServiceWithNoOuter : pb::IService { + public abstract void Foo( + pb::IRpcController controller, + self::MessageWithNoOuter request, + global::System.Action done); + + public static pbd::ServiceDescriptor Descriptor { + get { return self::MultiFileProto.Descriptor.Services[0]; } + } + public pbd::ServiceDescriptor DescriptorForType { + get { return Descriptor; } + } + + public void CallMethod( + pbd::MethodDescriptor method, + pb::IRpcController controller, + pb::IMessage request, + global::System.Action done) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.CallMethod() given method descriptor for wrong " + + "service type."); + } + switch(method.Index) { + case 0: + this.Foo(controller, (self::MessageWithNoOuter)request, + pb::RpcUtil.SpecializeCallback( + done)); + return; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public pb::IMessage GetRequestPrototype(pbd::MethodDescriptor method) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.GetRequestPrototype() given method " + + "descriptor for wrong service type."); + } + switch(method.Index) { + case 0: + return self::MessageWithNoOuter.DefaultInstance; + default: + throw new global::System.ArgumentException("Can't get here."); + } + } + + public pb::IMessage GetResponsePrototype(pbd::MethodDescriptor method) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.GetResponsePrototype() given method " + + "descriptor for wrong service type."); + } + switch(method.Index) { + case 0: + return self::TestAllTypes.DefaultInstance; + default: + throw new global::System.ArgumentException("Can't get here."); + } + } + + public static Stub CreateStub( + pb::IRpcChannel channel) { + return new Stub(channel); + } + + public class Stub : self::ServiceWithNoOuter { + internal Stub(pb::IRpcChannel channel) { + this.channel = channel; + } + + private readonly pb::IRpcChannel channel; + + public pb::IRpcChannel Channel { + get { return channel; } + } + + public override void Foo( + pb::IRpcController controller, + self::MessageWithNoOuter request, + global::System.Action done) { + channel.CallMethod( + Descriptor.Methods[0], + controller, + request, + self::TestAllTypes.DefaultInstance, + pb::RpcUtil.GeneralizeCallback(done, self::TestAllTypes.DefaultInstance)); + } + } + } + +} diff --git a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs index dd07da89..b96c7c9e 100644 --- a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs +++ b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs @@ -59,9 +59,6 @@ namespace Google.ProtocolBuffers.TestProtos { #region Messages public sealed partial class TestEmbedOptimizedForSize : pb::GeneratedMessage { - // Use TestEmbedOptimizedForSize.CreateBuilder() to construct. - private TestEmbedOptimizedForSize() {} - private static readonly TestEmbedOptimizedForSize defaultInstance = new TestEmbedOptimizedForSize(); public static TestEmbedOptimizedForSize DefaultInstance { get { return defaultInstance; } @@ -153,7 +150,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestEmbedOptimizedForSize ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestEmbedOptimizedForSize parseFrom(byte[] data, + public static self::TestEmbedOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); diff --git a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs index c7e68878..d798070c 100644 --- a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs +++ b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs @@ -59,9 +59,6 @@ namespace Google.ProtocolBuffers.TestProtos { #region Messages public sealed partial class ImportMessage : pb::GeneratedMessage { - // Use ImportMessage.CreateBuilder() to construct. - private ImportMessage() {} - private static readonly ImportMessage defaultInstance = new ImportMessage(); public static ImportMessage DefaultInstance { get { return defaultInstance; } @@ -129,7 +126,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::ImportMessage ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::ImportMessage parseFrom(byte[] data, + public static self::ImportMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); diff --git a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs index 4a8fc794..dc2c62b1 100644 --- a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs +++ b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs @@ -109,9 +109,6 @@ namespace Google.ProtocolBuffers.TestProtos { #region Messages public sealed partial class TestMessageSet : pb::ExtendableMessage { - // Use TestMessageSet.CreateBuilder() to construct. - private TestMessageSet() {} - private static readonly TestMessageSet defaultInstance = new TestMessageSet(); public static TestMessageSet DefaultInstance { get { return defaultInstance; } @@ -167,7 +164,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestMessageSet ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestMessageSet parseFrom(byte[] data, + public static self::TestMessageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -277,9 +274,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestMessageSetContainer : pb::GeneratedMessage { - // Use TestMessageSetContainer.CreateBuilder() to construct. - private TestMessageSetContainer() {} - private static readonly TestMessageSetContainer defaultInstance = new TestMessageSetContainer(); public static TestMessageSetContainer DefaultInstance { get { return defaultInstance; } @@ -350,7 +344,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestMessageSetContainer ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestMessageSetContainer parseFrom(byte[] data, + public static self::TestMessageSetContainer ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -507,9 +501,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestMessageSetExtension1 : pb::GeneratedMessage { - // Use TestMessageSetExtension1.CreateBuilder() to construct. - private TestMessageSetExtension1() {} - private static readonly TestMessageSetExtension1 defaultInstance = new TestMessageSetExtension1(); public static TestMessageSetExtension1 DefaultInstance { get { return defaultInstance; } @@ -584,7 +575,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestMessageSetExtension1 ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestMessageSetExtension1 parseFrom(byte[] data, + public static self::TestMessageSetExtension1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -720,9 +711,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestMessageSetExtension2 : pb::GeneratedMessage { - // Use TestMessageSetExtension2.CreateBuilder() to construct. - private TestMessageSetExtension2() {} - private static readonly TestMessageSetExtension2 defaultInstance = new TestMessageSetExtension2(); public static TestMessageSetExtension2 DefaultInstance { get { return defaultInstance; } @@ -797,7 +785,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestMessageSetExtension2 ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestMessageSetExtension2 parseFrom(byte[] data, + public static self::TestMessageSetExtension2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -933,9 +921,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class RawMessageSet : pb::GeneratedMessage { - // Use RawMessageSet.CreateBuilder() to construct. - private RawMessageSet() {} - private static readonly RawMessageSet defaultInstance = new RawMessageSet(); public static RawMessageSet DefaultInstance { get { return defaultInstance; } @@ -956,9 +941,6 @@ namespace Google.ProtocolBuffers.TestProtos { #region Nested types public static class Types { public sealed partial class Item : pb::GeneratedMessage { - // Use Item.CreateBuilder() to construct. - private Item() {} - private static readonly Item defaultInstance = new Item(); public static Item DefaultInstance { get { return defaultInstance; } @@ -1044,7 +1026,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::RawMessageSet.Types.Item ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::RawMessageSet.Types.Item parseFrom(byte[] data, + public static self::RawMessageSet.Types.Item ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -1263,7 +1245,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::RawMessageSet ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::RawMessageSet parseFrom(byte[] data, + public static self::RawMessageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); diff --git a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs index f950d8f6..fd647c1a 100644 --- a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs +++ b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs @@ -58,9 +58,6 @@ namespace Google.ProtocolBuffers.TestProtos { #region Messages public sealed partial class TestOptimizedForSize : pb::ExtendableMessage { - // Use TestOptimizedForSize.CreateBuilder() to construct. - private TestOptimizedForSize() {} - private static readonly TestOptimizedForSize defaultInstance = new TestOptimizedForSize(); public static TestOptimizedForSize DefaultInstance { get { return defaultInstance; } @@ -116,7 +113,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestOptimizedForSize ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestOptimizedForSize parseFrom(byte[] data, + public static self::TestOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); diff --git a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs index 29b6a6b4..bf6a3543 100644 --- a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs +++ b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs @@ -1033,9 +1033,6 @@ namespace Google.ProtocolBuffers.TestProtos { #region Messages public sealed partial class TestAllTypes : pb::GeneratedMessage { - // Use TestAllTypes.CreateBuilder() to construct. - private TestAllTypes() {} - private static readonly TestAllTypes defaultInstance = new TestAllTypes(); public static TestAllTypes DefaultInstance { get { return defaultInstance; } @@ -1062,9 +1059,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class NestedMessage : pb::GeneratedMessage { - // Use NestedMessage.CreateBuilder() to construct. - private NestedMessage() {} - private static readonly NestedMessage defaultInstance = new NestedMessage(); public static NestedMessage DefaultInstance { get { return defaultInstance; } @@ -1132,7 +1126,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestAllTypes.Types.NestedMessage ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestAllTypes.Types.NestedMessage parseFrom(byte[] data, + public static self::TestAllTypes.Types.NestedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -1268,9 +1262,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class OptionalGroup : pb::GeneratedMessage { - // Use OptionalGroup.CreateBuilder() to construct. - private OptionalGroup() {} - private static readonly OptionalGroup defaultInstance = new OptionalGroup(); public static OptionalGroup DefaultInstance { get { return defaultInstance; } @@ -1338,7 +1329,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestAllTypes.Types.OptionalGroup ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestAllTypes.Types.OptionalGroup parseFrom(byte[] data, + public static self::TestAllTypes.Types.OptionalGroup ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -1474,9 +1465,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class RepeatedGroup : pb::GeneratedMessage { - // Use RepeatedGroup.CreateBuilder() to construct. - private RepeatedGroup() {} - private static readonly RepeatedGroup defaultInstance = new RepeatedGroup(); public static RepeatedGroup DefaultInstance { get { return defaultInstance; } @@ -1544,7 +1532,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestAllTypes.Types.RepeatedGroup ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestAllTypes.Types.RepeatedGroup parseFrom(byte[] data, + public static self::TestAllTypes.Types.RepeatedGroup ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -2866,7 +2854,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestAllTypes ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestAllTypes parseFrom(byte[] data, + public static self::TestAllTypes ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -5368,9 +5356,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class ForeignMessage : pb::GeneratedMessage { - // Use ForeignMessage.CreateBuilder() to construct. - private ForeignMessage() {} - private static readonly ForeignMessage defaultInstance = new ForeignMessage(); public static ForeignMessage DefaultInstance { get { return defaultInstance; } @@ -5438,7 +5423,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::ForeignMessage ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::ForeignMessage parseFrom(byte[] data, + public static self::ForeignMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -5574,9 +5559,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestAllExtensions : pb::ExtendableMessage { - // Use TestAllExtensions.CreateBuilder() to construct. - private TestAllExtensions() {} - private static readonly TestAllExtensions defaultInstance = new TestAllExtensions(); public static TestAllExtensions DefaultInstance { get { return defaultInstance; } @@ -5632,7 +5614,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestAllExtensions ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestAllExtensions parseFrom(byte[] data, + public static self::TestAllExtensions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -5742,9 +5724,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class OptionalGroup_extension : pb::GeneratedMessage { - // Use OptionalGroup_extension.CreateBuilder() to construct. - private OptionalGroup_extension() {} - private static readonly OptionalGroup_extension defaultInstance = new OptionalGroup_extension(); public static OptionalGroup_extension DefaultInstance { get { return defaultInstance; } @@ -5812,7 +5791,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::OptionalGroup_extension ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::OptionalGroup_extension parseFrom(byte[] data, + public static self::OptionalGroup_extension ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -5948,9 +5927,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class RepeatedGroup_extension : pb::GeneratedMessage { - // Use RepeatedGroup_extension.CreateBuilder() to construct. - private RepeatedGroup_extension() {} - private static readonly RepeatedGroup_extension defaultInstance = new RepeatedGroup_extension(); public static RepeatedGroup_extension DefaultInstance { get { return defaultInstance; } @@ -6018,7 +5994,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::RepeatedGroup_extension ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::RepeatedGroup_extension parseFrom(byte[] data, + public static self::RepeatedGroup_extension ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -6154,9 +6130,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestRequired : pb::GeneratedMessage { - // Use TestRequired.CreateBuilder() to construct. - private TestRequired() {} - private static readonly TestRequired defaultInstance = new TestRequired(); public static TestRequired DefaultInstance { get { return defaultInstance; } @@ -6749,7 +6722,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestRequired ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestRequired parseFrom(byte[] data, + public static self::TestRequired ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -7717,9 +7690,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestRequiredForeign : pb::GeneratedMessage { - // Use TestRequiredForeign.CreateBuilder() to construct. - private TestRequiredForeign() {} - private static readonly TestRequiredForeign defaultInstance = new TestRequiredForeign(); public static TestRequiredForeign DefaultInstance { get { return defaultInstance; } @@ -7827,7 +7797,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestRequiredForeign ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestRequiredForeign parseFrom(byte[] data, + public static self::TestRequiredForeign ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -8069,9 +8039,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestForeignNested : pb::GeneratedMessage { - // Use TestForeignNested.CreateBuilder() to construct. - private TestForeignNested() {} - private static readonly TestForeignNested defaultInstance = new TestForeignNested(); public static TestForeignNested DefaultInstance { get { return defaultInstance; } @@ -8139,7 +8106,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestForeignNested ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestForeignNested parseFrom(byte[] data, + public static self::TestForeignNested ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -8296,9 +8263,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestEmptyMessage : pb::GeneratedMessage { - // Use TestEmptyMessage.CreateBuilder() to construct. - private TestEmptyMessage() {} - private static readonly TestEmptyMessage defaultInstance = new TestEmptyMessage(); public static TestEmptyMessage DefaultInstance { get { return defaultInstance; } @@ -8350,7 +8314,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestEmptyMessage ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestEmptyMessage parseFrom(byte[] data, + public static self::TestEmptyMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -8460,9 +8424,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestEmptyMessageWithExtensions : pb::ExtendableMessage { - // Use TestEmptyMessageWithExtensions.CreateBuilder() to construct. - private TestEmptyMessageWithExtensions() {} - private static readonly TestEmptyMessageWithExtensions defaultInstance = new TestEmptyMessageWithExtensions(); public static TestEmptyMessageWithExtensions DefaultInstance { get { return defaultInstance; } @@ -8518,7 +8479,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestEmptyMessageWithExtensions ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestEmptyMessageWithExtensions parseFrom(byte[] data, + public static self::TestEmptyMessageWithExtensions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -8628,9 +8589,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestReallyLargeTagNumber : pb::GeneratedMessage { - // Use TestReallyLargeTagNumber.CreateBuilder() to construct. - private TestReallyLargeTagNumber() {} - private static readonly TestReallyLargeTagNumber defaultInstance = new TestReallyLargeTagNumber(); public static TestReallyLargeTagNumber DefaultInstance { get { return defaultInstance; } @@ -8714,7 +8672,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestReallyLargeTagNumber ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestReallyLargeTagNumber parseFrom(byte[] data, + public static self::TestReallyLargeTagNumber ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -8876,9 +8834,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestRecursiveMessage : pb::GeneratedMessage { - // Use TestRecursiveMessage.CreateBuilder() to construct. - private TestRecursiveMessage() {} - private static readonly TestRecursiveMessage defaultInstance = new TestRecursiveMessage(); public static TestRecursiveMessage DefaultInstance { get { return defaultInstance; } @@ -8962,7 +8917,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestRecursiveMessage ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestRecursiveMessage parseFrom(byte[] data, + public static self::TestRecursiveMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -9145,9 +9100,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestMutualRecursionA : pb::GeneratedMessage { - // Use TestMutualRecursionA.CreateBuilder() to construct. - private TestMutualRecursionA() {} - private static readonly TestMutualRecursionA defaultInstance = new TestMutualRecursionA(); public static TestMutualRecursionA DefaultInstance { get { return defaultInstance; } @@ -9215,7 +9167,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestMutualRecursionA ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestMutualRecursionA parseFrom(byte[] data, + public static self::TestMutualRecursionA ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -9372,9 +9324,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestMutualRecursionB : pb::GeneratedMessage { - // Use TestMutualRecursionB.CreateBuilder() to construct. - private TestMutualRecursionB() {} - private static readonly TestMutualRecursionB defaultInstance = new TestMutualRecursionB(); public static TestMutualRecursionB DefaultInstance { get { return defaultInstance; } @@ -9458,7 +9407,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestMutualRecursionB ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestMutualRecursionB parseFrom(byte[] data, + public static self::TestMutualRecursionB ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -9641,9 +9590,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestDupFieldNumber : pb::GeneratedMessage { - // Use TestDupFieldNumber.CreateBuilder() to construct. - private TestDupFieldNumber() {} - private static readonly TestDupFieldNumber defaultInstance = new TestDupFieldNumber(); public static TestDupFieldNumber DefaultInstance { get { return defaultInstance; } @@ -9664,9 +9610,6 @@ namespace Google.ProtocolBuffers.TestProtos { #region Nested types public static class Types { public sealed partial class Foo : pb::GeneratedMessage { - // Use Foo.CreateBuilder() to construct. - private Foo() {} - private static readonly Foo defaultInstance = new Foo(); public static Foo DefaultInstance { get { return defaultInstance; } @@ -9734,7 +9677,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestDupFieldNumber.Types.Foo ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestDupFieldNumber.Types.Foo parseFrom(byte[] data, + public static self::TestDupFieldNumber.Types.Foo ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -9870,9 +9813,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class Bar : pb::GeneratedMessage { - // Use Bar.CreateBuilder() to construct. - private Bar() {} - private static readonly Bar defaultInstance = new Bar(); public static Bar DefaultInstance { get { return defaultInstance; } @@ -9940,7 +9880,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestDupFieldNumber.Types.Bar ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestDupFieldNumber.Types.Bar parseFrom(byte[] data, + public static self::TestDupFieldNumber.Types.Bar ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -10160,7 +10100,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestDupFieldNumber ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestDupFieldNumber parseFrom(byte[] data, + public static self::TestDupFieldNumber ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -10390,9 +10330,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestNestedMessageHasBits : pb::GeneratedMessage { - // Use TestNestedMessageHasBits.CreateBuilder() to construct. - private TestNestedMessageHasBits() {} - private static readonly TestNestedMessageHasBits defaultInstance = new TestNestedMessageHasBits(); public static TestNestedMessageHasBits DefaultInstance { get { return defaultInstance; } @@ -10413,9 +10350,6 @@ namespace Google.ProtocolBuffers.TestProtos { #region Nested types public static class Types { public sealed partial class NestedMessage : pb::GeneratedMessage { - // Use NestedMessage.CreateBuilder() to construct. - private NestedMessage() {} - private static readonly NestedMessage defaultInstance = new NestedMessage(); public static NestedMessage DefaultInstance { get { return defaultInstance; } @@ -10504,7 +10438,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestNestedMessageHasBits.Types.NestedMessage ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestNestedMessageHasBits.Types.NestedMessage parseFrom(byte[] data, + public static self::TestNestedMessageHasBits.Types.NestedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -10769,7 +10703,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestNestedMessageHasBits ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestNestedMessageHasBits parseFrom(byte[] data, + public static self::TestNestedMessageHasBits ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -10926,9 +10860,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestCamelCaseFieldNames : pb::GeneratedMessage { - // Use TestCamelCaseFieldNames.CreateBuilder() to construct. - private TestCamelCaseFieldNames() {} - private static readonly TestCamelCaseFieldNames defaultInstance = new TestCamelCaseFieldNames(); public static TestCamelCaseFieldNames DefaultInstance { get { return defaultInstance; } @@ -11188,7 +11119,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestCamelCaseFieldNames ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestCamelCaseFieldNames parseFrom(byte[] data, + public static self::TestCamelCaseFieldNames ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -11765,9 +11696,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestFieldOrderings : pb::ExtendableMessage { - // Use TestFieldOrderings.CreateBuilder() to construct. - private TestFieldOrderings() {} - private static readonly TestFieldOrderings defaultInstance = new TestFieldOrderings(); public static TestFieldOrderings DefaultInstance { get { return defaultInstance; } @@ -11872,7 +11800,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestFieldOrderings ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestFieldOrderings parseFrom(byte[] data, + public static self::TestFieldOrderings ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -12060,9 +11988,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class TestExtremeDefaultValues : pb::GeneratedMessage { - // Use TestExtremeDefaultValues.CreateBuilder() to construct. - private TestExtremeDefaultValues() {} - private static readonly TestExtremeDefaultValues defaultInstance = new TestExtremeDefaultValues(); public static TestExtremeDefaultValues DefaultInstance { get { return defaultInstance; } @@ -12210,7 +12135,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::TestExtremeDefaultValues ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::TestExtremeDefaultValues parseFrom(byte[] data, + public static self::TestExtremeDefaultValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -12476,9 +12401,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class FooRequest : pb::GeneratedMessage { - // Use FooRequest.CreateBuilder() to construct. - private FooRequest() {} - private static readonly FooRequest defaultInstance = new FooRequest(); public static FooRequest DefaultInstance { get { return defaultInstance; } @@ -12530,7 +12452,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::FooRequest ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::FooRequest parseFrom(byte[] data, + public static self::FooRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -12640,9 +12562,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class FooResponse : pb::GeneratedMessage { - // Use FooResponse.CreateBuilder() to construct. - private FooResponse() {} - private static readonly FooResponse defaultInstance = new FooResponse(); public static FooResponse DefaultInstance { get { return defaultInstance; } @@ -12694,7 +12613,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::FooResponse ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::FooResponse parseFrom(byte[] data, + public static self::FooResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -12804,9 +12723,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class BarRequest : pb::GeneratedMessage { - // Use BarRequest.CreateBuilder() to construct. - private BarRequest() {} - private static readonly BarRequest defaultInstance = new BarRequest(); public static BarRequest DefaultInstance { get { return defaultInstance; } @@ -12858,7 +12774,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::BarRequest ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::BarRequest parseFrom(byte[] data, + public static self::BarRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); @@ -12968,9 +12884,6 @@ namespace Google.ProtocolBuffers.TestProtos { } public sealed partial class BarResponse : pb::GeneratedMessage { - // Use BarResponse.CreateBuilder() to construct. - private BarResponse() {} - private static readonly BarResponse defaultInstance = new BarResponse(); public static BarResponse DefaultInstance { get { return defaultInstance; } @@ -13022,7 +12935,7 @@ namespace Google.ProtocolBuffers.TestProtos { public static self::BarResponse ParseFrom(byte[] data) { return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); } - public static self::BarResponse parseFrom(byte[] data, + public static self::BarResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)) .BuildParsed(); -- cgit v1.2.3