From 6803686bc06c4d96afd9bd2637f7b37a58596699 Mon Sep 17 00:00:00 2001 From: Jon Skeet Date: Wed, 22 Oct 2008 13:30:34 +0100 Subject: First cut at new layout --- src/ProtocolBuffers.Test/AbstractMessageTest.cs | 364 + src/ProtocolBuffers.Test/ByteStringTest.cs | 98 + src/ProtocolBuffers.Test/CodedInputStreamTest.cs | 376 + src/ProtocolBuffers.Test/CodedOutputStreamTest.cs | 239 + .../Collections/PopsicleListTest.cs | 64 + src/ProtocolBuffers.Test/DescriptorsTest.cs | 274 + src/ProtocolBuffers.Test/DynamicMessageTest.cs | 114 + src/ProtocolBuffers.Test/GeneratedMessageTest.cs | 291 + .../MessageStreamIteratorTest.cs | 23 + .../MessageStreamWriterTest.cs | 36 + src/ProtocolBuffers.Test/MessageTest.cs | 299 + .../Properties/AssemblyInfo.cs | 36 + .../Properties/Google.ProtocolBuffers.Test.snk | Bin 0 -> 596 bytes .../ProtocolBuffers.Test.csproj | 88 + src/ProtocolBuffers.Test/ReflectionTester.cs | 798 ++ src/ProtocolBuffers.Test/ServiceTest.cs | 178 + .../TestProtos/UnitTestCustomOptionsProtoFile.cs | 2251 ++++ .../UnitTestEmbedOptimizeForProtoFile.cs | 324 + .../TestProtos/UnitTestImportProtoFile.cs | 243 + .../TestProtos/UnitTestMessageSetProtoFile.cs | 1284 ++ .../TestProtos/UnitTestOptimizeForProtoFile.cs | 467 + .../TestProtos/UnitTestProtoFile.cs | 11835 +++++++++++++++++++ src/ProtocolBuffers.Test/TestUtil.cs | 1370 +++ src/ProtocolBuffers.Test/TextFormatTest.cs | 487 + src/ProtocolBuffers.Test/UnknownFieldSetTest.cs | 314 + src/ProtocolBuffers.Test/WireFormatTest.cs | 228 + 26 files changed, 22081 insertions(+) create mode 100644 src/ProtocolBuffers.Test/AbstractMessageTest.cs create mode 100644 src/ProtocolBuffers.Test/ByteStringTest.cs create mode 100644 src/ProtocolBuffers.Test/CodedInputStreamTest.cs create mode 100644 src/ProtocolBuffers.Test/CodedOutputStreamTest.cs create mode 100644 src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs create mode 100644 src/ProtocolBuffers.Test/DescriptorsTest.cs create mode 100644 src/ProtocolBuffers.Test/DynamicMessageTest.cs create mode 100644 src/ProtocolBuffers.Test/GeneratedMessageTest.cs create mode 100644 src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs create mode 100644 src/ProtocolBuffers.Test/MessageStreamWriterTest.cs create mode 100644 src/ProtocolBuffers.Test/MessageTest.cs create mode 100644 src/ProtocolBuffers.Test/Properties/AssemblyInfo.cs create mode 100644 src/ProtocolBuffers.Test/Properties/Google.ProtocolBuffers.Test.snk create mode 100644 src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj create mode 100644 src/ProtocolBuffers.Test/ReflectionTester.cs create mode 100644 src/ProtocolBuffers.Test/ServiceTest.cs create mode 100644 src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs create mode 100644 src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs create mode 100644 src/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs create mode 100644 src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs create mode 100644 src/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs create mode 100644 src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs create mode 100644 src/ProtocolBuffers.Test/TestUtil.cs create mode 100644 src/ProtocolBuffers.Test/TextFormatTest.cs create mode 100644 src/ProtocolBuffers.Test/UnknownFieldSetTest.cs create mode 100644 src/ProtocolBuffers.Test/WireFormatTest.cs (limited to 'src/ProtocolBuffers.Test') diff --git a/src/ProtocolBuffers.Test/AbstractMessageTest.cs b/src/ProtocolBuffers.Test/AbstractMessageTest.cs new file mode 100644 index 00000000..38cc8636 --- /dev/null +++ b/src/ProtocolBuffers.Test/AbstractMessageTest.cs @@ -0,0 +1,364 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using NUnit.Framework; +using Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class AbstractMessageTest { + + [Test] + public void Clear() { + AbstractMessageWrapper message = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder(TestUtil.GetAllSet())).Clear().Build(); + TestUtil.AssertClear((TestAllTypes) message.WrappedMessage); + } + + [Test] + public void Copy() { + AbstractMessageWrapper message = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder()).MergeFrom(TestUtil.GetAllSet()).Build(); + TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage); + } + + [Test] + public void SerializedSize() { + TestAllTypes message = TestUtil.GetAllSet(); + IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet()); + + Assert.AreEqual(message.SerializedSize, abstractMessage.SerializedSize); + } + + [Test] + public void Serialization() { + IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet()); + TestUtil.AssertAllFieldsSet(TestAllTypes.ParseFrom(abstractMessage.ToByteString())); + Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), abstractMessage.ToByteString()); + } + + [Test] + public void Parsing() { + IBuilder builder = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder()); + AbstractMessageWrapper message = (AbstractMessageWrapper) builder.WeakMergeFrom(TestUtil.GetAllSet().ToByteString()).WeakBuild(); + TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage); + } + + [Test] + public void OptimizedForSize() { + // We're mostly only Checking that this class was compiled successfully. + TestOptimizedForSize message = TestOptimizedForSize.CreateBuilder().SetI(1).Build(); + message = TestOptimizedForSize.ParseFrom(message.ToByteString()); + Assert.AreEqual(2, message.SerializedSize); + } + + // ----------------------------------------------------------------- + // Tests for isInitialized(). + + private static readonly TestRequired TestRequiredUninitialized = TestRequired.DefaultInstance; + private static readonly TestRequired TestRequiredInitialized = TestRequired.CreateBuilder().SetA(1).SetB(2).SetC(3).Build(); + + [Test] + public void IsInitialized() { + TestRequired.Builder builder = TestRequired.CreateBuilder(); + AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder); + + Assert.IsFalse(abstractBuilder.IsInitialized); + builder.A = 1; + Assert.IsFalse(abstractBuilder.IsInitialized); + builder.B = 1; + Assert.IsFalse(abstractBuilder.IsInitialized); + builder.C = 1; + Assert.IsTrue(abstractBuilder.IsInitialized); + } + + [Test] + public void ForeignIsInitialized() { + TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder(); + AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder); + + Assert.IsTrue(abstractBuilder.IsInitialized); + + builder.SetOptionalMessage(TestRequiredUninitialized); + Assert.IsFalse(abstractBuilder.IsInitialized); + + builder.SetOptionalMessage(TestRequiredInitialized); + Assert.IsTrue(abstractBuilder.IsInitialized); + + builder.AddRepeatedMessage(TestRequiredUninitialized); + Assert.IsFalse(abstractBuilder.IsInitialized); + + builder.SetRepeatedMessage(0, TestRequiredInitialized); + Assert.IsTrue(abstractBuilder.IsInitialized); + } + + // ----------------------------------------------------------------- + // Tests for mergeFrom + + static readonly TestAllTypes MergeSource = TestAllTypes.CreateBuilder() + .SetOptionalInt32(1) + .SetOptionalString("foo") + .SetOptionalForeignMessage(ForeignMessage.DefaultInstance) + .AddRepeatedString("bar") + .Build(); + + static readonly TestAllTypes MergeDest = TestAllTypes.CreateBuilder() + .SetOptionalInt64(2) + .SetOptionalString("baz") + .SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(3).Build()) + .AddRepeatedString("qux") + .Build(); + + 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() { + AbstractMessageWrapper result = (AbstractMessageWrapper) + new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder(MergeDest)) + .MergeFrom(MergeSource) + .Build(); + + Assert.AreEqual(MergeResultText, result.ToString()); + } + + // ----------------------------------------------------------------- + // Tests for equals and hashCode + + [Test] + public void EqualsAndHashCode() { + TestAllTypes a = TestUtil.GetAllSet(); + TestAllTypes b = TestAllTypes.CreateBuilder().Build(); + TestAllTypes c = TestAllTypes.CreateBuilder(b).AddRepeatedString("x").Build(); + TestAllTypes d = TestAllTypes.CreateBuilder(c).AddRepeatedString("y").Build(); + TestAllExtensions e = TestUtil.GetAllExtensionsSet(); + TestAllExtensions f = TestAllExtensions.CreateBuilder(e) + .AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 999).Build(); + + CheckEqualsIsConsistent(a); + CheckEqualsIsConsistent(b); + CheckEqualsIsConsistent(c); + CheckEqualsIsConsistent(d); + CheckEqualsIsConsistent(e); + CheckEqualsIsConsistent(f); + + CheckNotEqual(a, b); + CheckNotEqual(a, c); + CheckNotEqual(a, d); + CheckNotEqual(a, e); + CheckNotEqual(a, f); + + CheckNotEqual(b, c); + CheckNotEqual(b, d); + CheckNotEqual(b, e); + CheckNotEqual(b, f); + + CheckNotEqual(c, d); + CheckNotEqual(c, e); + CheckNotEqual(c, f); + + CheckNotEqual(d, e); + CheckNotEqual(d, f); + + CheckNotEqual(e, f); + } + + /// + /// Asserts that the given protos are equal and have the same hash code. + /// + private static void CheckEqualsIsConsistent(IMessage message) { + // Object should be equal to itself. + Assert.AreEqual(message, message); + + // Object should be equal to a dynamic copy of itself. + DynamicMessage dynamic = DynamicMessage.CreateBuilder(message).Build(); + Assert.AreEqual(message, dynamic); + Assert.AreEqual(dynamic, message); + Assert.AreEqual(dynamic.GetHashCode(), message.GetHashCode()); + } + + /// + /// Asserts that the given protos are not equal and have different hash codes. + /// + /// + /// It's valid for non-equal objects to have the same hash code, so + /// this test is stricter than it needs to be. However, this should happen + /// relatively rarely. (If this test fails, it's probably still due to a bug.) + /// + private static void CheckNotEqual(IMessage m1, IMessage m2) { + String equalsError = string.Format("{0} should not be equal to {1}", m1, m2); + Assert.IsFalse(m1.Equals(m2), equalsError); + Assert.IsFalse(m2.Equals(m1), equalsError); + + Assert.IsFalse(m1.GetHashCode() == m2.GetHashCode(), + string.Format("{0} should have a different hash code from {1}", m1, m2)); + } + + /// + /// Extends AbstractMessage and wraps some other message object. The methods + /// of the Message interface which aren't explicitly implemented by + /// AbstractMessage are forwarded to the wrapped object. This allows us to + /// test that AbstractMessage's implementations work even if the wrapped + /// object does not use them. + /// + private class AbstractMessageWrapper : AbstractMessage { + private readonly IMessage wrappedMessage; + + public IMessage WrappedMessage { + get { return wrappedMessage; } + } + + public AbstractMessageWrapper(IMessage wrappedMessage) { + this.wrappedMessage = wrappedMessage; + } + + public override MessageDescriptor DescriptorForType { + get { return wrappedMessage.DescriptorForType; } + } + + public override AbstractMessageWrapper DefaultInstanceForType { + get { return new AbstractMessageWrapper(wrappedMessage.WeakDefaultInstanceForType); } + } + + public override IDictionary AllFields { + get { return wrappedMessage.AllFields; } + } + + public override bool HasField(FieldDescriptor field) { + return wrappedMessage.HasField(field); + } + + public override object this[FieldDescriptor field] { + get { return wrappedMessage[field]; } + } + + public override object this[FieldDescriptor field, int index] { + get { return wrappedMessage[field, index]; } + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + return wrappedMessage.GetRepeatedFieldCount(field); + } + + public override UnknownFieldSet UnknownFields { + get { return wrappedMessage.UnknownFields; } + } + + public override Builder CreateBuilderForType() { + return new Builder(wrappedMessage.WeakCreateBuilderForType()); + } + + internal class Builder : AbstractBuilder { + private readonly IBuilder wrappedBuilder; + + protected override Builder ThisBuilder { + get { return this; } + } + + internal Builder(IBuilder wrappedBuilder) { + this.wrappedBuilder = wrappedBuilder; + } + + public override Builder MergeFrom(AbstractMessageWrapper other) { + wrappedBuilder.WeakMergeFrom(other.wrappedMessage); + return this; + } + + public override bool IsInitialized { + get { return wrappedBuilder.IsInitialized; } + } + + public override IDictionary AllFields { + get { return wrappedBuilder.AllFields; } + } + + public override object this[FieldDescriptor field] { + get { return wrappedBuilder[field]; } + set { wrappedBuilder[field] = value; } + } + + public override MessageDescriptor DescriptorForType { + get { return wrappedBuilder.DescriptorForType; } + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + return wrappedBuilder.GetRepeatedFieldCount(field); + } + + public override object this[FieldDescriptor field, int index] { + get { return wrappedBuilder[field, index]; } + set { wrappedBuilder[field, index] = value; } + } + + public override bool HasField(FieldDescriptor field) { + return wrappedBuilder.HasField(field); + } + + public override UnknownFieldSet UnknownFields { + get { return wrappedBuilder.UnknownFields; } + set { wrappedBuilder.UnknownFields = value; } + } + + public override AbstractMessageWrapper Build() { + return new AbstractMessageWrapper(wrappedBuilder.WeakBuild()); + } + + public override AbstractMessageWrapper BuildPartial() { + return new AbstractMessageWrapper(wrappedBuilder.WeakBuildPartial()); + } + + public override Builder Clone() { + return new Builder(wrappedBuilder.WeakClone()); + } + + public override AbstractMessageWrapper DefaultInstanceForType { + get { return new AbstractMessageWrapper(wrappedBuilder.WeakDefaultInstanceForType); } + } + + public override Builder ClearField(FieldDescriptor field) { + wrappedBuilder.WeakClearField(field); + return this; + } + + public override Builder AddRepeatedField(FieldDescriptor field, object value) { + wrappedBuilder.WeakAddRepeatedField(field, value); + return this; + } + + public override IBuilder CreateBuilderForField(FieldDescriptor field) { + wrappedBuilder.CreateBuilderForField(field); + return this; + } + + public override Builder MergeFrom(IMessage other) { + wrappedBuilder.WeakMergeFrom(other); + return this; + } + + public override Builder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) { + wrappedBuilder.WeakMergeFrom(input, extensionRegistry); + return this; + } + } + } + } +} diff --git a/src/ProtocolBuffers.Test/ByteStringTest.cs b/src/ProtocolBuffers.Test/ByteStringTest.cs new file mode 100644 index 00000000..768d74fe --- /dev/null +++ b/src/ProtocolBuffers.Test/ByteStringTest.cs @@ -0,0 +1,98 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Text; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class ByteStringTest { + [Test] + public void EmptyByteStringHasZeroSize() { + Assert.AreEqual(0, ByteString.Empty.Length); + } + + [Test] + public void CopyFromStringWithExplicitEncoding() { + ByteString bs = ByteString.CopyFrom("AB", Encoding.Unicode); + Assert.AreEqual(4, bs.Length); + Assert.AreEqual(65, bs[0]); + Assert.AreEqual(0, bs[1]); + Assert.AreEqual(66, bs[2]); + Assert.AreEqual(0, bs[3]); + } + + [Test] + public void IsEmptyWhenEmpty() { + Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty); + } + + [Test] + public void IsEmptyWhenNotEmpty() { + Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty); + } + + [Test] + public void CopyFromByteArrayCopiesContents() { + byte[] data = new byte[1]; + data[0] = 10; + ByteString bs = ByteString.CopyFrom(data); + Assert.AreEqual(10, bs[0]); + data[0] = 5; + Assert.AreEqual(10, bs[0]); + } + + [Test] + public void ToByteArrayCopiesContents() { + ByteString bs = ByteString.CopyFromUtf8("Hello"); + byte[] data = bs.ToByteArray(); + Assert.AreEqual('H', data[0]); + Assert.AreEqual('H', bs[0]); + data[0] = 0; + Assert.AreEqual(0, data[0]); + Assert.AreEqual('H', bs[0]); + } + + [Test] + public void CopyFromUtf8UsesUtf8() { + ByteString bs = ByteString.CopyFromUtf8("\u20ac"); + Assert.AreEqual(3, bs.Length); + Assert.AreEqual(0xe2, bs[0]); + Assert.AreEqual(0x82, bs[1]); + Assert.AreEqual(0xac, bs[2]); + } + + [Test] + public void CopyFromPortion() { + byte[] data = new byte[]{0, 1, 2, 3, 4, 5, 6}; + ByteString bs = ByteString.CopyFrom(data, 2, 3); + Assert.AreEqual(3, bs.Length); + Assert.AreEqual(2, bs[0]); + Assert.AreEqual(3, bs[1]); + } + + [Test] + public void ToStringUtf8() { + ByteString bs = ByteString.CopyFromUtf8("\u20ac"); + Assert.AreEqual("\u20ac", bs.ToStringUtf8()); + } + + [Test] + public void ToStringWithExplicitEncoding() { + ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode); + Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode)); + } + } +} diff --git a/src/ProtocolBuffers.Test/CodedInputStreamTest.cs b/src/ProtocolBuffers.Test/CodedInputStreamTest.cs new file mode 100644 index 00000000..24b3a732 --- /dev/null +++ b/src/ProtocolBuffers.Test/CodedInputStreamTest.cs @@ -0,0 +1,376 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.IO; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; +using System.Diagnostics; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class CodedInputStreamTest { + + /// + /// Helper to construct a byte array from a bunch of bytes. The inputs are + /// actually ints so that I can use hex notation and not get stupid errors + /// about precision. + /// + private static byte[] Bytes(params int[] bytesAsInts) { + byte[] bytes = new byte[bytesAsInts.Length]; + for (int i = 0; i < bytesAsInts.Length; i++) { + bytes[i] = (byte)bytesAsInts[i]; + } + return bytes; + } + + /// + /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and + /// + private static void AssertReadVarint(byte[] data, ulong value) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + Assert.AreEqual((uint)value, input.ReadRawVarint32()); + + input = CodedInputStream.CreateInstance(data); + Assert.AreEqual(value, input.ReadRawVarint64()); + + // Try different block sizes. + for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { + input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize)); + Assert.AreEqual((uint)value, input.ReadRawVarint32()); + + input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize)); + Assert.AreEqual(value, input.ReadRawVarint64()); + } + } + + /// + /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and + /// expects them to fail with an InvalidProtocolBufferException whose + /// description matches the given one. + /// + private void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + try { + input.ReadRawVarint32(); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual(expected.Message, e.Message); + } + + input = CodedInputStream.CreateInstance(data); + try { + input.ReadRawVarint64(); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual(expected.Message, e.Message); + } + } + + [Test] + public void ReadVarint() { + AssertReadVarint(Bytes(0x00), 0); + AssertReadVarint(Bytes(0x01), 1); + AssertReadVarint(Bytes(0x7f), 127); + // 14882 + AssertReadVarint(Bytes(0xa2, 0x74), (0x22 << 0) | (0x74 << 7)); + // 2961488830 + AssertReadVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b), + (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | + (0x0bL << 28)); + + // 64-bit + // 7256456126 + AssertReadVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b), + (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | + (0x1bL << 28)); + // 41256202580718336 + AssertReadVarint(Bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49), + (0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) | + (0x43L << 28) | (0x49L << 35) | (0x24L << 42) | (0x49L << 49)); + // 11964378330978735131 + AssertReadVarint(Bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01), + (0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) | + (0x3bUL << 28) | (0x56UL << 35) | (0x00UL << 42) | + (0x05UL << 49) | (0x26UL << 56) | (0x01UL << 63)); + + // Failures + AssertReadVarintFailure( + InvalidProtocolBufferException.MalformedVarint(), + Bytes(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x00)); + AssertReadVarintFailure( + InvalidProtocolBufferException.TruncatedMessage(), + Bytes(0x80)); + } + + /// + /// Parses the given bytes using ReadRawLittleEndian32() and checks + /// that the result matches the given value. + /// + private static void AssertReadLittleEndian32(byte[] data, uint value) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + Assert.AreEqual(value, input.ReadRawLittleEndian32()); + + // Try different block sizes. + for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { + input = CodedInputStream.CreateInstance( + new SmallBlockInputStream(data, blockSize)); + Assert.AreEqual(value, input.ReadRawLittleEndian32()); + } + } + + /// + /// Parses the given bytes using ReadRawLittleEndian64() and checks + /// that the result matches the given value. + /// + private static void AssertReadLittleEndian64(byte[] data, ulong value) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + Assert.AreEqual(value, input.ReadRawLittleEndian64()); + + // Try different block sizes. + for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { + input = CodedInputStream.CreateInstance( + new SmallBlockInputStream(data, blockSize)); + Assert.AreEqual(value, input.ReadRawLittleEndian64()); + } + } + + [Test] + public void ReadLittleEndian() { + AssertReadLittleEndian32(Bytes(0x78, 0x56, 0x34, 0x12), 0x12345678); + AssertReadLittleEndian32(Bytes(0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef0); + + AssertReadLittleEndian64(Bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12), + 0x123456789abcdef0L); + AssertReadLittleEndian64( + Bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef012345678UL); + } + + [Test] + public void DecodeZigZag32() { + Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(0)); + Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(1)); + Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(2)); + Assert.AreEqual(-2, CodedInputStream.DecodeZigZag32(3)); + Assert.AreEqual(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE)); + Assert.AreEqual(unchecked((int)0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF)); + Assert.AreEqual(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE)); + Assert.AreEqual(unchecked((int)0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF)); + } + + [Test] + public void DecodeZigZag64() { + Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(0)); + Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(1)); + Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(2)); + Assert.AreEqual(-2, CodedInputStream.DecodeZigZag64(3)); + Assert.AreEqual(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL)); + Assert.AreEqual(unchecked((long)0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL)); + Assert.AreEqual(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL)); + Assert.AreEqual(unchecked((long)0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL)); + Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL)); + Assert.AreEqual(unchecked((long)0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL)); + } + + [Test] + public void ReadWholeMessage() { + TestAllTypes message = TestUtil.GetAllSet(); + + byte[] rawBytes = message.ToByteArray(); + Assert.AreEqual(rawBytes.Length, message.SerializedSize); + TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); + TestUtil.AssertAllFieldsSet(message2); + + // Try different block sizes. + for (int blockSize = 1; blockSize < 256; blockSize *= 2) { + message2 = TestAllTypes.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize)); + TestUtil.AssertAllFieldsSet(message2); + } + } + + [Test] + public void SkipWholeMessage() { + TestAllTypes message = TestUtil.GetAllSet(); + byte[] rawBytes = message.ToByteArray(); + + // Create two parallel inputs. Parse one as unknown fields while using + // skipField() to skip each field on the other. Expect the same tags. + CodedInputStream input1 = CodedInputStream.CreateInstance(rawBytes); + CodedInputStream input2 = CodedInputStream.CreateInstance(rawBytes); + UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder(); + + while (true) { + uint tag = input1.ReadTag(); + Assert.AreEqual(tag, input2.ReadTag()); + if (tag == 0) { + break; + } + unknownFields.MergeFieldFrom(tag, input1); + input2.SkipField(tag); + } + } + + public void ReadHugeBlob() { + // Allocate and initialize a 1MB blob. + byte[] blob = new byte[1 << 20]; + for (int i = 0; i < blob.Length; i++) { + blob[i] = (byte)i; + } + + // Make a message containing it. + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + builder.SetOptionalBytes(ByteString.CopyFrom(blob)); + TestAllTypes message = builder.Build(); + + // Serialize and parse it. Make sure to parse from an InputStream, not + // directly from a ByteString, so that CodedInputStream uses buffered + // reading. + TestAllTypes message2 = TestAllTypes.ParseFrom(message.ToByteString().CreateCodedInput()); + + Assert.AreEqual(message.OptionalBytes, message2.OptionalBytes); + + // Make sure all the other fields were parsed correctly. + TestAllTypes message3 = TestAllTypes.CreateBuilder(message2) + .SetOptionalBytes(TestUtil.GetAllSet().OptionalBytes) + .Build(); + TestUtil.AssertAllFieldsSet(message3); + } + + [Test] + public void ReadMaliciouslyLargeBlob() { + MemoryStream ms = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(ms); + + uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); + output.WriteRawVarint32(tag); + output.WriteRawVarint32(0x7FFFFFFF); + output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. + output.Flush(); + ms.Position = 0; + + CodedInputStream input = CodedInputStream.CreateInstance(ms); + Assert.AreEqual(tag, input.ReadTag()); + + try { + input.ReadBytes(); + Assert.Fail("Should have thrown an exception!"); + } catch (InvalidProtocolBufferException) { + // success. + } + } + + private static TestRecursiveMessage MakeRecursiveMessage(int depth) { + if (depth == 0) { + return TestRecursiveMessage.CreateBuilder().SetI(5).Build(); + } else { + return TestRecursiveMessage.CreateBuilder() + .SetA(MakeRecursiveMessage(depth - 1)).Build(); + } + } + + private static void AssertMessageDepth(TestRecursiveMessage message, int depth) { + if (depth == 0) { + Assert.IsFalse(message.HasA); + Assert.AreEqual(5, message.I); + } else { + Assert.IsTrue(message.HasA); + AssertMessageDepth(message.A, depth - 1); + } + } + + [Test] + public void MaliciousRecursion() { + ByteString data64 = MakeRecursiveMessage(64).ToByteString(); + ByteString data65 = MakeRecursiveMessage(65).ToByteString(); + + AssertMessageDepth(TestRecursiveMessage.ParseFrom(data64), 64); + + try { + TestRecursiveMessage.ParseFrom(data65); + Assert.Fail("Should have thrown an exception!"); + } catch (InvalidProtocolBufferException) { + // success. + } + + CodedInputStream input = data64.CreateCodedInput(); + input.SetRecursionLimit(8); + try { + TestRecursiveMessage.ParseFrom(input); + Assert.Fail("Should have thrown an exception!"); + } catch (InvalidProtocolBufferException) { + // success. + } + } + + [Test] + public void SizeLimit() { + // Have to use a Stream rather than ByteString.CreateCodedInput as SizeLimit doesn't + // apply to the latter case. + MemoryStream ms = new MemoryStream(TestUtil.GetAllSet().ToByteString().ToByteArray()); + CodedInputStream input = CodedInputStream.CreateInstance(ms); + input.SetSizeLimit(16); + + try { + TestAllTypes.ParseFrom(input); + Assert.Fail("Should have thrown an exception!"); + } catch (InvalidProtocolBufferException) { + // success. + } + } + + /// + /// Tests that if we read an string that contains invalid UTF-8, no exception + /// is thrown. Instead, the invalid bytes are replaced with the Unicode + /// "replacement character" U+FFFD. + /// + [Test] + public void ReadInvalidUtf8() { + MemoryStream ms = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(ms); + + uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); + output.WriteRawVarint32(tag); + output.WriteRawVarint32(1); + output.WriteRawBytes(new byte[] { 0x80 }); + output.Flush(); + ms.Position = 0; + + CodedInputStream input = CodedInputStream.CreateInstance(ms); + Assert.AreEqual(tag, input.ReadTag()); + string text = input.ReadString(); + Assert.AreEqual('\ufffd', text[0]); + } + + /// + /// A stream which limits the number of bytes it reads at a time. + /// We use this to make sure that CodedInputStream doesn't screw up when + /// reading in small blocks. + /// + private sealed class SmallBlockInputStream : MemoryStream { + private readonly int blockSize; + + public SmallBlockInputStream(byte[] data, int blockSize) + : base(data) { + this.blockSize = blockSize; + } + + public override int Read(byte[] buffer, int offset, int count) { + return base.Read(buffer, offset, Math.Min(count, blockSize)); + } + } + } +} diff --git a/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs new file mode 100644 index 00000000..d6a4e672 --- /dev/null +++ b/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs @@ -0,0 +1,239 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.IO; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class CodedOutputStreamTest { + + /// + /// Writes the given value using WriteRawVarint32() and WriteRawVarint64() and + /// checks that the result matches the given bytes + /// + private static void AssertWriteVarint(byte[] data, ulong value) { + // Only do 32-bit write if the value fits in 32 bits. + if ((value >> 32) == 0) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); + output.WriteRawVarint32((uint) value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + // Also try computing size. + Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value)); + } + + { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); + output.WriteRawVarint64(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + + // Also try computing size. + Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value)); + } + + // Try different buffer sizes. + for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { + // Only do 32-bit write if the value fits in 32 bits. + if ((value >> 32) == 0) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = + CodedOutputStream.CreateInstance(rawOutput, bufferSize); + output.WriteRawVarint32((uint) value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + } + + { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, bufferSize); + output.WriteRawVarint64(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + } + } + } + + /// + /// Tests WriteRawVarint32() and WriteRawVarint64() + /// + [Test] + public void WriteVarint() { + AssertWriteVarint(new byte[] {0x00}, 0); + AssertWriteVarint(new byte[] {0x01}, 1); + AssertWriteVarint(new byte[] {0x7f}, 127); + // 14882 + AssertWriteVarint(new byte[] {0xa2, 0x74}, (0x22 << 0) | (0x74 << 7)); + // 2961488830 + AssertWriteVarint(new byte[] {0xbe, 0xf7, 0x92, 0x84, 0x0b}, + (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | + (0x0bL << 28)); + + // 64-bit + // 7256456126 + AssertWriteVarint(new byte[] {0xbe, 0xf7, 0x92, 0x84, 0x1b}, + (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | + (0x1bL << 28)); + // 41256202580718336 + AssertWriteVarint( + new byte[] {0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49}, + (0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) | + (0x43UL << 28) | (0x49L << 35) | (0x24UL << 42) | (0x49UL << 49)); + // 11964378330978735131 + AssertWriteVarint( + new byte[] {0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01}, + unchecked((ulong) + ((0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) | + (0x3bL << 28) | (0x56L << 35) | (0x00L << 42) | + (0x05L << 49) | (0x26L << 56) | (0x01L << 63)))); + } + + /// + /// Parses the given bytes using WriteRawLittleEndian32() and checks + /// that the result matches the given value. + /// + private static void AssertWriteLittleEndian32(byte[] data, uint value) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); + output.WriteRawLittleEndian32(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + + // Try different buffer sizes. + for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { + rawOutput = new MemoryStream(); + output = CodedOutputStream.CreateInstance(rawOutput, bufferSize); + output.WriteRawLittleEndian32(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + } + } + + /// + /// Parses the given bytes using WriteRawLittleEndian64() and checks + /// that the result matches the given value. + /// + private static void AssertWriteLittleEndian64(byte[] data, ulong value) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); + output.WriteRawLittleEndian64(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + + // Try different block sizes. + for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { + rawOutput = new MemoryStream(); + output = CodedOutputStream.CreateInstance(rawOutput, blockSize); + output.WriteRawLittleEndian64(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + } + } + + /// + /// Tests writeRawLittleEndian32() and writeRawLittleEndian64(). + /// + [Test] + public void WriteLittleEndian() { + AssertWriteLittleEndian32(new byte[] {0x78, 0x56, 0x34, 0x12}, 0x12345678); + AssertWriteLittleEndian32(new byte[] {0xf0, 0xde, 0xbc, 0x9a}, 0x9abcdef0); + + AssertWriteLittleEndian64( + new byte[]{0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12}, + 0x123456789abcdef0L); + AssertWriteLittleEndian64( + new byte[]{0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a}, + 0x9abcdef012345678UL); + } + + [Test] + public void WriteWholeMessage() { + TestAllTypes message = TestUtil.GetAllSet(); + + byte[] rawBytes = message.ToByteArray(); + TestUtil.AssertEqualBytes(TestUtil.GoldenMessage.ToByteArray(), rawBytes); + + // Try different block sizes. + for (int blockSize = 1; blockSize < 256; blockSize *= 2) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = + CodedOutputStream.CreateInstance(rawOutput, blockSize); + message.WriteTo(output); + output.Flush(); + TestUtil.AssertEqualBytes(rawBytes, rawOutput.ToArray()); + } + } + + + [Test] + public void EncodeZigZag32() { + Assert.AreEqual(0, CodedOutputStream.EncodeZigZag32( 0)); + Assert.AreEqual(1, CodedOutputStream.EncodeZigZag32(-1)); + Assert.AreEqual(2, CodedOutputStream.EncodeZigZag32( 1)); + Assert.AreEqual(3, CodedOutputStream.EncodeZigZag32(-2)); + Assert.AreEqual(0x7FFFFFFE, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF)); + Assert.AreEqual(0x7FFFFFFF, CodedOutputStream.EncodeZigZag32(unchecked((int)0xC0000000))); + Assert.AreEqual(0xFFFFFFFE, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF)); + Assert.AreEqual(0xFFFFFFFF, CodedOutputStream.EncodeZigZag32(unchecked((int)0x80000000))); + } + + [Test] + public void EncodeZigZag64() { + Assert.AreEqual(0, CodedOutputStream.EncodeZigZag64( 0)); + Assert.AreEqual(1, CodedOutputStream.EncodeZigZag64(-1)); + Assert.AreEqual(2, CodedOutputStream.EncodeZigZag64( 1)); + Assert.AreEqual(3, CodedOutputStream.EncodeZigZag64(-2)); + Assert.AreEqual(0x000000007FFFFFFEL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0x000000003FFFFFFFUL))); + Assert.AreEqual(0x000000007FFFFFFFL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0xFFFFFFFFC0000000UL))); + Assert.AreEqual(0x00000000FFFFFFFEL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0x000000007FFFFFFFUL))); + Assert.AreEqual(0x00000000FFFFFFFFL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0xFFFFFFFF80000000UL))); + Assert.AreEqual(0xFFFFFFFFFFFFFFFEL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0x7FFFFFFFFFFFFFFFUL))); + Assert.AreEqual(0xFFFFFFFFFFFFFFFFL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0x8000000000000000UL))); + } + + [Test] + public void RoundTripZigZag32() { + // Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1) + // were chosen semi-randomly via keyboard bashing. + Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0))); + Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1))); + Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1))); + Assert.AreEqual(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927))); + Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612))); + } + + [Test] + public void RoundTripZigZag64() { + Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0))); + Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1))); + Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1))); + Assert.AreEqual(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927))); + Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612))); + + Assert.AreEqual(856912304801416L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L))); + Assert.AreEqual(-75123905439571256L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L))); + } + } +} diff --git a/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs b/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs new file mode 100644 index 00000000..6943672d --- /dev/null +++ b/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs @@ -0,0 +1,64 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NUnit.Framework; + +namespace Google.ProtocolBuffers.Collections { + [TestFixture] + public class PopsicleListTest { + + [Test] + public void MutatingOperationsOnFrozenList() { + PopsicleList list = new PopsicleList(); + list.MakeReadOnly(); + AssertNotSupported(() => list.Add("")); + AssertNotSupported(() => list.Clear()); + AssertNotSupported(() => list.Insert(0, "")); + AssertNotSupported(() => list.Remove("")); + AssertNotSupported(() => list.RemoveAt(0)); + } + + [Test] + public void NonMutatingOperationsOnFrozenList() { + PopsicleList list = new PopsicleList(); + list.MakeReadOnly(); + Assert.IsFalse(list.Contains("")); + Assert.AreEqual(0, list.Count); + list.CopyTo(new string[5], 0); + list.GetEnumerator(); + Assert.AreEqual(-1, list.IndexOf("")); + Assert.IsTrue(list.IsReadOnly); + } + + [Test] + public void MutatingOperationsOnFluidList() { + PopsicleList list = new PopsicleList(); + list.Add(""); + list.Clear(); + list.Insert(0, ""); + list.Remove(""); + list.Add("x"); // Just to make the next call valid + list.RemoveAt(0); + } + + [Test] + public void NonMutatingOperationsOnFluidList() { + PopsicleList list = new PopsicleList(); + Assert.IsFalse(list.Contains("")); + Assert.AreEqual(0, list.Count); + list.CopyTo(new string[5], 0); + list.GetEnumerator(); + Assert.AreEqual(-1, list.IndexOf("")); + Assert.IsFalse(list.IsReadOnly); + } + + private static void AssertNotSupported(Action action) { + try { + action(); + Assert.Fail("Expected NotSupportedException"); + } catch (NotSupportedException) { + // Expected + } + } + } +} diff --git a/src/ProtocolBuffers.Test/DescriptorsTest.cs b/src/ProtocolBuffers.Test/DescriptorsTest.cs new file mode 100644 index 00000000..c997e75a --- /dev/null +++ b/src/ProtocolBuffers.Test/DescriptorsTest.cs @@ -0,0 +1,274 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.Text; +using NUnit.Framework; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers { + /// + /// 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...) + /// + [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); + +// TODO(jonskeet): Either change to expect 3 dependencies, or don't emit them. +// Assert.AreEqual(1, file.Dependencies.Count); + Assert.AreEqual(UnitTestImportProtoFile.Descriptor, file.Dependencies[2]); + + MessageDescriptor messageType = TestAllTypes.Descriptor; + Assert.AreEqual(messageType, file.MessageTypes[0]); + Assert.AreEqual(messageType, file.FindTypeByName("TestAllTypes")); + Assert.IsNull(file.FindTypeByName("NoSuchType")); + Assert.IsNull(file.FindTypeByName("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("ForeignEnum")); + Assert.IsNull(file.FindTypeByName("NoSuchType")); + Assert.IsNull(file.FindTypeByName("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("TestService")); + Assert.IsNull(file.FindTypeByName("NoSuchType")); + Assert.IsNull(file.FindTypeByName("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("optional_int32_extension")); + Assert.IsNull(file.FindTypeByName("no_such_ext")); + Assert.IsNull(file.FindTypeByName("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("optional_int32")); + Assert.IsNull(messageType.FindDescriptor("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("NestedMessage")); + Assert.IsNull(messageType.FindDescriptor("NoSuchType")); + for (int i = 0; i < messageType.NestedTypes.Count; i++) { + Assert.AreEqual(i, messageType.NestedTypes[i].Index); + } + + Assert.AreEqual(messageType.EnumTypes[0], messageType.FindDescriptor("NestedEnum")); + Assert.IsNull(messageType.FindDescriptor("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("optional_int32"); + FieldDescriptor enumField = messageType.FindDescriptor("optional_nested_enum"); + FieldDescriptor messageField = messageType.FindDescriptor("optional_foreign_message"); + FieldDescriptor cordField = messageType.FindDescriptor("optional_cord"); + FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor; + FieldDescriptor nestedExtension = TestRequired.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("a"); + FieldDescriptor optionalField = + TestAllTypes.Descriptor.FindDescriptor("optional_int32"); + FieldDescriptor repeatedField = + TestAllTypes.Descriptor.FindDescriptor("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("optional_int32").HasDefaultValue); + Assert.AreEqual(0, d.FindDescriptor("optional_int32").DefaultValue); + Assert.IsTrue(d.FindDescriptor("default_int32").HasDefaultValue); + Assert.AreEqual(41, d.FindDescriptor("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("escaped_bytes").DefaultValue); + Assert.AreEqual(uint.MaxValue, d.FindDescriptor("large_uint32").DefaultValue); + Assert.AreEqual(ulong.MaxValue, d.FindDescriptor("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("ForeignEnum"); + EnumDescriptor nestedType = TestAllTypes.Descriptor.FindDescriptor("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/src/ProtocolBuffers.Test/DynamicMessageTest.cs b/src/ProtocolBuffers.Test/DynamicMessageTest.cs new file mode 100644 index 00000000..11fc2d82 --- /dev/null +++ b/src/ProtocolBuffers.Test/DynamicMessageTest.cs @@ -0,0 +1,114 @@ +using Google.ProtocolBuffers.TestProtos; +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class DynamicMessageTest { + + private ReflectionTester reflectionTester; + private ReflectionTester extensionsReflectionTester; + + [SetUp] + public void SetUp() { + reflectionTester = ReflectionTester.CreateTestAllTypesInstance(); + extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance(); + } + + [Test] + public void DynamicMessageAccessors() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + IMessage message = builder.WeakBuild(); + 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.WeakBuild(); + extensionsReflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void DynamicMessageRepeatedSetters() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + reflectionTester.ModifyRepeatedFieldsViaReflection(builder); + IMessage message = builder.WeakBuild(); + 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.WeakBuild(); + + Assert.AreEqual(message.SerializedSize, dynamicMessage.SerializedSize); + } + + [Test] + public void DynamicMessageSerialization() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + IMessage message = builder.WeakBuild(); + + 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/src/ProtocolBuffers.Test/GeneratedMessageTest.cs b/src/ProtocolBuffers.Test/GeneratedMessageTest.cs new file mode 100644 index 00000000..feba6e3b --- /dev/null +++ b/src/ProtocolBuffers.Test/GeneratedMessageTest.cs @@ -0,0 +1,291 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class GeneratedMessageTest { + ReflectionTester reflectionTester; + ReflectionTester extensionsReflectionTester; + + [SetUp] + public void SetUp() { + reflectionTester = ReflectionTester.CreateTestAllTypesInstance(); + extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance(); + } + + [Test] + public void RepeatedAddPrimitiveBeforeBuild() { + TestAllTypes message = new TestAllTypes.Builder { RepeatedInt32List = { 1, 2, 3 } }.Build(); + TestUtil.AssertEqual(new int[]{1, 2, 3}, message.RepeatedInt32List); + } + + [Test] + public void AddPrimitiveFailsAfterBuild() { + TestAllTypes.Builder builder = new TestAllTypes.Builder(); + IList list = builder.RepeatedInt32List; + list.Add(1); // Fine + builder.Build(); + + try { + list.Add(2); + Assert.Fail("List should be frozen"); + } catch (NotSupportedException) { + // Expected + } + } + + [Test] + public void RepeatedAddMessageBeforeBuild() { + TestAllTypes message = new TestAllTypes.Builder { + RepeatedNestedMessageList = { new TestAllTypes.Types.NestedMessage.Builder { Bb = 10 }.Build() } }.Build(); + Assert.AreEqual(1, message.RepeatedNestedMessageCount); + Assert.AreEqual(10, message.RepeatedNestedMessageList[0].Bb); + } + + [Test] + public void AddMessageFailsAfterBuild() { + TestAllTypes.Builder builder = new TestAllTypes.Builder(); + IList list = builder.RepeatedNestedMessageList; + builder.Build(); + + try { + list.Add(new TestAllTypes.Types.NestedMessage.Builder { Bb = 10 }.Build()); + Assert.Fail("List should be frozen"); + } catch (NotSupportedException) { + // Expected + } + } + + [Test] + public void DefaultInstance() { + Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.DefaultInstance.DefaultInstanceForType); + Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().DefaultInstanceForType); + } + + [Test] + public void Accessors() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestAllTypes message = builder.Build(); + TestUtil.AssertAllFieldsSet(message); + } + + [Test] + public void RepeatedSetters() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestUtil.ModifyRepeatedFields(builder); + TestAllTypes message = builder.Build(); + TestUtil.AssertRepeatedFieldsModified(message); + } + + [Test] + public void RepeatedAppend() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + + builder.AddRangeRepeatedInt32(new int[]{1, 2, 3, 4}); + builder.AddRangeRepeatedForeignEnum((new ForeignEnum[] { ForeignEnum.FOREIGN_BAZ })); + + ForeignMessage foreignMessage = ForeignMessage.CreateBuilder().SetC(12).Build(); + builder.AddRangeRepeatedForeignMessage(new ForeignMessage[] {foreignMessage}); + + TestAllTypes message = builder.Build(); + TestUtil.AssertEqual(message.RepeatedInt32List, new int[]{1, 2, 3, 4}); + TestUtil.AssertEqual(message.RepeatedForeignEnumList, new ForeignEnum[] {ForeignEnum.FOREIGN_BAZ}); + Assert.AreEqual(1, message.RepeatedForeignMessageCount); + Assert.AreEqual(12, message.GetRepeatedForeignMessage(0).C); + } + + [Test] + public void SettingForeignMessageUsingBuilder() { + TestAllTypes message = TestAllTypes.CreateBuilder() + // Pass builder for foreign message instance. + .SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(123)) + .Build(); + TestAllTypes expectedMessage = TestAllTypes.CreateBuilder() + // Create expected version passing foreign message instance explicitly. + .SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(123).Build()) + .Build(); + Assert.AreEqual(expectedMessage, message); + } + + [Test] + public void SettingRepeatedForeignMessageUsingBuilder() { + TestAllTypes message = TestAllTypes.CreateBuilder() + // Pass builder for foreign message instance. + .AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(456)) + .Build(); + TestAllTypes expectedMessage = TestAllTypes.CreateBuilder() + // Create expected version passing foreign message instance explicitly. + .AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(456).Build()) + .Build(); + Assert.AreEqual(expectedMessage, message); + } + + + [Test] + public void Defaults() { + TestUtil.AssertClear(TestAllTypes.DefaultInstance); + TestUtil.AssertClear(TestAllTypes.CreateBuilder().Build()); + + Assert.AreEqual("\u1234", TestExtremeDefaultValues.DefaultInstance.Utf8String); + } + + [Test] + public void ReflectionGetters() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestAllTypes message = builder.Build(); + reflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void ReflectionSetters() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + reflectionTester.SetAllFieldsViaReflection(builder); + TestAllTypes message = builder.Build(); + TestUtil.AssertAllFieldsSet(message); + } + + [Test] + public void ReflectionRepeatedSetters() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + reflectionTester.SetAllFieldsViaReflection(builder); + reflectionTester.ModifyRepeatedFieldsViaReflection(builder); + TestAllTypes message = builder.Build(); + TestUtil.AssertRepeatedFieldsModified(message); + } + + [Test] + public void ReflectionDefaults() { + reflectionTester.AssertClearViaReflection(TestAllTypes.DefaultInstance); + reflectionTester.AssertClearViaReflection(TestAllTypes.CreateBuilder().Build()); + } + // ================================================================= + // Extensions. + + [Test] + public void ExtensionAccessors() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + TestUtil.SetAllExtensions(builder); + TestAllExtensions message = builder.Build(); + TestUtil.AssertAllExtensionsSet(message); + } + + [Test] + public void ExtensionRepeatedSetters() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + TestUtil.SetAllExtensions(builder); + TestUtil.ModifyRepeatedExtensions(builder); + TestAllExtensions message = builder.Build(); + TestUtil.AssertRepeatedExtensionsModified(message); + } + + [Test] + public void ExtensionDefaults() { + TestUtil.AssertExtensionsClear(TestAllExtensions.DefaultInstance); + TestUtil.AssertExtensionsClear(TestAllExtensions.CreateBuilder().Build()); + } + + [Test] + public void ExtensionReflectionGetters() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + TestUtil.SetAllExtensions(builder); + TestAllExtensions message = builder.Build(); + extensionsReflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void ExtensionReflectionSetters() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + extensionsReflectionTester.SetAllFieldsViaReflection(builder); + TestAllExtensions message = builder.Build(); + TestUtil.AssertAllExtensionsSet(message); + } + + [Test] + public void ExtensionReflectionRepeatedSetters() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + extensionsReflectionTester.SetAllFieldsViaReflection(builder); + extensionsReflectionTester.ModifyRepeatedFieldsViaReflection(builder); + TestAllExtensions message = builder.Build(); + TestUtil.AssertRepeatedExtensionsModified(message); + } + + [Test] + public void ExtensionReflectionDefaults() { + extensionsReflectionTester.AssertClearViaReflection(TestAllExtensions.DefaultInstance); + extensionsReflectionTester.AssertClearViaReflection(TestAllExtensions.CreateBuilder().Build()); + } + + [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() + .AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 1) + .ClearExtension(UnitTestProtoFile.RepeatedInt32Extension) + .GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); + } + + /* Removed multiple files option for the moment + [Test] + public void MultipleFilesOption() { + // We mostly just want to check that things compile. + MessageWithNoOuter message = MessageWithNoOuter.CreateBuilder() + .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(MultiFileProto.Descriptor, MessageWithNoOuter.Descriptor.File); + + FieldDescriptor field = MessageWithNoOuter.Descriptor.FindDescriptor("foreign_enum"); + Assert.AreEqual(MultiFileProto.Descriptor.FindTypeByName("EnumWithNoOuter") + .FindValueByNumber((int)EnumWithNoOuter.BAR), message[field]); + + Assert.AreEqual(MultiFileProto.Descriptor, ServiceWithNoOuter.Descriptor.File); + + Assert.IsFalse(TestAllExtensions.DefaultInstance.HasExtension(MultiFileProto.ExtensionWithOuter)); + }*/ + + [Test] + public void OptionalFieldWithRequiredSubfieldsOptimizedForSize() { + TestOptionalOptimizedForSize message = TestOptionalOptimizedForSize.DefaultInstance; + Assert.IsTrue(message.IsInitialized); + + message = TestOptionalOptimizedForSize.CreateBuilder().SetO( + TestRequiredOptimizedForSize.CreateBuilder().BuildPartial() + ).BuildPartial(); + Assert.IsFalse(message.IsInitialized); + + message = TestOptionalOptimizedForSize.CreateBuilder().SetO( + TestRequiredOptimizedForSize.CreateBuilder().SetX(5).BuildPartial() + ).BuildPartial(); + Assert.IsTrue(message.IsInitialized); + } + } +} diff --git a/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs b/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs new file mode 100644 index 00000000..0cccd4a7 --- /dev/null +++ b/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs @@ -0,0 +1,23 @@ +using System.Collections; +using System.Collections.Generic; +using System.IO; +using NUnit.Framework; +using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class MessageStreamIteratorTest { + + [Test] + public void ThreeMessagesInMemory() { + MemoryStream stream = new MemoryStream(MessageStreamWriterTest.ThreeMessageData); + IEnumerable iterator = MessageStreamIterator.FromStreamProvider(() => stream); + List messages = new List(iterator); + + Assert.AreEqual(3, messages.Count); + Assert.AreEqual(5, messages[0].Bb); + Assert.AreEqual(1500, messages[1].Bb); + Assert.IsFalse(messages[2].HasBb); + } + } +} diff --git a/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs b/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs new file mode 100644 index 00000000..9cbe2b33 --- /dev/null +++ b/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs @@ -0,0 +1,36 @@ +using System.IO; +using NUnit.Framework; +using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class MessageStreamWriterTest { + + internal static readonly byte[] ThreeMessageData = new byte[] { + (1 << 3) | 2, 2, // Field 1, 2 bytes long (first message) + (1 << 3) | 0, 5, // Field 1, value 5 + (1 << 3) | 2, 3, // Field 1, 3 bytes long (second message) + (1 << 3) | 0, (1500 & 0x7f) | 0x80, 1500 >> 7, // Field 1, value 1500 + (1 << 3) | 2, 0, // Field 1, no data (third message) + }; + + [Test] + public void ThreeMessages() { + NestedMessage message1 = new NestedMessage.Builder { Bb = 5 }.Build(); + NestedMessage message2 = new NestedMessage.Builder { Bb = 1500 }.Build(); + NestedMessage message3 = new NestedMessage.Builder().Build(); + + byte[] data; + using (MemoryStream stream = new MemoryStream()) { + MessageStreamWriter writer = new MessageStreamWriter(stream); + writer.Write(message1); + writer.Write(message2); + writer.Write(message3); + writer.Flush(); + data = stream.ToArray(); + } + + TestUtil.AssertEqualBytes(ThreeMessageData, data); + } + } +} diff --git a/src/ProtocolBuffers.Test/MessageTest.cs b/src/ProtocolBuffers.Test/MessageTest.cs new file mode 100644 index 00000000..d206e78f --- /dev/null +++ b/src/ProtocolBuffers.Test/MessageTest.cs @@ -0,0 +1,299 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +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. + /// + [Test] + public void DynamicMergeFrom() { + 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.Single, TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetExtension(TestRequired.Single, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + + builder.AddExtension(TestRequired.Multi, TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetExtension(TestRequired.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); + + 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. + DynamicMessage message = 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/src/ProtocolBuffers.Test/Properties/AssemblyInfo.cs b/src/ProtocolBuffers.Test/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..93ff802f --- /dev/null +++ b/src/ProtocolBuffers.Test/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtocolBuffers.Test")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtocolBuffers.Test")] +[assembly: AssemblyCopyright("Copyright © 2008")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("54e627c3-daaa-4850-82cf-f25b7f097e78")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtocolBuffers.Test/Properties/Google.ProtocolBuffers.Test.snk b/src/ProtocolBuffers.Test/Properties/Google.ProtocolBuffers.Test.snk new file mode 100644 index 00000000..20046fb2 Binary files /dev/null and b/src/ProtocolBuffers.Test/Properties/Google.ProtocolBuffers.Test.snk differ diff --git a/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj new file mode 100644 index 00000000..7f84da07 --- /dev/null +++ b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -0,0 +1,88 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {DD01ED24-3750-4567-9A23-1DB676A15610} + Library + Properties + Google.ProtocolBuffers + Google.ProtocolBuffers.Test + v2.0 + 512 + true + Properties\Google.ProtocolBuffers.Test.snk + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + False + ..\..\lib\nunit.framework.dll + + + False + ..\..\lib\Rhino.Mocks.dll + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {6908BDCE-D925-43F3-94AC-A531E6DF2591} + ProtocolBuffers + + + + + + + + \ No newline at end of file diff --git a/src/ProtocolBuffers.Test/ReflectionTester.cs b/src/ProtocolBuffers.Test/ReflectionTester.cs new file mode 100644 index 00000000..c146a823 --- /dev/null +++ b/src/ProtocolBuffers.Test/ReflectionTester.cs @@ -0,0 +1,798 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + /// + /// Performs the same things that the methods of TestUtil do, but + /// via the reflection interface. This is its own class because it needs + /// to know what descriptor to use. + /// + internal class ReflectionTester { + private readonly MessageDescriptor baseDescriptor; + private readonly ExtensionRegistry extensionRegistry; + + private readonly FileDescriptor file; + private readonly FileDescriptor importFile; + + private readonly MessageDescriptor optionalGroup; + private readonly MessageDescriptor repeatedGroup; + private readonly MessageDescriptor nestedMessage; + private readonly MessageDescriptor foreignMessage; + private readonly MessageDescriptor importMessage; + + private readonly FieldDescriptor groupA; + private readonly FieldDescriptor repeatedGroupA; + private readonly FieldDescriptor nestedB; + private readonly FieldDescriptor foreignC; + private readonly FieldDescriptor importD; + + private readonly EnumDescriptor nestedEnum; + private readonly EnumDescriptor foreignEnum; + private readonly EnumDescriptor importEnum; + + private readonly EnumValueDescriptor nestedFoo; + private readonly EnumValueDescriptor nestedBar; + private readonly EnumValueDescriptor nestedBaz; + private readonly EnumValueDescriptor foreignFoo; + private readonly EnumValueDescriptor foreignBar; + private readonly EnumValueDescriptor foreignBaz; + private readonly EnumValueDescriptor importFoo; + private readonly EnumValueDescriptor importBar; + private readonly EnumValueDescriptor importBaz; + + /// + /// Constructs an instance that will expect messages using the given + /// descriptor. Normally should be + /// a descriptor for TestAllTypes. However, if extensionRegistry is non-null, + /// then baseDescriptor should be for TestAllExtensions instead, and instead of + /// reading and writing normal fields, the tester will read and write extensions. + /// All of the TestAllExtensions extensions must be registered in the registry. + /// + private ReflectionTester(MessageDescriptor baseDescriptor, + ExtensionRegistry extensionRegistry) { + this.baseDescriptor = baseDescriptor; + this.extensionRegistry = extensionRegistry; + + this.file = baseDescriptor.File; + // TODO(jonskeet): We've got 3 dependencies, not 1 - because of the C# options. Hmm. +// Assert.AreEqual(1, file.Dependencies.Count); + // TODO(jonskeet): Find dependency by name instead of number? + this.importFile = file.Dependencies[2]; + + MessageDescriptor testAllTypes; + if (extensionRegistry == null) { + testAllTypes = baseDescriptor; + } else { + testAllTypes = file.FindTypeByName("TestAllTypes"); + Assert.IsNotNull(testAllTypes); + } + + if (extensionRegistry == null) { + this.optionalGroup = + baseDescriptor.FindDescriptor("OptionalGroup"); + this.repeatedGroup = + baseDescriptor.FindDescriptor("RepeatedGroup"); + } else { + this.optionalGroup = + file.FindTypeByName("OptionalGroup_extension"); + this.repeatedGroup = + file.FindTypeByName("RepeatedGroup_extension"); + } + this.nestedMessage = testAllTypes.FindDescriptor("NestedMessage"); + this.foreignMessage = file.FindTypeByName("ForeignMessage"); + this.importMessage = importFile.FindTypeByName("ImportMessage"); + + this.nestedEnum = testAllTypes.FindDescriptor("NestedEnum"); + this.foreignEnum = file.FindTypeByName("ForeignEnum"); + this.importEnum = importFile.FindTypeByName("ImportEnum"); + + Assert.IsNotNull(optionalGroup ); + Assert.IsNotNull(repeatedGroup ); + Assert.IsNotNull(nestedMessage ); + Assert.IsNotNull(foreignMessage); + Assert.IsNotNull(importMessage ); + Assert.IsNotNull(nestedEnum ); + Assert.IsNotNull(foreignEnum ); + Assert.IsNotNull(importEnum ); + + this.nestedB = nestedMessage.FindDescriptor("bb"); + this.foreignC = foreignMessage.FindDescriptor("c"); + this.importD = importMessage .FindDescriptor("d"); + this.nestedFoo = nestedEnum.FindValueByName("FOO"); + this.nestedBar = nestedEnum.FindValueByName("BAR"); + this.nestedBaz = nestedEnum.FindValueByName("BAZ"); + this.foreignFoo = foreignEnum.FindValueByName("FOREIGN_FOO"); + this.foreignBar = foreignEnum.FindValueByName("FOREIGN_BAR"); + this.foreignBaz = foreignEnum.FindValueByName("FOREIGN_BAZ"); + this.importFoo = importEnum.FindValueByName("IMPORT_FOO"); + this.importBar = importEnum.FindValueByName("IMPORT_BAR"); + this.importBaz = importEnum.FindValueByName("IMPORT_BAZ"); + + this.groupA = optionalGroup.FindDescriptor("a"); + this.repeatedGroupA = repeatedGroup.FindDescriptor("a"); + + Assert.IsNotNull(groupA ); + Assert.IsNotNull(repeatedGroupA); + Assert.IsNotNull(nestedB ); + Assert.IsNotNull(foreignC ); + Assert.IsNotNull(importD ); + Assert.IsNotNull(nestedFoo ); + Assert.IsNotNull(nestedBar ); + Assert.IsNotNull(nestedBaz ); + Assert.IsNotNull(foreignFoo ); + Assert.IsNotNull(foreignBar ); + Assert.IsNotNull(foreignBaz ); + Assert.IsNotNull(importFoo ); + Assert.IsNotNull(importBar ); + Assert.IsNotNull(importBaz ); + } + + /// + /// Creates an instance for the TestAllTypes message, with no extension registry. + /// + public static ReflectionTester CreateTestAllTypesInstance() { + return new ReflectionTester(TestAllTypes.Descriptor, null); + } + + /// + /// Creates an instance for the TestAllExtensions message, with an + /// extension registry from TestUtil.CreateExtensionRegistry. + /// + public static ReflectionTester CreateTestAllExtensionsInstance() { + return new ReflectionTester(TestAllExtensions.Descriptor, TestUtil.CreateExtensionRegistry()); + } + + /// + /// Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes. + /// + private FieldDescriptor f(String name) { + FieldDescriptor result; + if (extensionRegistry == null) { + result = baseDescriptor.FindDescriptor(name); + } else { + result = file.FindTypeByName(name + "_extension"); + } + Assert.IsNotNull(result); + return result; + } + + /// + /// Calls parent.CreateBuilderForField() or uses the extension registry + /// to find an appropriate builder, depending on what type is being tested. + /// + private IBuilder CreateBuilderForField(IBuilder parent, FieldDescriptor field) { + if (extensionRegistry == null) { + return parent.CreateBuilderForField(field); + } else { + ExtensionInfo extension = extensionRegistry[field.ContainingType, field.FieldNumber]; + Assert.IsNotNull(extension); + Assert.IsNotNull(extension.DefaultInstance); + return extension.DefaultInstance.WeakCreateBuilderForType(); + } + } + + /// + /// Sets every field of the message to the values expected by + /// AssertAllFieldsSet, using the reflection interface. + /// + /// + internal void SetAllFieldsViaReflection(IBuilder message) { + message[f("optional_int32" )] = 101 ; + message[f("optional_int64" )] = 102L; + message[f("optional_uint32" )] = 103U ; + message[f("optional_uint64" )] = 104UL; + message[f("optional_sint32" )] = 105 ; + message[f("optional_sint64" )] = 106L; + message[f("optional_fixed32" )] = 107U ; + message[f("optional_fixed64" )] = 108UL; + message[f("optional_sfixed32")] = 109 ; + message[f("optional_sfixed64")] = 110L; + message[f("optional_float" )] = 111F; + message[f("optional_double" )] = 112D; + message[f("optional_bool" )] = true; + message[f("optional_string" )] = "115"; + message[f("optional_bytes")] = TestUtil.ToBytes("116"); + + message[f("optionalgroup")] = CreateBuilderForField(message, f("optionalgroup")).SetField(groupA, 117).WeakBuild(); + message[f("optional_nested_message")] = CreateBuilderForField(message, f("optional_nested_message")).SetField(nestedB, 118).WeakBuild(); + message[f("optional_foreign_message")] = CreateBuilderForField(message, f("optional_foreign_message")).SetField(foreignC, 119).WeakBuild(); + message[f("optional_import_message")] = CreateBuilderForField(message, f("optional_import_message")).SetField(importD, 120).WeakBuild(); + + message[f("optional_nested_enum" )] = nestedBaz; + message[f("optional_foreign_enum")] = foreignBaz; + message[f("optional_import_enum" )] = importBaz; + + message[f("optional_string_piece" )] = "124"; + message[f("optional_cord" )] = "125"; + + // ----------------------------------------------------------------- + + message.WeakAddRepeatedField(f("repeated_int32" ), 201 ); + message.WeakAddRepeatedField(f("repeated_int64" ), 202L); + message.WeakAddRepeatedField(f("repeated_uint32" ), 203U ); + message.WeakAddRepeatedField(f("repeated_uint64" ), 204UL); + message.WeakAddRepeatedField(f("repeated_sint32" ), 205 ); + message.WeakAddRepeatedField(f("repeated_sint64" ), 206L); + message.WeakAddRepeatedField(f("repeated_fixed32" ), 207U ); + message.WeakAddRepeatedField(f("repeated_fixed64" ), 208UL); + message.WeakAddRepeatedField(f("repeated_sfixed32"), 209 ); + message.WeakAddRepeatedField(f("repeated_sfixed64"), 210L); + message.WeakAddRepeatedField(f("repeated_float" ), 211F); + message.WeakAddRepeatedField(f("repeated_double" ), 212D); + message.WeakAddRepeatedField(f("repeated_bool" ), true); + message.WeakAddRepeatedField(f("repeated_string" ), "215"); + message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("216")); + + + message.WeakAddRepeatedField(f("repeatedgroup"), CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 217).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_nested_message"), CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 218).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_foreign_message"), CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 219).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_import_message"), CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 220).WeakBuild()); + + message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBar); + message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBar); + message.WeakAddRepeatedField(f("repeated_import_enum" ), importBar); + + message.WeakAddRepeatedField(f("repeated_string_piece" ), "224"); + message.WeakAddRepeatedField(f("repeated_cord" ), "225"); + + // Add a second one of each field. + message.WeakAddRepeatedField(f("repeated_int32" ), 301 ); + message.WeakAddRepeatedField(f("repeated_int64" ), 302L); + message.WeakAddRepeatedField(f("repeated_uint32" ), 303U ); + message.WeakAddRepeatedField(f("repeated_uint64" ), 304UL); + message.WeakAddRepeatedField(f("repeated_sint32" ), 305 ); + message.WeakAddRepeatedField(f("repeated_sint64" ), 306L); + message.WeakAddRepeatedField(f("repeated_fixed32" ), 307U ); + message.WeakAddRepeatedField(f("repeated_fixed64" ), 308UL); + message.WeakAddRepeatedField(f("repeated_sfixed32"), 309 ); + message.WeakAddRepeatedField(f("repeated_sfixed64"), 310L); + message.WeakAddRepeatedField(f("repeated_float" ), 311F); + message.WeakAddRepeatedField(f("repeated_double" ), 312D); + message.WeakAddRepeatedField(f("repeated_bool" ), false); + message.WeakAddRepeatedField(f("repeated_string" ), "315"); + message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("316")); + + message.WeakAddRepeatedField(f("repeatedgroup"), + CreateBuilderForField(message, f("repeatedgroup")) + .SetField(repeatedGroupA, 317).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_nested_message"), + CreateBuilderForField(message, f("repeated_nested_message")) + .SetField(nestedB, 318).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_foreign_message"), + CreateBuilderForField(message, f("repeated_foreign_message")) + .SetField(foreignC, 319).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_import_message"), + CreateBuilderForField(message, f("repeated_import_message")) + .SetField(importD, 320).WeakBuild()); + + message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBaz); + message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBaz); + message.WeakAddRepeatedField(f("repeated_import_enum" ), importBaz); + + message.WeakAddRepeatedField(f("repeated_string_piece" ), "324"); + message.WeakAddRepeatedField(f("repeated_cord" ), "325"); + + // ----------------------------------------------------------------- + + message[f("default_int32" )] = 401 ; + message[f("default_int64" )] = 402L; + message[f("default_uint32" )] = 403U ; + message[f("default_uint64" )] = 404UL; + message[f("default_sint32" )] = 405 ; + message[f("default_sint64" )] = 406L; + message[f("default_fixed32" )] = 407U ; + message[f("default_fixed64" )] = 408UL; + message[f("default_sfixed32")] = 409 ; + message[f("default_sfixed64")] = 410L; + message[f("default_float" )] = 411F; + message[f("default_double" )] = 412D; + message[f("default_bool" )] = false; + message[f("default_string" )] = "415"; + message[f("default_bytes" )] = TestUtil.ToBytes("416"); + + message[f("default_nested_enum" )] = nestedFoo; + message[f("default_foreign_enum")] = foreignFoo; + message[f("default_import_enum" )] = importFoo; + + message[f("default_string_piece" )] = "424"; + message[f("default_cord" )] = "425"; + } + + // ------------------------------------------------------------------- + + /// + /// Modify the repeated fields of the specified message to contain the + /// values expected by AssertRepeatedFieldsModified, using the IBuilder + /// reflection interface. + /// + internal void ModifyRepeatedFieldsViaReflection(IBuilder message) { + message[f("repeated_int32" ), 1] = 501 ; + message[f("repeated_int64" ), 1] = 502L; + message[f("repeated_uint32" ), 1] = 503U ; + message[f("repeated_uint64" ), 1] = 504UL; + message[f("repeated_sint32" ), 1] = 505 ; + message[f("repeated_sint64" ), 1] = 506L; + message[f("repeated_fixed32" ), 1] = 507U ; + message[f("repeated_fixed64" ), 1] = 508UL; + message[f("repeated_sfixed32"), 1] = 509 ; + message[f("repeated_sfixed64"), 1] = 510L; + message[f("repeated_float" ), 1] = 511F; + message[f("repeated_double" ), 1] = 512D; + message[f("repeated_bool" ), 1] = true; + message[f("repeated_string" ), 1] = "515"; + message.SetRepeatedField(f("repeated_bytes" ), 1, TestUtil.ToBytes("516")); + + message.SetRepeatedField(f("repeatedgroup"), 1, CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 517).WeakBuild()); + message.SetRepeatedField(f("repeated_nested_message"), 1, CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 518).WeakBuild()); + message.SetRepeatedField(f("repeated_foreign_message"), 1, CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 519).WeakBuild()); + message.SetRepeatedField(f("repeated_import_message"), 1, CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 520).WeakBuild()); + + message[f("repeated_nested_enum" ), 1] = nestedFoo; + message[f("repeated_foreign_enum"), 1] = foreignFoo; + message[f("repeated_import_enum" ), 1] = importFoo; + + message[f("repeated_string_piece"), 1] = "524"; + message[f("repeated_cord"), 1] = "525"; + } + + // ------------------------------------------------------------------- + + /// + /// Asserts that all fields of the specified message are set to the values + /// assigned by SetAllFields, using the IMessage reflection interface. + /// + public void AssertAllFieldsSetViaReflection(IMessage message) { + Assert.IsTrue(message.HasField(f("optional_int32" ))); + Assert.IsTrue(message.HasField(f("optional_int64" ))); + Assert.IsTrue(message.HasField(f("optional_uint32" ))); + Assert.IsTrue(message.HasField(f("optional_uint64" ))); + Assert.IsTrue(message.HasField(f("optional_sint32" ))); + Assert.IsTrue(message.HasField(f("optional_sint64" ))); + Assert.IsTrue(message.HasField(f("optional_fixed32" ))); + Assert.IsTrue(message.HasField(f("optional_fixed64" ))); + Assert.IsTrue(message.HasField(f("optional_sfixed32"))); + Assert.IsTrue(message.HasField(f("optional_sfixed64"))); + Assert.IsTrue(message.HasField(f("optional_float" ))); + Assert.IsTrue(message.HasField(f("optional_double" ))); + Assert.IsTrue(message.HasField(f("optional_bool" ))); + Assert.IsTrue(message.HasField(f("optional_string" ))); + Assert.IsTrue(message.HasField(f("optional_bytes" ))); + + Assert.IsTrue(message.HasField(f("optionalgroup" ))); + Assert.IsTrue(message.HasField(f("optional_nested_message" ))); + Assert.IsTrue(message.HasField(f("optional_foreign_message"))); + Assert.IsTrue(message.HasField(f("optional_import_message" ))); + + Assert.IsTrue(((IMessage)message[f("optionalgroup")]).HasField(groupA)); + Assert.IsTrue(((IMessage)message[f("optional_nested_message")]).HasField(nestedB)); + Assert.IsTrue(((IMessage)message[f("optional_foreign_message")]).HasField(foreignC)); + Assert.IsTrue(((IMessage)message[f("optional_import_message")]).HasField(importD)); + + Assert.IsTrue(message.HasField(f("optional_nested_enum" ))); + Assert.IsTrue(message.HasField(f("optional_foreign_enum"))); + Assert.IsTrue(message.HasField(f("optional_import_enum" ))); + + Assert.IsTrue(message.HasField(f("optional_string_piece"))); + Assert.IsTrue(message.HasField(f("optional_cord"))); + + Assert.AreEqual(101 , message[f("optional_int32" )]); + Assert.AreEqual(102L , message[f("optional_int64" )]); + Assert.AreEqual(103U , message[f("optional_uint32" )]); + Assert.AreEqual(104UL , message[f("optional_uint64" )]); + Assert.AreEqual(105 , message[f("optional_sint32" )]); + Assert.AreEqual(106L , message[f("optional_sint64" )]); + Assert.AreEqual(107U , message[f("optional_fixed32" )]); + Assert.AreEqual(108UL , message[f("optional_fixed64" )]); + Assert.AreEqual(109 , message[f("optional_sfixed32")]); + Assert.AreEqual(110L , message[f("optional_sfixed64")]); + Assert.AreEqual(111F , message[f("optional_float" )]); + Assert.AreEqual(112D , message[f("optional_double" )]); + Assert.AreEqual(true , message[f("optional_bool" )]); + Assert.AreEqual("115", message[f("optional_string" )]); + Assert.AreEqual(TestUtil.ToBytes("116"), message[f("optional_bytes")]); + + Assert.AreEqual(117,((IMessage)message[f("optionalgroup")])[groupA]); + Assert.AreEqual(118,((IMessage)message[f("optional_nested_message")])[nestedB]); + Assert.AreEqual(119,((IMessage)message[f("optional_foreign_message")])[foreignC]); + Assert.AreEqual(120,((IMessage)message[f("optional_import_message")])[importD]); + + Assert.AreEqual( nestedBaz, message[f("optional_nested_enum" )]); + Assert.AreEqual(foreignBaz, message[f("optional_foreign_enum")]); + Assert.AreEqual( importBaz, message[f("optional_import_enum" )]); + + Assert.AreEqual("124", message[f("optional_string_piece")]); + Assert.AreEqual("125", message[f("optional_cord")]); + + // ----------------------------------------------------------------- + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" ))); + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" ))); + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord"))); + + Assert.AreEqual(201 , message[f("repeated_int32" ), 0]); + Assert.AreEqual(202L , message[f("repeated_int64" ), 0]); + Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]); + Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]); + Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]); + Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]); + Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]); + Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]); + Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]); + Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]); + Assert.AreEqual(211F , message[f("repeated_float" ), 0]); + Assert.AreEqual(212D , message[f("repeated_double" ), 0]); + Assert.AreEqual(true , message[f("repeated_bool" ), 0]); + Assert.AreEqual("215", message[f("repeated_string" ), 0]); + Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]); + + Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]); + Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]); + Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]); + Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]); + + Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]); + Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]); + Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]); + + Assert.AreEqual("224", message[f("repeated_string_piece"), 0]); + Assert.AreEqual("225", message[f("repeated_cord"), 0]); + + Assert.AreEqual(301 , message[f("repeated_int32" ), 1]); + Assert.AreEqual(302L , message[f("repeated_int64" ), 1]); + Assert.AreEqual(303U , message[f("repeated_uint32" ), 1]); + Assert.AreEqual(304UL, message[f("repeated_uint64" ), 1]); + Assert.AreEqual(305 , message[f("repeated_sint32" ), 1]); + Assert.AreEqual(306L , message[f("repeated_sint64" ), 1]); + Assert.AreEqual(307U , message[f("repeated_fixed32" ), 1]); + Assert.AreEqual(308UL, message[f("repeated_fixed64" ), 1]); + Assert.AreEqual(309 , message[f("repeated_sfixed32"), 1]); + Assert.AreEqual(310L , message[f("repeated_sfixed64"), 1]); + Assert.AreEqual(311F , message[f("repeated_float" ), 1]); + Assert.AreEqual(312D , message[f("repeated_double" ), 1]); + Assert.AreEqual(false, message[f("repeated_bool" ), 1]); + Assert.AreEqual("315", message[f("repeated_string" ), 1]); + Assert.AreEqual(TestUtil.ToBytes("316"), message[f("repeated_bytes"), 1]); + + Assert.AreEqual(317,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]); + Assert.AreEqual(318,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]); + Assert.AreEqual(319,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]); + Assert.AreEqual(320,((IMessage)message[f("repeated_import_message"), 1])[importD]); + + Assert.AreEqual( nestedBaz, message[f("repeated_nested_enum" ),1]); + Assert.AreEqual(foreignBaz, message[f("repeated_foreign_enum"),1]); + Assert.AreEqual( importBaz, message[f("repeated_import_enum" ),1]); + + Assert.AreEqual("324", message[f("repeated_string_piece"), 1]); + Assert.AreEqual("325", message[f("repeated_cord"), 1]); + + // ----------------------------------------------------------------- + + Assert.IsTrue(message.HasField(f("default_int32" ))); + Assert.IsTrue(message.HasField(f("default_int64" ))); + Assert.IsTrue(message.HasField(f("default_uint32" ))); + Assert.IsTrue(message.HasField(f("default_uint64" ))); + Assert.IsTrue(message.HasField(f("default_sint32" ))); + Assert.IsTrue(message.HasField(f("default_sint64" ))); + Assert.IsTrue(message.HasField(f("default_fixed32" ))); + Assert.IsTrue(message.HasField(f("default_fixed64" ))); + Assert.IsTrue(message.HasField(f("default_sfixed32"))); + Assert.IsTrue(message.HasField(f("default_sfixed64"))); + Assert.IsTrue(message.HasField(f("default_float" ))); + Assert.IsTrue(message.HasField(f("default_double" ))); + Assert.IsTrue(message.HasField(f("default_bool" ))); + Assert.IsTrue(message.HasField(f("default_string" ))); + Assert.IsTrue(message.HasField(f("default_bytes" ))); + + Assert.IsTrue(message.HasField(f("default_nested_enum" ))); + Assert.IsTrue(message.HasField(f("default_foreign_enum"))); + Assert.IsTrue(message.HasField(f("default_import_enum" ))); + + Assert.IsTrue(message.HasField(f("default_string_piece"))); + Assert.IsTrue(message.HasField(f("default_cord"))); + + Assert.AreEqual(401 , message[f("default_int32" )]); + Assert.AreEqual(402L , message[f("default_int64" )]); + Assert.AreEqual(403U , message[f("default_uint32" )]); + Assert.AreEqual(404UL, message[f("default_uint64" )]); + Assert.AreEqual(405 , message[f("default_sint32" )]); + Assert.AreEqual(406L , message[f("default_sint64" )]); + Assert.AreEqual(407U , message[f("default_fixed32" )]); + Assert.AreEqual(408UL, message[f("default_fixed64" )]); + Assert.AreEqual(409 , message[f("default_sfixed32")]); + Assert.AreEqual(410L , message[f("default_sfixed64")]); + Assert.AreEqual(411F , message[f("default_float" )]); + Assert.AreEqual(412D , message[f("default_double" )]); + Assert.AreEqual(false, message[f("default_bool" )]); + Assert.AreEqual("415", message[f("default_string" )]); + Assert.AreEqual(TestUtil.ToBytes("416"), message[f("default_bytes")]); + + Assert.AreEqual( nestedFoo, message[f("default_nested_enum" )]); + Assert.AreEqual(foreignFoo, message[f("default_foreign_enum")]); + Assert.AreEqual( importFoo, message[f("default_import_enum" )]); + + Assert.AreEqual("424", message[f("default_string_piece")]); + Assert.AreEqual("425", message[f("default_cord")]); + } + + /// + /// Assert that all fields of the message are cleared, and that + /// getting the fields returns their default values, using the reflection interface. + /// + public void AssertClearViaReflection(IMessage message) { + // has_blah() should initially be false for all optional fields. + Assert.IsFalse(message.HasField(f("optional_int32" ))); + Assert.IsFalse(message.HasField(f("optional_int64" ))); + Assert.IsFalse(message.HasField(f("optional_uint32" ))); + Assert.IsFalse(message.HasField(f("optional_uint64" ))); + Assert.IsFalse(message.HasField(f("optional_sint32" ))); + Assert.IsFalse(message.HasField(f("optional_sint64" ))); + Assert.IsFalse(message.HasField(f("optional_fixed32" ))); + Assert.IsFalse(message.HasField(f("optional_fixed64" ))); + Assert.IsFalse(message.HasField(f("optional_sfixed32"))); + Assert.IsFalse(message.HasField(f("optional_sfixed64"))); + Assert.IsFalse(message.HasField(f("optional_float" ))); + Assert.IsFalse(message.HasField(f("optional_double" ))); + Assert.IsFalse(message.HasField(f("optional_bool" ))); + Assert.IsFalse(message.HasField(f("optional_string" ))); + Assert.IsFalse(message.HasField(f("optional_bytes" ))); + + Assert.IsFalse(message.HasField(f("optionalgroup" ))); + Assert.IsFalse(message.HasField(f("optional_nested_message" ))); + Assert.IsFalse(message.HasField(f("optional_foreign_message"))); + Assert.IsFalse(message.HasField(f("optional_import_message" ))); + + Assert.IsFalse(message.HasField(f("optional_nested_enum" ))); + Assert.IsFalse(message.HasField(f("optional_foreign_enum"))); + Assert.IsFalse(message.HasField(f("optional_import_enum" ))); + + Assert.IsFalse(message.HasField(f("optional_string_piece"))); + Assert.IsFalse(message.HasField(f("optional_cord"))); + + // Optional fields without defaults are set to zero or something like it. + Assert.AreEqual(0 , message[f("optional_int32" )]); + Assert.AreEqual(0L , message[f("optional_int64" )]); + Assert.AreEqual(0U , message[f("optional_uint32" )]); + Assert.AreEqual(0UL , message[f("optional_uint64" )]); + Assert.AreEqual(0 , message[f("optional_sint32" )]); + Assert.AreEqual(0L , message[f("optional_sint64" )]); + Assert.AreEqual(0U , message[f("optional_fixed32" )]); + Assert.AreEqual(0UL , message[f("optional_fixed64" )]); + Assert.AreEqual(0 , message[f("optional_sfixed32")]); + Assert.AreEqual(0L , message[f("optional_sfixed64")]); + Assert.AreEqual(0F , message[f("optional_float" )]); + Assert.AreEqual(0D , message[f("optional_double" )]); + Assert.AreEqual(false, message[f("optional_bool" )]); + Assert.AreEqual("" , message[f("optional_string" )]); + Assert.AreEqual(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")]) + .HasField(nestedB)); + Assert.IsFalse(((IMessage)message[f("optional_foreign_message")]) + .HasField(foreignC)); + Assert.IsFalse(((IMessage)message[f("optional_import_message")]) + .HasField(importD)); + + Assert.AreEqual(0,((IMessage)message[f("optionalgroup")])[groupA]); + Assert.AreEqual(0,((IMessage)message[f("optional_nested_message")])[nestedB]); + Assert.AreEqual(0,((IMessage)message[f("optional_foreign_message")])[foreignC]); + Assert.AreEqual(0,((IMessage)message[f("optional_import_message")])[importD]); + + // Enums without defaults are set to the first value in the enum. + Assert.AreEqual( nestedFoo, message[f("optional_nested_enum" )]); + Assert.AreEqual(foreignFoo, message[f("optional_foreign_enum")]); + Assert.AreEqual( importFoo, message[f("optional_import_enum" )]); + + Assert.AreEqual("", message[f("optional_string_piece")]); + Assert.AreEqual("", message[f("optional_cord")]); + + // Repeated fields are empty. + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int32" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int64" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint32" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint64" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint32" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint64" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed32" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed64" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_float" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_double" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bool" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bytes" ))); + + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeatedgroup" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_message" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_message" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_enum" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_enum" ))); + + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_cord"))); + + // has_blah() should also be false for all default fields. + Assert.IsFalse(message.HasField(f("default_int32" ))); + Assert.IsFalse(message.HasField(f("default_int64" ))); + Assert.IsFalse(message.HasField(f("default_uint32" ))); + Assert.IsFalse(message.HasField(f("default_uint64" ))); + Assert.IsFalse(message.HasField(f("default_sint32" ))); + Assert.IsFalse(message.HasField(f("default_sint64" ))); + Assert.IsFalse(message.HasField(f("default_fixed32" ))); + Assert.IsFalse(message.HasField(f("default_fixed64" ))); + Assert.IsFalse(message.HasField(f("default_sfixed32"))); + Assert.IsFalse(message.HasField(f("default_sfixed64"))); + Assert.IsFalse(message.HasField(f("default_float" ))); + Assert.IsFalse(message.HasField(f("default_double" ))); + Assert.IsFalse(message.HasField(f("default_bool" ))); + Assert.IsFalse(message.HasField(f("default_string" ))); + Assert.IsFalse(message.HasField(f("default_bytes" ))); + + Assert.IsFalse(message.HasField(f("default_nested_enum" ))); + Assert.IsFalse(message.HasField(f("default_foreign_enum"))); + Assert.IsFalse(message.HasField(f("default_import_enum" ))); + + Assert.IsFalse(message.HasField(f("default_string_piece" ))); + Assert.IsFalse(message.HasField(f("default_cord" ))); + + // Fields with defaults have their default values (duh). + Assert.AreEqual( 41 , message[f("default_int32" )]); + Assert.AreEqual( 42L , message[f("default_int64" )]); + Assert.AreEqual( 43U , message[f("default_uint32" )]); + Assert.AreEqual( 44UL , message[f("default_uint64" )]); + Assert.AreEqual(-45 , message[f("default_sint32" )]); + Assert.AreEqual( 46L , message[f("default_sint64" )]); + Assert.AreEqual( 47U , message[f("default_fixed32" )]); + Assert.AreEqual( 48UL , message[f("default_fixed64" )]); + Assert.AreEqual( 49 , message[f("default_sfixed32")]); + Assert.AreEqual(-50L , message[f("default_sfixed64")]); + Assert.AreEqual( 51.5F , message[f("default_float" )]); + Assert.AreEqual( 52e3D , message[f("default_double" )]); + Assert.AreEqual(true , message[f("default_bool" )]); + Assert.AreEqual("hello", message[f("default_string" )]); + Assert.AreEqual(TestUtil.ToBytes("world"), message[f("default_bytes")]); + + Assert.AreEqual( nestedBar, message[f("default_nested_enum" )]); + Assert.AreEqual(foreignBar, message[f("default_foreign_enum")]); + Assert.AreEqual( importBar, message[f("default_import_enum" )]); + + Assert.AreEqual("abc", message[f("default_string_piece")]); + Assert.AreEqual("123", message[f("default_cord")]); + } + + // --------------------------------------------------------------- + + internal void AssertRepeatedFieldsModifiedViaReflection(IMessage message) { + // ModifyRepeatedFields only sets the second repeated element of each + // field. In addition to verifying this, we also verify that the first + // element and size were *not* modified. + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" ))); + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" ))); + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord"))); + + Assert.AreEqual(201 , message[f("repeated_int32" ), 0]); + Assert.AreEqual(202L , message[f("repeated_int64" ), 0]); + Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]); + Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]); + Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]); + Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]); + Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]); + Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]); + Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]); + Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]); + Assert.AreEqual(211F , message[f("repeated_float" ), 0]); + Assert.AreEqual(212D , message[f("repeated_double" ), 0]); + Assert.AreEqual(true , message[f("repeated_bool" ), 0]); + Assert.AreEqual("215", message[f("repeated_string" ), 0]); + Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]); + + Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]); + Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]); + Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]); + Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]); + + Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]); + Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]); + Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]); + + Assert.AreEqual("224", message[f("repeated_string_piece"), 0]); + Assert.AreEqual("225", message[f("repeated_cord"), 0]); + + Assert.AreEqual(501 , message[f("repeated_int32" ), 1]); + Assert.AreEqual(502L , message[f("repeated_int64" ), 1]); + Assert.AreEqual(503U , message[f("repeated_uint32" ), 1]); + Assert.AreEqual(504UL, message[f("repeated_uint64" ), 1]); + Assert.AreEqual(505 , message[f("repeated_sint32" ), 1]); + Assert.AreEqual(506L , message[f("repeated_sint64" ), 1]); + Assert.AreEqual(507U , message[f("repeated_fixed32" ), 1]); + Assert.AreEqual(508UL, message[f("repeated_fixed64" ), 1]); + Assert.AreEqual(509 , message[f("repeated_sfixed32"), 1]); + Assert.AreEqual(510L , message[f("repeated_sfixed64"), 1]); + Assert.AreEqual(511F , message[f("repeated_float" ), 1]); + Assert.AreEqual(512D , message[f("repeated_double" ), 1]); + Assert.AreEqual(true , message[f("repeated_bool" ), 1]); + Assert.AreEqual("515", message[f("repeated_string" ), 1]); + Assert.AreEqual(TestUtil.ToBytes("516"), message[f("repeated_bytes"), 1]); + + Assert.AreEqual(517,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]); + Assert.AreEqual(518,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]); + Assert.AreEqual(519,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]); + Assert.AreEqual(520,((IMessage)message[f("repeated_import_message"), 1])[importD]); + + Assert.AreEqual( nestedFoo, message[f("repeated_nested_enum" ),1]); + Assert.AreEqual(foreignFoo, message[f("repeated_foreign_enum"),1]); + Assert.AreEqual( importFoo, message[f("repeated_import_enum" ),1]); + + Assert.AreEqual("524", message[f("repeated_string_piece"), 1]); + Assert.AreEqual("525", message[f("repeated_cord"), 1]); + } + } +} diff --git a/src/ProtocolBuffers.Test/ServiceTest.cs b/src/ProtocolBuffers.Test/ServiceTest.cs new file mode 100644 index 00000000..34f83bda --- /dev/null +++ b/src/ProtocolBuffers.Test/ServiceTest.cs @@ -0,0 +1,178 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; +using Rhino.Mocks; +using Rhino.Mocks.Constraints; + +namespace Google.ProtocolBuffers { + + /// + /// Tests for generated service classes. + /// TODO(jonskeet): Convert the mocking tests using Rhino.Mocks. + /// + [TestFixture] + public class ServiceTest { + + delegate void Action(T1 t1, T2 t2); + + private static readonly MethodDescriptor FooDescriptor = TestService.Descriptor.Methods[0]; + private static readonly MethodDescriptor BarDescriptor = TestService.Descriptor.Methods[1]; + + [Test] + public void GetRequestPrototype() { + TestService service = new TestServiceImpl(); + + Assert.AreSame(service.GetRequestPrototype(FooDescriptor), FooRequest.DefaultInstance); + Assert.AreSame(service.GetRequestPrototype(BarDescriptor), BarRequest.DefaultInstance); + } + + [Test] + public void GetResponsePrototype() { + TestService service = new TestServiceImpl(); + + Assert.AreSame(service.GetResponsePrototype(FooDescriptor), FooResponse.DefaultInstance); + Assert.AreSame(service.GetResponsePrototype(BarDescriptor), BarResponse.DefaultInstance); + } + + [Test] + public void CallMethodFoo() { + MockRepository mocks = new MockRepository(); + FooRequest fooRequest = FooRequest.CreateBuilder().Build(); + FooResponse fooResponse = FooResponse.CreateBuilder().Build(); + IRpcController controller = mocks.StrictMock(); + + bool fooCalled = false; + + TestService service = new TestServiceImpl((request, responseAction) => { + Assert.AreSame(fooRequest, request); + fooCalled = true; + responseAction(fooResponse); + }, null, controller); + + bool doneHandlerCalled = false; + Action doneHandler = (response => { + Assert.AreSame(fooResponse, response); + doneHandlerCalled = true; + }); + + using (mocks.Record()) { + // No mock interactions to record + } + + service.CallMethod(FooDescriptor, controller, fooRequest, doneHandler); + + Assert.IsTrue(doneHandlerCalled); + Assert.IsTrue(fooCalled); + mocks.VerifyAll(); + } + + delegate void CallFooDelegate(MethodDescriptor descriptor, IRpcController controller, + IMessage request, IMessage response, Action doneHandler); + + /// + /// Tests the generated stub handling of Foo. By this stage we're reasonably confident + /// that the choice between Foo and Bar is arbitrary, hence the lack of a corresponding Bar + /// test. + /// + [Test] + public void GeneratedStubFooCall() { + FooRequest fooRequest = FooRequest.CreateBuilder().Build(); + MockRepository mocks = new MockRepository(); + IRpcChannel mockChannel = mocks.StrictMock(); + IRpcController mockController = mocks.StrictMock(); + TestService service = TestService.CreateStub(mockChannel); + Action doneHandler = mocks.StrictMock>(); + + using (mocks.Record()) { + + // Nasty way of mocking out "the channel calls the done handler". + Expect.Call(() => mockChannel.CallMethod(null, null, null, null, null)) + .IgnoreArguments() + .Constraints(Is.Same(FooDescriptor), Is.Same(mockController), Is.Same(fooRequest), + Is.Same(FooResponse.DefaultInstance), Is.Anything()) + .Do((CallFooDelegate) ((p1, p2, p3, response, done) => done(response))); + doneHandler.Invoke(FooResponse.DefaultInstance); + } + + service.Foo(mockController, fooRequest, doneHandler); + + mocks.VerifyAll(); + } + + [Test] + public void CallMethodBar() { + MockRepository mocks = new MockRepository(); + BarRequest barRequest = BarRequest.CreateBuilder().Build(); + BarResponse barResponse = BarResponse.CreateBuilder().Build(); + IRpcController controller = mocks.StrictMock(); + + bool barCalled = false; + + TestService service = new TestServiceImpl(null, (request, responseAction) => { + Assert.AreSame(barRequest, request); + barCalled = true; + responseAction(barResponse); + }, controller); + + bool doneHandlerCalled = false; + Action doneHandler = (response => { + Assert.AreSame(barResponse, response); + doneHandlerCalled = true; + }); + + using (mocks.Record()) { + // No mock interactions to record + } + + service.CallMethod(BarDescriptor, controller, barRequest, doneHandler); + + Assert.IsTrue(doneHandlerCalled); + Assert.IsTrue(barCalled); + mocks.VerifyAll(); + } + + + class TestServiceImpl : TestService { + private readonly Action> fooHandler; + private readonly Action> barHandler; + private readonly IRpcController expectedController; + + internal TestServiceImpl() { + } + + internal TestServiceImpl(Action> fooHandler, + Action> barHandler, + IRpcController expectedController) { + this.fooHandler = fooHandler; + this.barHandler = barHandler; + this.expectedController = expectedController; + } + + public override void Foo(IRpcController controller, FooRequest request, Action done) { + Assert.AreSame(expectedController, controller); + fooHandler(request, done); + } + + public override void Bar(IRpcController controller, BarRequest request, Action done) { + Assert.AreSame(expectedController, controller); + barHandler(request, done); + } + } + } +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs new file mode 100644 index 00000000..8a1def53 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs @@ -0,0 +1,2251 @@ +// 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; +namespace Google.ProtocolBuffers.TestProtos { + + public static partial class UnitTestCustomOptionsProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "Ci1nb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfY3VzdG9tX29wdGlvbnMucHJv" + + "dG8SEXByb3RvYnVmX3VuaXR0ZXN0GiRnb29nbGUvcHJvdG9idWYvY3NoYXJw" + + "X29wdGlvbnMucHJvdG8aIGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlwdG9yLnBy" + + "b3RvIpoBChxUZXN0TWVzc2FnZVdpdGhDdXN0b21PcHRpb25zEioKBmZpZWxk" + + "MRgBIAEoCUIaCAHB4MMdLeF1CgIAAADB4MMdLeF1CgIAAAAiPAoGQW5FbnVt" + + "Eg8KC0FORU5VTV9WQUwxEAESDwoLQU5FTlVNX1ZBTDIQAhoQxfbJHev8///F" + + "9skd6/z//zoQCADg6cIdyP//////////ASIYChZDdXN0b21PcHRpb25Gb29S" + + "ZXF1ZXN0IhkKF0N1c3RvbU9wdGlvbkZvb1Jlc3BvbnNlIm0KGkR1bW15TWVz" + + "c2FnZUNvbnRhaW5pbmdFbnVtIk8KDFRlc3RFbnVtVHlwZRIaChZURVNUX09Q" + + "VElPTl9FTlVNX1RZUEUxEBYSIwoWVEVTVF9PUFRJT05fRU5VTV9UWVBFMhDp" + + "//////////8BIiEKH0R1bW15TWVzc2FnZUludmFsaWRBc09wdGlvblR5cGUi" + + "swEKHEN1c3RvbU9wdGlvbk1pbkludGVnZXJWYWx1ZXM6kgGZ1qgdAAAAAAAA" + + "AICZ1qgdAAAAAAAAAICtja8dAAAAgK2Nrx0AAACAke6vHQAAAAAAAAAAke6v" + + "HQAAAAAAAAAAnfWvHQAAAACd9a8dAAAAAPiXsB3///////////8BgMSwHf//" + + "//8P+PWwHQCAk7IdALC8sh2AgICAgICAgIAB6MayHYCAgID4/////wHQ3rId" + + "ACK6AQocQ3VzdG9tT3B0aW9uTWF4SW50ZWdlclZhbHVlczqZAZnWqB3/////" + + "////f5nWqB3/////////f62Nrx3///9/rY2vHf///3+R7q8d//////////+R" + + "7q8d//////////+d9a8d/////531rx3/////+JewHf7//////////wGAxLAd" + + "/v///w/49bAd////////////AYCTsh3/////D7C8sh3//////////3/oxrId" + + "/////wfQ3rIdASKCAQoXQ3VzdG9tT3B0aW9uT3RoZXJWYWx1ZXM6Z4jZoh3p" + + "//////////8BstmiHQtIZWxsbwBXb3JsZKrcoh0OSGVsbG8sICJXb3JsZCLp" + + "3KId+1mMQsrA8z/p3KId+1mMQsrA8z/136Md54dFQfXfox3nh0VB6MayHZz/" + + "/////////wEiSAocU2V0dGluZ1JlYWxzRnJvbVBvc2l0aXZlSW50czoo6dyi" + + "HQAAAAAAQGNA6dyiHQAAAAAAQGNA9d+jHQAAQEH136MdAABAQSJIChxTZXR0" + + "aW5nUmVhbHNGcm9tTmVnYXRpdmVJbnRzOijp3KIdAAAAAABAY8Dp3KIdAAAA" + + "AABAY8D136MdAABAwfXfox0AAEDBIisKEkNvbXBsZXhPcHRpb25UeXBlMRIL" + + "CgNmb28YASABKAUqCAhkEICAgIACIsECChJDb21wbGV4T3B0aW9uVHlwZTIS" + + "MgoDYmFyGAEgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlv" + + "blR5cGUxEgsKA2JhehgCIAEoBRJGCgRmcmVkGAMgASgLMjgucHJvdG9idWZf" + + "dW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUyLkNvbXBsZXhPcHRpb25UeXBl" + + "NBqXAQoSQ29tcGxleE9wdGlvblR5cGU0Eg0KBXdhbGRvGAEgASgFMnIKDGNv" + + "bXBsZXhfb3B0NBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiK" + + "9dEDIAEoCzI4LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBl" + + "Mi5Db21wbGV4T3B0aW9uVHlwZTQqCAhkEICAgIACIpwBChJDb21wbGV4T3B0" + + "aW9uVHlwZTMSCwoDcXV4GAEgASgFElQKEmNvbXBsZXhvcHRpb250eXBlNRgC" + + "IAEoCjI4LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMy5D" + + "b21wbGV4T3B0aW9uVHlwZTUaIwoSQ29tcGxleE9wdGlvblR5cGU1Eg0KBXBs" + + "dWdoGAMgASgFIh8KC0NvbXBsZXhPcHQ2EhAKBXh5enp5GN+/zwMgASgFItAB" + + "ChVWYXJpb3VzQ29tcGxleE9wdGlvbnM6tgHj3Pwc+P37HBjk3Pwc0qiPHQMI" + + "sw/63pAdAggJ+t6QHQQTGBYUqv2QHQMQ2weq/ZAdBvjmlx2OBar9kB0FCgMI" + + "5wWq/ZAdCAoG2IWeHc8Pqv2QHQoKCJL1nR0DCNgPqv2QHQjCrJcdAwjlBar9" + + "kB0LwqyXHQbYhZ4dzg+q/ZAdDcKslx0IkvWdHQMIyRCq/ZAdBRoDCMECouKV" + + "HQIIKqLilR0G2IWeHcQCouKVHQiS9Z0dAwjsBio2CgpNZXRob2RPcHQxEhMK" + + "D01FVEhPRE9QVDFfVkFMMRABEhMKD01FVEhPRE9QVDFfVkFMMhACMo4BChxU" + + "ZXN0U2VydmljZVdpdGhDdXN0b21PcHRpb25zEmMKA0ZvbxIpLnByb3RvYnVm" + + "X3VuaXR0ZXN0LkN1c3RvbU9wdGlvbkZvb1JlcXVlc3QaKi5wcm90b2J1Zl91" + + "bml0dGVzdC5DdXN0b21PcHRpb25Gb29SZXNwb25zZSIF4PqMHgIaCZCyix7T" + + "24DLSToyCglmaWxlX29wdDESHC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlv" + + "bnMYjp3YAyABKAQ6OAoMbWVzc2FnZV9vcHQxEh8uZ29vZ2xlLnByb3RvYnVm" + + "Lk1lc3NhZ2VPcHRpb25zGJyt2AMgASgFOjQKCmZpZWxkX29wdDESHS5nb29n" + + "bGUucHJvdG9idWYuRmllbGRPcHRpb25zGIi82AMgASgGOjgKCmZpZWxkX29w" + + "dDISHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGLmh2QMgASgFOgI0" + + "MjoyCgllbnVtX29wdDESHC5nb29nbGUucHJvdG9idWYuRW51bU9wdGlvbnMY" + + "6J7ZAyABKA86OAoMc2VydmljZV9vcHQxEh8uZ29vZ2xlLnByb3RvYnVmLlNl" + + "cnZpY2VPcHRpb25zGKK24QMgASgSOlUKC21ldGhvZF9vcHQxEh4uZ29vZ2xl" + + "LnByb3RvYnVmLk1ldGhvZE9wdGlvbnMYrM/hAyABKA4yHS5wcm90b2J1Zl91" + + "bml0dGVzdC5NZXRob2RPcHQxOjQKCGJvb2xfb3B0Eh8uZ29vZ2xlLnByb3Rv" + + "YnVmLk1lc3NhZ2VPcHRpb25zGOqr1gMgASgIOjUKCWludDMyX29wdBIfLmdv" + + "b2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjtqNYDIAEoBTo1CglpbnQ2" + + "NF9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYxqfWAyAB" + + "KAM6NgoKdWludDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0" + + "aW9ucxiwotYDIAEoDTo2Cgp1aW50NjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVm" + + "Lk1lc3NhZ2VPcHRpb25zGN+O1gMgASgEOjYKCnNpbnQzMl9vcHQSHy5nb29n" + + "bGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYwIjWAyABKBE6NgoKc2ludDY0" + + "X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxj/gtYDIAEo" + + "Ejo3CgtmaXhlZDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0" + + "aW9ucxjT/tUDIAEoBzo3CgtmaXhlZDY0X29wdBIfLmdvb2dsZS5wcm90b2J1" + + "Zi5NZXNzYWdlT3B0aW9ucxji/dUDIAEoBjo4CgxzZml4ZWQzMl9vcHQSHy5n" + + "b29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY1fHVAyABKA86OAoMc2Zp" + + "eGVkNjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGOOK" + + "1QMgASgQOjUKCWZsb2F0X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdl" + + "T3B0aW9ucxj+u9QDIAEoAjo2Cgpkb3VibGVfb3B0Eh8uZ29vZ2xlLnByb3Rv" + + "YnVmLk1lc3NhZ2VPcHRpb25zGM2r1AMgASgBOjYKCnN0cmluZ19vcHQSHy5n" + + "b29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYxavUAyABKAk6NQoJYnl0" + + "ZXNfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGJar1AMg" + + "ASgMOnAKCGVudW1fb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRp" + + "b25zGJGr1AMgASgOMjoucHJvdG9idWZfdW5pdHRlc3QuRHVtbXlNZXNzYWdl" + + "Q29udGFpbmluZ0VudW0uVGVzdEVudW1UeXBlOnAKEG1lc3NhZ2VfdHlwZV9v" + + "cHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYr/LTAyABKAsy" + + "Mi5wcm90b2J1Zl91bml0dGVzdC5EdW1teU1lc3NhZ2VJbnZhbGlkQXNPcHRp" + + "b25UeXBlOjYKBHF1dXgSJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0" + + "aW9uVHlwZTEY2+DTAyABKAU6XgoFY29yZ2USJS5wcm90b2J1Zl91bml0dGVz" + + "dC5Db21wbGV4T3B0aW9uVHlwZTEY0t7TAyABKAsyJS5wcm90b2J1Zl91bml0" + + "dGVzdC5Db21wbGV4T3B0aW9uVHlwZTM6OAoGZ3JhdWx0EiUucHJvdG9idWZf" + + "dW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUyGO/80gMgASgFOl8KBmdhcnBs" + + "eRIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMhjI9dID" + + "IAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMTpf" + + "Cgxjb21wbGV4X29wdDESHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlv" + + "bnMYpNzSAyABKAsyJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9u" + + "VHlwZTE6XwoMY29tcGxleF9vcHQyEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3Nh" + + "Z2VPcHRpb25zGNWP0gMgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxl" + + "eE9wdGlvblR5cGUyOl8KDGNvbXBsZXhfb3B0MxIfLmdvb2dsZS5wcm90b2J1" + + "Zi5NZXNzYWdlT3B0aW9ucxjvi9IDIAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0" + + "LkNvbXBsZXhPcHRpb25UeXBlMzpXCgtjb21wbGV4b3B0NhIfLmdvb2dsZS5w" + + "cm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjMy88DIAEoCjIeLnByb3RvYnVmX3Vu" + + "aXR0ZXN0LkNvbXBsZXhPcHQ2QlCC4gkhR29vZ2xlLlByb3RvY29sQnVmZmVy" + + "cy5UZXN0UHJvdG9ziuIJHlVuaXRUZXN0Q3VzdG9tT3B0aW9uc1Byb3RvRmls" + + "ZfDowR3qrcDlJA=="), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Extensions + public static readonly pb::GeneratedExtensionBase FileOpt1 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[0]); + public static readonly pb::GeneratedExtensionBase MessageOpt1 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[1]); + public static readonly pb::GeneratedExtensionBase FieldOpt1 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[2]); + public static readonly pb::GeneratedExtensionBase FieldOpt2 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[3]); + public static readonly pb::GeneratedExtensionBase EnumOpt1 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[4]); + public static readonly pb::GeneratedExtensionBase ServiceOpt1 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[5]); + public static readonly pb::GeneratedExtensionBase MethodOpt1 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[6]); + public static readonly pb::GeneratedExtensionBase BoolOpt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[7]); + public static readonly pb::GeneratedExtensionBase Int32Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[8]); + public static readonly pb::GeneratedExtensionBase Int64Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[9]); + public static readonly pb::GeneratedExtensionBase Uint32Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[10]); + public static readonly pb::GeneratedExtensionBase Uint64Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[11]); + public static readonly pb::GeneratedExtensionBase Sint32Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[12]); + public static readonly pb::GeneratedExtensionBase Sint64Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[13]); + public static readonly pb::GeneratedExtensionBase Fixed32Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[14]); + public static readonly pb::GeneratedExtensionBase Fixed64Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[15]); + public static readonly pb::GeneratedExtensionBase Sfixed32Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[16]); + public static readonly pb::GeneratedExtensionBase Sfixed64Opt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[17]); + public static readonly pb::GeneratedExtensionBase FloatOpt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[18]); + public static readonly pb::GeneratedExtensionBase DoubleOpt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[19]); + public static readonly pb::GeneratedExtensionBase StringOpt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[20]); + public static readonly pb::GeneratedExtensionBase BytesOpt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[21]); + public static readonly pb::GeneratedExtensionBase EnumOpt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[22]); + public static readonly pb::GeneratedExtensionBase MessageTypeOpt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[23]); + public static readonly pb::GeneratedExtensionBase Quux = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[24]); + public static readonly pb::GeneratedExtensionBase Corge = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[25]); + public static readonly pb::GeneratedExtensionBase Grault = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[26]); + public static readonly pb::GeneratedExtensionBase Garply = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[27]); + public static readonly pb::GeneratedExtensionBase ComplexOpt1 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[28]); + public static readonly pb::GeneratedExtensionBase ComplexOpt2 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[29]); + public static readonly pb::GeneratedExtensionBase ComplexOpt3 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[30]); + public static readonly pb::GeneratedExtensionBase ComplexOpt6 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[31]); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageWithCustomOptions__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestMessageWithCustomOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestMessageWithCustomOptions__Descriptor, + new string[] { "Field1", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionFooRequest__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_CustomOptionFooRequest__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_CustomOptionFooRequest__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionFooResponse__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_CustomOptionFooResponse__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_CustomOptionFooResponse__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_DummyMessageContainingEnum__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_DummyMessageContainingEnum__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_DummyMessageContainingEnum__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__Descriptor + = Descriptor.MessageTypes[4]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionMinIntegerValues__Descriptor + = Descriptor.MessageTypes[5]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_CustomOptionMinIntegerValues__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_CustomOptionMinIntegerValues__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__Descriptor + = Descriptor.MessageTypes[6]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionOtherValues__Descriptor + = Descriptor.MessageTypes[7]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_CustomOptionOtherValues__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_CustomOptionOtherValues__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_SettingRealsFromPositiveInts__Descriptor + = Descriptor.MessageTypes[8]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_SettingRealsFromPositiveInts__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_SettingRealsFromPositiveInts__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_SettingRealsFromNegativeInts__Descriptor + = Descriptor.MessageTypes[9]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_SettingRealsFromNegativeInts__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_SettingRealsFromNegativeInts__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType1__Descriptor + = Descriptor.MessageTypes[10]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_ComplexOptionType1__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_ComplexOptionType1__Descriptor, + new string[] { "Foo", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType2__Descriptor + = Descriptor.MessageTypes[11]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_ComplexOptionType2__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_ComplexOptionType2__Descriptor, + new string[] { "Bar", "Baz", "Fred", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__Descriptor + = internal__static_protobuf_unittest_ComplexOptionType2__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__Descriptor, + new string[] { "Waldo", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType3__Descriptor + = Descriptor.MessageTypes[12]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_ComplexOptionType3__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_ComplexOptionType3__Descriptor, + new string[] { "Qux", "ComplexOptionType5", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__Descriptor + = internal__static_protobuf_unittest_ComplexOptionType3__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__Descriptor, + new string[] { "Plugh", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOpt6__Descriptor + = Descriptor.MessageTypes[13]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_ComplexOpt6__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_ComplexOpt6__Descriptor, + new string[] { "Xyzzy", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_VariousComplexOptions__Descriptor + = Descriptor.MessageTypes[14]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_VariousComplexOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_VariousComplexOptions__Descriptor, + new string[] { }); + #endregion + } + #region Enums + public enum MethodOpt1 { + METHODOPT1_VAL1 = 1, + METHODOPT1_VAL2 = 2, + } + + #endregion + + #region Messages + public sealed partial class TestMessageWithCustomOptions : pb::GeneratedMessage { + private static readonly TestMessageWithCustomOptions defaultInstance = new Builder().BuildPartial(); + public static TestMessageWithCustomOptions DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageWithCustomOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageWithCustomOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_TestMessageWithCustomOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_TestMessageWithCustomOptions__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum AnEnum { + ANENUM_VAL1 = 1, + ANENUM_VAL2 = 2, + } + + } + #endregion + + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + public static TestMessageWithCustomOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageWithCustomOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageWithCustomOptions result = new TestMessageWithCustomOptions(); + + protected override TestMessageWithCustomOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageWithCustomOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageWithCustomOptions.Descriptor; } + } + + public override TestMessageWithCustomOptions DefaultInstanceForType { + get { return TestMessageWithCustomOptions.DefaultInstance; } + } + + public override TestMessageWithCustomOptions BuildPartial() { + TestMessageWithCustomOptions returnMe = result; + result = null; + return returnMe; + } + + + public bool HasField1 { + get { return result.HasField1; } + } + public string Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(string value) { + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + result.hasField1 = false; + result.field1_ = ""; + return this; + } + } + } + + public sealed partial class CustomOptionFooRequest : pb::GeneratedMessage { + private static readonly CustomOptionFooRequest defaultInstance = new Builder().BuildPartial(); + public static CustomOptionFooRequest DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionFooRequest DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionFooRequest ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionFooRequest__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionFooRequest__FieldAccessorTable; } + } + + public static CustomOptionFooRequest ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionFooRequest prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionFooRequest result = new CustomOptionFooRequest(); + + protected override CustomOptionFooRequest MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionFooRequest(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionFooRequest.Descriptor; } + } + + public override CustomOptionFooRequest DefaultInstanceForType { + get { return CustomOptionFooRequest.DefaultInstance; } + } + + public override CustomOptionFooRequest BuildPartial() { + CustomOptionFooRequest returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class CustomOptionFooResponse : pb::GeneratedMessage { + private static readonly CustomOptionFooResponse defaultInstance = new Builder().BuildPartial(); + public static CustomOptionFooResponse DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionFooResponse DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionFooResponse ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionFooResponse__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionFooResponse__FieldAccessorTable; } + } + + public static CustomOptionFooResponse ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionFooResponse prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionFooResponse result = new CustomOptionFooResponse(); + + protected override CustomOptionFooResponse MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionFooResponse(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionFooResponse.Descriptor; } + } + + public override CustomOptionFooResponse DefaultInstanceForType { + get { return CustomOptionFooResponse.DefaultInstance; } + } + + public override CustomOptionFooResponse BuildPartial() { + CustomOptionFooResponse returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class DummyMessageContainingEnum : pb::GeneratedMessage { + private static readonly DummyMessageContainingEnum defaultInstance = new Builder().BuildPartial(); + public static DummyMessageContainingEnum DefaultInstance { + get { return defaultInstance; } + } + + public override DummyMessageContainingEnum DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DummyMessageContainingEnum ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_DummyMessageContainingEnum__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_DummyMessageContainingEnum__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum TestEnumType { + TEST_OPTION_ENUM_TYPE1 = 22, + TEST_OPTION_ENUM_TYPE2 = -23, + } + + } + #endregion + + public static DummyMessageContainingEnum ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(DummyMessageContainingEnum prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DummyMessageContainingEnum result = new DummyMessageContainingEnum(); + + protected override DummyMessageContainingEnum MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DummyMessageContainingEnum(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return DummyMessageContainingEnum.Descriptor; } + } + + public override DummyMessageContainingEnum DefaultInstanceForType { + get { return DummyMessageContainingEnum.DefaultInstance; } + } + + public override DummyMessageContainingEnum BuildPartial() { + DummyMessageContainingEnum returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class DummyMessageInvalidAsOptionType : pb::GeneratedMessage { + private static readonly DummyMessageInvalidAsOptionType defaultInstance = new Builder().BuildPartial(); + public static DummyMessageInvalidAsOptionType DefaultInstance { + get { return defaultInstance; } + } + + public override DummyMessageInvalidAsOptionType DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DummyMessageInvalidAsOptionType ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__FieldAccessorTable; } + } + + public static DummyMessageInvalidAsOptionType ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(DummyMessageInvalidAsOptionType prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DummyMessageInvalidAsOptionType result = new DummyMessageInvalidAsOptionType(); + + protected override DummyMessageInvalidAsOptionType MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DummyMessageInvalidAsOptionType(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return DummyMessageInvalidAsOptionType.Descriptor; } + } + + public override DummyMessageInvalidAsOptionType DefaultInstanceForType { + get { return DummyMessageInvalidAsOptionType.DefaultInstance; } + } + + public override DummyMessageInvalidAsOptionType BuildPartial() { + DummyMessageInvalidAsOptionType returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class CustomOptionMinIntegerValues : pb::GeneratedMessage { + private static readonly CustomOptionMinIntegerValues defaultInstance = new Builder().BuildPartial(); + public static CustomOptionMinIntegerValues DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionMinIntegerValues DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionMinIntegerValues ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionMinIntegerValues__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionMinIntegerValues__FieldAccessorTable; } + } + + public static CustomOptionMinIntegerValues ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionMinIntegerValues prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionMinIntegerValues result = new CustomOptionMinIntegerValues(); + + protected override CustomOptionMinIntegerValues MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionMinIntegerValues(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionMinIntegerValues.Descriptor; } + } + + public override CustomOptionMinIntegerValues DefaultInstanceForType { + get { return CustomOptionMinIntegerValues.DefaultInstance; } + } + + public override CustomOptionMinIntegerValues BuildPartial() { + CustomOptionMinIntegerValues returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class CustomOptionMaxIntegerValues : pb::GeneratedMessage { + private static readonly CustomOptionMaxIntegerValues defaultInstance = new Builder().BuildPartial(); + public static CustomOptionMaxIntegerValues DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionMaxIntegerValues DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionMaxIntegerValues ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__FieldAccessorTable; } + } + + public static CustomOptionMaxIntegerValues ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionMaxIntegerValues prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionMaxIntegerValues result = new CustomOptionMaxIntegerValues(); + + protected override CustomOptionMaxIntegerValues MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionMaxIntegerValues(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionMaxIntegerValues.Descriptor; } + } + + public override CustomOptionMaxIntegerValues DefaultInstanceForType { + get { return CustomOptionMaxIntegerValues.DefaultInstance; } + } + + public override CustomOptionMaxIntegerValues BuildPartial() { + CustomOptionMaxIntegerValues returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class CustomOptionOtherValues : pb::GeneratedMessage { + private static readonly CustomOptionOtherValues defaultInstance = new Builder().BuildPartial(); + public static CustomOptionOtherValues DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionOtherValues DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionOtherValues ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionOtherValues__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionOtherValues__FieldAccessorTable; } + } + + public static CustomOptionOtherValues ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionOtherValues prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionOtherValues result = new CustomOptionOtherValues(); + + protected override CustomOptionOtherValues MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionOtherValues(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionOtherValues.Descriptor; } + } + + public override CustomOptionOtherValues DefaultInstanceForType { + get { return CustomOptionOtherValues.DefaultInstance; } + } + + public override CustomOptionOtherValues BuildPartial() { + CustomOptionOtherValues returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class SettingRealsFromPositiveInts : pb::GeneratedMessage { + private static readonly SettingRealsFromPositiveInts defaultInstance = new Builder().BuildPartial(); + public static SettingRealsFromPositiveInts DefaultInstance { + get { return defaultInstance; } + } + + public override SettingRealsFromPositiveInts DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override SettingRealsFromPositiveInts ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_SettingRealsFromPositiveInts__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_SettingRealsFromPositiveInts__FieldAccessorTable; } + } + + public static SettingRealsFromPositiveInts ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SettingRealsFromPositiveInts prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + SettingRealsFromPositiveInts result = new SettingRealsFromPositiveInts(); + + protected override SettingRealsFromPositiveInts MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new SettingRealsFromPositiveInts(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return SettingRealsFromPositiveInts.Descriptor; } + } + + public override SettingRealsFromPositiveInts DefaultInstanceForType { + get { return SettingRealsFromPositiveInts.DefaultInstance; } + } + + public override SettingRealsFromPositiveInts BuildPartial() { + SettingRealsFromPositiveInts returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class SettingRealsFromNegativeInts : pb::GeneratedMessage { + private static readonly SettingRealsFromNegativeInts defaultInstance = new Builder().BuildPartial(); + public static SettingRealsFromNegativeInts DefaultInstance { + get { return defaultInstance; } + } + + public override SettingRealsFromNegativeInts DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override SettingRealsFromNegativeInts ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_SettingRealsFromNegativeInts__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_SettingRealsFromNegativeInts__FieldAccessorTable; } + } + + public static SettingRealsFromNegativeInts ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SettingRealsFromNegativeInts prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + SettingRealsFromNegativeInts result = new SettingRealsFromNegativeInts(); + + protected override SettingRealsFromNegativeInts MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new SettingRealsFromNegativeInts(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return SettingRealsFromNegativeInts.Descriptor; } + } + + public override SettingRealsFromNegativeInts DefaultInstanceForType { + get { return SettingRealsFromNegativeInts.DefaultInstance; } + } + + public override SettingRealsFromNegativeInts BuildPartial() { + SettingRealsFromNegativeInts returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class ComplexOptionType1 : pb::ExtendableMessage { + private static readonly ComplexOptionType1 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType1 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType1 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType1__FieldAccessorTable; } + } + + private bool hasFoo; + private int foo_ = 0; + public bool HasFoo { + get { return hasFoo; } + } + public int Foo { + get { return foo_; } + } + + public static ComplexOptionType1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType1 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType1 result = new ComplexOptionType1(); + + protected override ComplexOptionType1 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType1(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType1.Descriptor; } + } + + public override ComplexOptionType1 DefaultInstanceForType { + get { return ComplexOptionType1.DefaultInstance; } + } + + public override ComplexOptionType1 BuildPartial() { + ComplexOptionType1 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasFoo { + get { return result.HasFoo; } + } + public int Foo { + get { return result.Foo; } + set { SetFoo(value); } + } + public Builder SetFoo(int value) { + result.hasFoo = true; + result.foo_ = value; + return this; + } + public Builder ClearFoo() { + result.hasFoo = false; + result.foo_ = 0; + return this; + } + } + } + + public sealed partial class ComplexOptionType2 : pb::ExtendableMessage { + private static readonly ComplexOptionType2 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType2 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType2 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType2 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType2__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType2__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class ComplexOptionType4 : pb::GeneratedMessage { + private static readonly ComplexOptionType4 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType4 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType4 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType4 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase ComplexOpt4 = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[0]); + private bool hasWaldo; + private int waldo_ = 0; + public bool HasWaldo { + get { return hasWaldo; } + } + public int Waldo { + get { return waldo_; } + } + + public static ComplexOptionType4 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType4 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType4 result = new ComplexOptionType4(); + + protected override ComplexOptionType4 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType4(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType4.Descriptor; } + } + + public override ComplexOptionType4 DefaultInstanceForType { + get { return ComplexOptionType4.DefaultInstance; } + } + + public override ComplexOptionType4 BuildPartial() { + ComplexOptionType4 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasWaldo { + get { return result.HasWaldo; } + } + public int Waldo { + get { return result.Waldo; } + set { SetWaldo(value); } + } + public Builder SetWaldo(int value) { + result.hasWaldo = true; + result.waldo_ = value; + return this; + } + public Builder ClearWaldo() { + result.hasWaldo = false; + result.waldo_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasBar; + private global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 bar_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.DefaultInstance; + public bool HasBar { + get { return hasBar; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 Bar { + get { return bar_; } + } + + private bool hasBaz; + private int baz_ = 0; + public bool HasBaz { + get { return hasBaz; } + } + public int Baz { + get { return baz_; } + } + + private bool hasFred; + private global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 fred_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.DefaultInstance; + public bool HasFred { + get { return hasFred; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 Fred { + get { return fred_; } + } + + public static ComplexOptionType2 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType2 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType2 result = new ComplexOptionType2(); + + protected override ComplexOptionType2 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType2(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType2.Descriptor; } + } + + public override ComplexOptionType2 DefaultInstanceForType { + get { return ComplexOptionType2.DefaultInstance; } + } + + public override ComplexOptionType2 BuildPartial() { + ComplexOptionType2 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasBar { + get { return result.HasBar; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 Bar { + get { return result.Bar; } + set { SetBar(value); } + } + public Builder SetBar(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 value) { + result.hasBar = true; + result.bar_ = value; + return this; + } + public Builder SetBar(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.Builder builderForValue) { + result.hasBar = true; + result.bar_ = builderForValue.Build(); + return this; + } + public Builder MergeBar(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 value) { + if (result.HasBar && + result.bar_ != global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.DefaultInstance) { + result.bar_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.CreateBuilder(result.bar_).MergeFrom(value).BuildPartial(); + } else { + result.bar_ = value; + } + result.hasBar = true; + return this; + } + public Builder ClearBar() { + result.hasBar = false; + result.bar_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.DefaultInstance; + return this; + } + + public bool HasBaz { + get { return result.HasBaz; } + } + public int Baz { + get { return result.Baz; } + set { SetBaz(value); } + } + public Builder SetBaz(int value) { + result.hasBaz = true; + result.baz_ = value; + return this; + } + public Builder ClearBaz() { + result.hasBaz = false; + result.baz_ = 0; + return this; + } + + public bool HasFred { + get { return result.HasFred; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 Fred { + get { return result.Fred; } + set { SetFred(value); } + } + public Builder SetFred(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 value) { + result.hasFred = true; + result.fred_ = value; + return this; + } + public Builder SetFred(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.Builder builderForValue) { + result.hasFred = true; + result.fred_ = builderForValue.Build(); + return this; + } + public Builder MergeFred(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 value) { + if (result.HasFred && + result.fred_ != global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.DefaultInstance) { + result.fred_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.CreateBuilder(result.fred_).MergeFrom(value).BuildPartial(); + } else { + result.fred_ = value; + } + result.hasFred = true; + return this; + } + public Builder ClearFred() { + result.hasFred = false; + result.fred_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.DefaultInstance; + return this; + } + } + } + + public sealed partial class ComplexOptionType3 : pb::GeneratedMessage { + private static readonly ComplexOptionType3 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType3 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType3 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType3 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType3__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType3__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class ComplexOptionType5 : pb::GeneratedMessage { + private static readonly ComplexOptionType5 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType5 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType5 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType5 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__FieldAccessorTable; } + } + + private bool hasPlugh; + private int plugh_ = 0; + public bool HasPlugh { + get { return hasPlugh; } + } + public int Plugh { + get { return plugh_; } + } + + public static ComplexOptionType5 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType5 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType5 result = new ComplexOptionType5(); + + protected override ComplexOptionType5 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType5(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType5.Descriptor; } + } + + public override ComplexOptionType5 DefaultInstanceForType { + get { return ComplexOptionType5.DefaultInstance; } + } + + public override ComplexOptionType5 BuildPartial() { + ComplexOptionType5 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasPlugh { + get { return result.HasPlugh; } + } + public int Plugh { + get { return result.Plugh; } + set { SetPlugh(value); } + } + public Builder SetPlugh(int value) { + result.hasPlugh = true; + result.plugh_ = value; + return this; + } + public Builder ClearPlugh() { + result.hasPlugh = false; + result.plugh_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasQux; + private int qux_ = 0; + public bool HasQux { + get { return hasQux; } + } + public int Qux { + get { return qux_; } + } + + private bool hasComplexOptionType5; + private global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 complexOptionType5_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.DefaultInstance; + public bool HasComplexOptionType5 { + get { return hasComplexOptionType5; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 ComplexOptionType5 { + get { return complexOptionType5_; } + } + + public static ComplexOptionType3 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType3 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType3 result = new ComplexOptionType3(); + + protected override ComplexOptionType3 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType3(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType3.Descriptor; } + } + + public override ComplexOptionType3 DefaultInstanceForType { + get { return ComplexOptionType3.DefaultInstance; } + } + + public override ComplexOptionType3 BuildPartial() { + ComplexOptionType3 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasQux { + get { return result.HasQux; } + } + public int Qux { + get { return result.Qux; } + set { SetQux(value); } + } + public Builder SetQux(int value) { + result.hasQux = true; + result.qux_ = value; + return this; + } + public Builder ClearQux() { + result.hasQux = false; + result.qux_ = 0; + return this; + } + + public bool HasComplexOptionType5 { + get { return result.HasComplexOptionType5; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 ComplexOptionType5 { + get { return result.ComplexOptionType5; } + set { SetComplexOptionType5(value); } + } + public Builder SetComplexOptionType5(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 value) { + result.hasComplexOptionType5 = true; + result.complexOptionType5_ = value; + return this; + } + public Builder SetComplexOptionType5(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.Builder builderForValue) { + result.hasComplexOptionType5 = true; + result.complexOptionType5_ = builderForValue.Build(); + return this; + } + public Builder MergeComplexOptionType5(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 value) { + if (result.HasComplexOptionType5 && + result.complexOptionType5_ != global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.DefaultInstance) { + result.complexOptionType5_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.CreateBuilder(result.complexOptionType5_).MergeFrom(value).BuildPartial(); + } else { + result.complexOptionType5_ = value; + } + result.hasComplexOptionType5 = true; + return this; + } + public Builder ClearComplexOptionType5() { + result.hasComplexOptionType5 = false; + result.complexOptionType5_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.DefaultInstance; + return this; + } + } + } + + public sealed partial class ComplexOpt6 : pb::GeneratedMessage { + private static readonly ComplexOpt6 defaultInstance = new Builder().BuildPartial(); + public static ComplexOpt6 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOpt6 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOpt6 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOpt6__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOpt6__FieldAccessorTable; } + } + + private bool hasXyzzy; + private int xyzzy_ = 0; + public bool HasXyzzy { + get { return hasXyzzy; } + } + public int Xyzzy { + get { return xyzzy_; } + } + + public static ComplexOpt6 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOpt6 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOpt6 result = new ComplexOpt6(); + + protected override ComplexOpt6 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOpt6(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOpt6.Descriptor; } + } + + public override ComplexOpt6 DefaultInstanceForType { + get { return ComplexOpt6.DefaultInstance; } + } + + public override ComplexOpt6 BuildPartial() { + ComplexOpt6 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasXyzzy { + get { return result.HasXyzzy; } + } + public int Xyzzy { + get { return result.Xyzzy; } + set { SetXyzzy(value); } + } + public Builder SetXyzzy(int value) { + result.hasXyzzy = true; + result.xyzzy_ = value; + return this; + } + public Builder ClearXyzzy() { + result.hasXyzzy = false; + result.xyzzy_ = 0; + return this; + } + } + } + + public sealed partial class VariousComplexOptions : pb::GeneratedMessage { + private static readonly VariousComplexOptions defaultInstance = new Builder().BuildPartial(); + public static VariousComplexOptions DefaultInstance { + get { return defaultInstance; } + } + + public override VariousComplexOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override VariousComplexOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_VariousComplexOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_VariousComplexOptions__FieldAccessorTable; } + } + + public static VariousComplexOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(VariousComplexOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + VariousComplexOptions result = new VariousComplexOptions(); + + protected override VariousComplexOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new VariousComplexOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return VariousComplexOptions.Descriptor; } + } + + public override VariousComplexOptions DefaultInstanceForType { + get { return VariousComplexOptions.DefaultInstance; } + } + + public override VariousComplexOptions BuildPartial() { + VariousComplexOptions returnMe = result; + result = null; + return returnMe; + } + + } + } + + #endregion + + #region Services + public abstract class TestServiceWithCustomOptions : pb::IService { + public abstract void Foo( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest request, + global::System.Action done); + + public static pbd::ServiceDescriptor Descriptor { + get { return UnitTestCustomOptionsProtoFile.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, (global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest) 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 global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest.DefaultInstance; + default: + throw new global::System.InvalidOperationException("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 global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.DefaultInstance; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public static Stub CreateStub(pb::IRpcChannel channel) { + return new Stub(channel); + } + + public class Stub : global::Google.ProtocolBuffers.TestProtos.TestServiceWithCustomOptions { + 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, + global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest request, + global::System.Action done) { + channel.CallMethod(Descriptor.Methods[0], + controller, request, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.DefaultInstance, + pb::RpcUtil.GeneralizeCallback(done, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.DefaultInstance)); + } + } + } + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs new file mode 100644 index 00000000..9dcbf1fe --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs @@ -0,0 +1,324 @@ +// 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; +namespace Google.ProtocolBuffers.TestProtos { + + public static partial class UnitTestEmbedOptimizeForProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "CjFnb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfZW1iZWRfb3B0aW1pemVfZm9y" + + "LnByb3RvEhFwcm90b2J1Zl91bml0dGVzdBokZ29vZ2xlL3Byb3RvYnVmL2Nz" + + "aGFycF9vcHRpb25zLnByb3RvGiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRv" + + "ci5wcm90bxorZ29vZ2xlL3Byb3RvYnVmL3VuaXR0ZXN0X29wdGltaXplX2Zv" + + "ci5wcm90byKhAQoZVGVzdEVtYmVkT3B0aW1pemVkRm9yU2l6ZRJBChBvcHRp" + + "b25hbF9tZXNzYWdlGAEgASgLMicucHJvdG9idWZfdW5pdHRlc3QuVGVzdE9w" + + "dGltaXplZEZvclNpemUSQQoQcmVwZWF0ZWRfbWVzc2FnZRgCIAMoCzInLnBy" + + "b3RvYnVmX3VuaXR0ZXN0LlRlc3RPcHRpbWl6ZWRGb3JTaXplQkxIAYLiCSFH" + + "b29nbGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQcm90b3OK4gkhVW5pdFRlc3RF" + + "bWJlZE9wdGltaXplRm9yUHJvdG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestEmbedOptimizedForSize__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor, + new string[] { "OptionalMessage", "RepeatedMessage", }); + #endregion + } + #region Messages + public sealed partial class TestEmbedOptimizedForSize : pb::GeneratedMessage { + private static readonly TestEmbedOptimizedForSize defaultInstance = new Builder().BuildPartial(); + public static TestEmbedOptimizedForSize DefaultInstance { + get { return defaultInstance; } + } + + public override TestEmbedOptimizedForSize DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestEmbedOptimizedForSize ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestEmbedOptimizeForProtoFile.internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestEmbedOptimizeForProtoFile.internal__static_protobuf_unittest_TestEmbedOptimizedForSize__FieldAccessorTable; } + } + + private bool hasOptionalMessage; + private global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance; + public bool HasOptionalMessage { + get { return hasOptionalMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize OptionalMessage { + get { return optionalMessage_; } + } + + private pbc::PopsicleList repeatedMessage_ = new pbc::PopsicleList(); + public scg::IList RepeatedMessageList { + get { return repeatedMessage_; } + } + public int RepeatedMessageCount { + get { return repeatedMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize GetRepeatedMessage(int index) { + return repeatedMessage_[index]; + } + + public override bool IsInitialized { + get { + if (HasOptionalMessage) { + if (!OptionalMessage.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) { + if (!element.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasOptionalMessage) { + output.WriteMessage(1, OptionalMessage); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) { + output.WriteMessage(2, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasOptionalMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(1, OptionalMessage); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestEmbedOptimizedForSize ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestEmbedOptimizedForSize prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestEmbedOptimizedForSize result = new TestEmbedOptimizedForSize(); + + protected override TestEmbedOptimizedForSize MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestEmbedOptimizedForSize(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestEmbedOptimizedForSize.Descriptor; } + } + + public override TestEmbedOptimizedForSize DefaultInstanceForType { + get { return TestEmbedOptimizedForSize.DefaultInstance; } + } + + public override TestEmbedOptimizedForSize BuildPartial() { + result.repeatedMessage_.MakeReadOnly(); + TestEmbedOptimizedForSize returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestEmbedOptimizedForSize) { + return MergeFrom((TestEmbedOptimizedForSize) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestEmbedOptimizedForSize other) { + if (other == TestEmbedOptimizedForSize.DefaultInstance) return this; + if (other.HasOptionalMessage) { + MergeOptionalMessage(other.OptionalMessage); + } + if (other.repeatedMessage_.Count != 0) { + base.AddRange(other.repeatedMessage_, result.repeatedMessage_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder(); + if (HasOptionalMessage) { + subBuilder.MergeFrom(OptionalMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalMessage = subBuilder.BuildPartial(); + break; + } + case 18: { + global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedMessage(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public bool HasOptionalMessage { + get { return result.HasOptionalMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize OptionalMessage { + get { return result.OptionalMessage; } + set { SetOptionalMessage(value); } + } + public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) { + result.hasOptionalMessage = true; + result.optionalMessage_ = value; + return this; + } + public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) { + result.hasOptionalMessage = true; + result.optionalMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) { + if (result.HasOptionalMessage && + result.optionalMessage_ != global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance) { + result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder(result.optionalMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalMessage_ = value; + } + result.hasOptionalMessage = true; + return this; + } + public Builder ClearOptionalMessage() { + result.hasOptionalMessage = false; + result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance; + return this; + } + + public scg::IList RepeatedMessageList { + get { return result.repeatedMessage_; } + } + public int RepeatedMessageCount { + get { return result.RepeatedMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize GetRepeatedMessage(int index) { + return result.GetRepeatedMessage(index); + } + public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) { + result.repeatedMessage_[index] = value; + return this; + } + public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) { + result.repeatedMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) { + result.repeatedMessage_.Add(value); + return this; + } + public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) { + result.repeatedMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedMessage(scg::IEnumerable values) { + base.AddRange(values, result.repeatedMessage_); + return this; + } + public Builder ClearRepeatedMessage() { + result.repeatedMessage_.Clear(); + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs new file mode 100644 index 00000000..c8f5bef2 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs @@ -0,0 +1,243 @@ +// 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; +namespace Google.ProtocolBuffers.TestProtos { + + public static partial class UnitTestImportProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "CiVnb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfaW1wb3J0LnByb3RvEhhwcm90" + + "b2J1Zl91bml0dGVzdF9pbXBvcnQaJGdvb2dsZS9wcm90b2J1Zi9jc2hhcnBf" + + "b3B0aW9ucy5wcm90bxogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJv" + + "dG8iGgoNSW1wb3J0TWVzc2FnZRIJCgFkGAEgASgFKjwKCkltcG9ydEVudW0S" + + "DgoKSU1QT1JUX0ZPTxAHEg4KCklNUE9SVF9CQVIQCBIOCgpJTVBPUlRfQkFa" + + "EAlCXAoYY29tLmdvb2dsZS5wcm90b2J1Zi50ZXN0SAGC4gkhR29vZ2xlLlBy" + + "b3RvY29sQnVmZmVycy5UZXN0UHJvdG9ziuIJF1VuaXRUZXN0SW1wb3J0UHJv" + + "dG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_import_ImportMessage__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_import_ImportMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_import_ImportMessage__Descriptor, + new string[] { "D", }); + #endregion + } + #region Enums + public enum ImportEnum { + IMPORT_FOO = 7, + IMPORT_BAR = 8, + IMPORT_BAZ = 9, + } + + #endregion + + #region Messages + public sealed partial class ImportMessage : pb::GeneratedMessage { + private static readonly ImportMessage defaultInstance = new Builder().BuildPartial(); + public static ImportMessage DefaultInstance { + get { return defaultInstance; } + } + + public override ImportMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ImportMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.internal__static_protobuf_unittest_import_ImportMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.internal__static_protobuf_unittest_import_ImportMessage__FieldAccessorTable; } + } + + private bool hasD; + private int d_ = 0; + public bool HasD { + get { return hasD; } + } + public int D { + get { return d_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasD) { + output.WriteInt32(1, D); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasD) { + size += pb::CodedOutputStream.ComputeInt32Size(1, D); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ImportMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ImportMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ImportMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ImportMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ImportMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ImportMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ImportMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ImportMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ImportMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ImportMessage result = new ImportMessage(); + + protected override ImportMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ImportMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ImportMessage.Descriptor; } + } + + public override ImportMessage DefaultInstanceForType { + get { return ImportMessage.DefaultInstance; } + } + + public override ImportMessage BuildPartial() { + ImportMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ImportMessage) { + return MergeFrom((ImportMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ImportMessage other) { + if (other == ImportMessage.DefaultInstance) return this; + if (other.HasD) { + D = other.D; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + D = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasD { + get { return result.HasD; } + } + public int D { + get { return result.D; } + set { SetD(value); } + } + public Builder SetD(int value) { + result.hasD = true; + result.d_ = value; + return this; + } + public Builder ClearD() { + result.hasD = false; + result.d_ = 0; + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs new file mode 100644 index 00000000..72b06d33 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs @@ -0,0 +1,1284 @@ +// 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; +namespace Google.ProtocolBuffers.TestProtos { + + public static partial class UnitTestMessageSetProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "CiNnb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfbXNldC5wcm90bxIRcHJvdG9i" + + "dWZfdW5pdHRlc3QaJGdvb2dsZS9wcm90b2J1Zi9jc2hhcnBfb3B0aW9ucy5w" + + "cm90bxogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG8iHgoOVGVz" + + "dE1lc3NhZ2VTZXQqCAgEEICAgIACOgIIASJRChdUZXN0TWVzc2FnZVNldENv" + + "bnRhaW5lchI2CgttZXNzYWdlX3NldBgBIAEoCzIhLnByb3RvYnVmX3VuaXR0" + + "ZXN0LlRlc3RNZXNzYWdlU2V0IpYBChhUZXN0TWVzc2FnZVNldEV4dGVuc2lv" + + "bjESCQoBaRgPIAEoBTJvChVtZXNzYWdlX3NldF9leHRlbnNpb24SIS5wcm90" + + "b2J1Zl91bml0dGVzdC5UZXN0TWVzc2FnZVNldBiwpl4gASgLMisucHJvdG9i" + + "dWZfdW5pdHRlc3QuVGVzdE1lc3NhZ2VTZXRFeHRlbnNpb24xIpgBChhUZXN0" + + "TWVzc2FnZVNldEV4dGVuc2lvbjISCwoDc3RyGBkgASgJMm8KFW1lc3NhZ2Vf" + + "c2V0X2V4dGVuc2lvbhIhLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RNZXNzYWdl" + + "U2V0GPm7XiABKAsyKy5wcm90b2J1Zl91bml0dGVzdC5UZXN0TWVzc2FnZVNl" + + "dEV4dGVuc2lvbjIibgoNUmF3TWVzc2FnZVNldBIzCgRpdGVtGAEgAygKMiUu" + + "cHJvdG9idWZfdW5pdHRlc3QuUmF3TWVzc2FnZVNldC5JdGVtGigKBEl0ZW0S" + + "DwoHdHlwZV9pZBgCIAIoBRIPCgdtZXNzYWdlGAMgAigMQkZIAYLiCSFHb29n" + + "bGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQcm90b3OK4gkbVW5pdFRlc3RNZXNz" + + "YWdlU2V0UHJvdG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageSet__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestMessageSet__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestMessageSet__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageSetContainer__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestMessageSetContainer__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestMessageSetContainer__Descriptor, + new string[] { "MessageSet", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageSetExtension1__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestMessageSetExtension1__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestMessageSetExtension1__Descriptor, + new string[] { "I", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageSetExtension2__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestMessageSetExtension2__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestMessageSetExtension2__Descriptor, + new string[] { "Str", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_RawMessageSet__Descriptor + = Descriptor.MessageTypes[4]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_RawMessageSet__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_RawMessageSet__Descriptor, + new string[] { "Item", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_RawMessageSet_Item__Descriptor + = internal__static_protobuf_unittest_RawMessageSet__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_RawMessageSet_Item__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_RawMessageSet_Item__Descriptor, + new string[] { "TypeId", "Message", }); + #endregion + } + #region Messages + public sealed partial class TestMessageSet : pb::ExtendableMessage { + private static readonly TestMessageSet defaultInstance = new Builder().BuildPartial(); + public static TestMessageSet DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSet__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteAsMessageSetTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSizeAsMessageSet; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessageSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageSet result = new TestMessageSet(); + + protected override TestMessageSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageSet.Descriptor; } + } + + public override TestMessageSet DefaultInstanceForType { + get { return TestMessageSet.DefaultInstance; } + } + + public override TestMessageSet BuildPartial() { + TestMessageSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessageSet) { + return MergeFrom((TestMessageSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessageSet other) { + if (other == TestMessageSet.DefaultInstance) return this; + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class TestMessageSetContainer : pb::GeneratedMessage { + private static readonly TestMessageSetContainer defaultInstance = new Builder().BuildPartial(); + public static TestMessageSetContainer DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageSetContainer DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageSetContainer ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetContainer__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetContainer__FieldAccessorTable; } + } + + private bool hasMessageSet; + private global::Google.ProtocolBuffers.TestProtos.TestMessageSet messageSet_ = global::Google.ProtocolBuffers.TestProtos.TestMessageSet.DefaultInstance; + public bool HasMessageSet { + get { return hasMessageSet; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMessageSet MessageSet { + get { return messageSet_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasMessageSet) { + output.WriteMessage(1, MessageSet); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasMessageSet) { + size += pb::CodedOutputStream.ComputeMessageSize(1, MessageSet); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessageSetContainer ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageSetContainer prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageSetContainer result = new TestMessageSetContainer(); + + protected override TestMessageSetContainer MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageSetContainer(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageSetContainer.Descriptor; } + } + + public override TestMessageSetContainer DefaultInstanceForType { + get { return TestMessageSetContainer.DefaultInstance; } + } + + public override TestMessageSetContainer BuildPartial() { + TestMessageSetContainer returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessageSetContainer) { + return MergeFrom((TestMessageSetContainer) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessageSetContainer other) { + if (other == TestMessageSetContainer.DefaultInstance) return this; + if (other.HasMessageSet) { + MergeMessageSet(other.MessageSet); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestMessageSet.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestMessageSet.CreateBuilder(); + if (HasMessageSet) { + subBuilder.MergeFrom(MessageSet); + } + input.ReadMessage(subBuilder, extensionRegistry); + MessageSet = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasMessageSet { + get { return result.HasMessageSet; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMessageSet MessageSet { + get { return result.MessageSet; } + set { SetMessageSet(value); } + } + public Builder SetMessageSet(global::Google.ProtocolBuffers.TestProtos.TestMessageSet value) { + result.hasMessageSet = true; + result.messageSet_ = value; + return this; + } + public Builder SetMessageSet(global::Google.ProtocolBuffers.TestProtos.TestMessageSet.Builder builderForValue) { + result.hasMessageSet = true; + result.messageSet_ = builderForValue.Build(); + return this; + } + public Builder MergeMessageSet(global::Google.ProtocolBuffers.TestProtos.TestMessageSet value) { + if (result.HasMessageSet && + result.messageSet_ != global::Google.ProtocolBuffers.TestProtos.TestMessageSet.DefaultInstance) { + result.messageSet_ = global::Google.ProtocolBuffers.TestProtos.TestMessageSet.CreateBuilder(result.messageSet_).MergeFrom(value).BuildPartial(); + } else { + result.messageSet_ = value; + } + result.hasMessageSet = true; + return this; + } + public Builder ClearMessageSet() { + result.hasMessageSet = false; + result.messageSet_ = global::Google.ProtocolBuffers.TestProtos.TestMessageSet.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestMessageSetExtension1 : pb::GeneratedMessage { + private static readonly TestMessageSetExtension1 defaultInstance = new Builder().BuildPartial(); + public static TestMessageSetExtension1 DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageSetExtension1 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageSetExtension1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetExtension1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetExtension1__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase MessageSetExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[0]); + private bool hasI; + private int i_ = 0; + public bool HasI { + get { return hasI; } + } + public int I { + get { return i_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasI) { + output.WriteInt32(15, I); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasI) { + size += pb::CodedOutputStream.ComputeInt32Size(15, I); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessageSetExtension1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageSetExtension1 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageSetExtension1 result = new TestMessageSetExtension1(); + + protected override TestMessageSetExtension1 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageSetExtension1(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageSetExtension1.Descriptor; } + } + + public override TestMessageSetExtension1 DefaultInstanceForType { + get { return TestMessageSetExtension1.DefaultInstance; } + } + + public override TestMessageSetExtension1 BuildPartial() { + TestMessageSetExtension1 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessageSetExtension1) { + return MergeFrom((TestMessageSetExtension1) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessageSetExtension1 other) { + if (other == TestMessageSetExtension1.DefaultInstance) return this; + if (other.HasI) { + I = other.I; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 120: { + I = input.ReadInt32(); + break; + } + } + } + } + + + 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; + } + } + } + + public sealed partial class TestMessageSetExtension2 : pb::GeneratedMessage { + private static readonly TestMessageSetExtension2 defaultInstance = new Builder().BuildPartial(); + public static TestMessageSetExtension2 DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageSetExtension2 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageSetExtension2 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetExtension2__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetExtension2__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase MessageSetExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[0]); + private bool hasStr; + private string str_ = ""; + public bool HasStr { + get { return hasStr; } + } + public string Str { + get { return str_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasStr) { + output.WriteString(25, Str); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasStr) { + size += pb::CodedOutputStream.ComputeStringSize(25, Str); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessageSetExtension2 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageSetExtension2 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageSetExtension2 result = new TestMessageSetExtension2(); + + protected override TestMessageSetExtension2 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageSetExtension2(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageSetExtension2.Descriptor; } + } + + public override TestMessageSetExtension2 DefaultInstanceForType { + get { return TestMessageSetExtension2.DefaultInstance; } + } + + public override TestMessageSetExtension2 BuildPartial() { + TestMessageSetExtension2 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessageSetExtension2) { + return MergeFrom((TestMessageSetExtension2) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessageSetExtension2 other) { + if (other == TestMessageSetExtension2.DefaultInstance) return this; + if (other.HasStr) { + Str = other.Str; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 202: { + Str = input.ReadString(); + break; + } + } + } + } + + + public bool HasStr { + get { return result.HasStr; } + } + public string Str { + get { return result.Str; } + set { SetStr(value); } + } + public Builder SetStr(string value) { + result.hasStr = true; + result.str_ = value; + return this; + } + public Builder ClearStr() { + result.hasStr = false; + result.str_ = ""; + return this; + } + } + } + + public sealed partial class RawMessageSet : pb::GeneratedMessage { + private static readonly RawMessageSet defaultInstance = new Builder().BuildPartial(); + public static RawMessageSet DefaultInstance { + get { return defaultInstance; } + } + + public override RawMessageSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override RawMessageSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_RawMessageSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_RawMessageSet__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class Item : pb::GeneratedMessage { + private static readonly Item defaultInstance = new Builder().BuildPartial(); + public static Item DefaultInstance { + get { return defaultInstance; } + } + + public override Item DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Item ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_RawMessageSet_Item__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_RawMessageSet_Item__FieldAccessorTable; } + } + + private bool hasTypeId; + private int typeId_ = 0; + public bool HasTypeId { + get { return hasTypeId; } + } + public int TypeId { + get { return typeId_; } + } + + private bool hasMessage; + private pb::ByteString message_ = pb::ByteString.Empty; + public bool HasMessage { + get { return hasMessage; } + } + public pb::ByteString Message { + get { return message_; } + } + + public override bool IsInitialized { + get { + if (!hasTypeId) return false; + if (!hasMessage) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasTypeId) { + output.WriteInt32(2, TypeId); + } + if (HasMessage) { + output.WriteBytes(3, Message); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasTypeId) { + size += pb::CodedOutputStream.ComputeInt32Size(2, TypeId); + } + if (HasMessage) { + size += pb::CodedOutputStream.ComputeBytesSize(3, Message); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Item ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Item ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Item ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Item ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Item ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Item ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Item ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Item ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Item prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Item result = new Item(); + + protected override Item MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Item(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Item.Descriptor; } + } + + public override Item DefaultInstanceForType { + get { return Item.DefaultInstance; } + } + + public override Item BuildPartial() { + Item returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Item) { + return MergeFrom((Item) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Item other) { + if (other == Item.DefaultInstance) return this; + if (other.HasTypeId) { + TypeId = other.TypeId; + } + if (other.HasMessage) { + Message = other.Message; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 16: { + TypeId = input.ReadInt32(); + break; + } + case 26: { + Message = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasTypeId { + get { return result.HasTypeId; } + } + public int TypeId { + get { return result.TypeId; } + set { SetTypeId(value); } + } + public Builder SetTypeId(int value) { + result.hasTypeId = true; + result.typeId_ = value; + return this; + } + public Builder ClearTypeId() { + result.hasTypeId = false; + result.typeId_ = 0; + return this; + } + + public bool HasMessage { + get { return result.HasMessage; } + } + public pb::ByteString Message { + get { return result.Message; } + set { SetMessage(value); } + } + public Builder SetMessage(pb::ByteString value) { + result.hasMessage = true; + result.message_ = value; + return this; + } + public Builder ClearMessage() { + result.hasMessage = false; + result.message_ = pb::ByteString.Empty; + return this; + } + } + } + + } + #endregion + + private pbc::PopsicleList item_ = new pbc::PopsicleList(); + public scg::IList ItemList { + get { return item_; } + } + public int ItemCount { + get { return item_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item GetItem(int index) { + return item_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item element in ItemList) { + output.WriteGroup(1, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item element in ItemList) { + size += pb::CodedOutputStream.ComputeGroupSize(1, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static RawMessageSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RawMessageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RawMessageSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RawMessageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RawMessageSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RawMessageSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static RawMessageSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RawMessageSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(RawMessageSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + RawMessageSet result = new RawMessageSet(); + + protected override RawMessageSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new RawMessageSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return RawMessageSet.Descriptor; } + } + + public override RawMessageSet DefaultInstanceForType { + get { return RawMessageSet.DefaultInstance; } + } + + public override RawMessageSet BuildPartial() { + result.item_.MakeReadOnly(); + RawMessageSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is RawMessageSet) { + return MergeFrom((RawMessageSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(RawMessageSet other) { + if (other == RawMessageSet.DefaultInstance) return this; + if (other.item_.Count != 0) { + base.AddRange(other.item_, result.item_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 11: { + global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.CreateBuilder(); + input.ReadGroup(1, subBuilder, extensionRegistry); + AddItem(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList ItemList { + get { return result.item_; } + } + public int ItemCount { + get { return result.ItemCount; } + } + public global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item GetItem(int index) { + return result.GetItem(index); + } + public Builder SetItem(int index, global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item value) { + result.item_[index] = value; + return this; + } + public Builder SetItem(int index, global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.Builder builderForValue) { + result.item_[index] = builderForValue.Build(); + return this; + } + public Builder AddItem(global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item value) { + result.item_.Add(value); + return this; + } + public Builder AddItem(global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.Builder builderForValue) { + result.item_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeItem(scg::IEnumerable values) { + base.AddRange(values, result.item_); + return this; + } + public Builder ClearItem() { + result.item_.Clear(); + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs new file mode 100644 index 00000000..135e7a2f --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs @@ -0,0 +1,467 @@ +// 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; +namespace Google.ProtocolBuffers.TestProtos { + + public static partial class UnitTestOptimizeForProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "Citnb29nbGUvcHJvdG9idWYvdW5pdHRlc3Rfb3B0aW1pemVfZm9yLnByb3Rv" + + "EhFwcm90b2J1Zl91bml0dGVzdBokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9v" + + "cHRpb25zLnByb3RvGiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90" + + "bxoeZ29vZ2xlL3Byb3RvYnVmL3VuaXR0ZXN0LnByb3RvIp4BChRUZXN0T3B0" + + "aW1pemVkRm9yU2l6ZRIJCgFpGAEgASgFEi4KA21zZxgTIAEoCzIhLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LkZvcmVpZ25NZXNzYWdlKgkI6AcQgICAgAIyQAoOdGVz" + + "dF9leHRlbnNpb24SJy5wcm90b2J1Zl91bml0dGVzdC5UZXN0T3B0aW1pemVk" + + "Rm9yU2l6ZRjSCSABKAUiKQocVGVzdFJlcXVpcmVkT3B0aW1pemVkRm9yU2l6" + + "ZRIJCgF4GAEgAigFIloKHFRlc3RPcHRpb25hbE9wdGltaXplZEZvclNpemUS" + + "OgoBbxgBIAEoCzIvLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RSZXF1aXJlZE9w" + + "dGltaXplZEZvclNpemVCR0gCguIJIUdvb2dsZS5Qcm90b2NvbEJ1ZmZlcnMu" + + "VGVzdFByb3Rvc4riCRxVbml0VGVzdE9wdGltaXplRm9yUHJvdG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestOptimizedForSize__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor, + new string[] { "I", "Msg", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestRequiredOptimizedForSize__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor, + new string[] { "X", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestOptionalOptimizedForSize__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor, + new string[] { "O", }); + #endregion + } + #region Messages + public sealed partial class TestOptimizedForSize : pb::ExtendableMessage { + private static readonly TestOptimizedForSize defaultInstance = new Builder().BuildPartial(); + public static TestOptimizedForSize DefaultInstance { + get { return defaultInstance; } + } + + public override TestOptimizedForSize DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestOptimizedForSize ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptimizedForSize__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase TestExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[0]); + private bool hasI; + private int i_ = 0; + public bool HasI { + get { return hasI; } + } + public int I { + get { return i_; } + } + + private bool hasMsg; + private global::Google.ProtocolBuffers.TestProtos.ForeignMessage msg_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + public bool HasMsg { + get { return hasMsg; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage Msg { + get { return msg_; } + } + + public static TestOptimizedForSize ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestOptimizedForSize prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestOptimizedForSize result = new TestOptimizedForSize(); + + protected override TestOptimizedForSize MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestOptimizedForSize(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestOptimizedForSize.Descriptor; } + } + + public override TestOptimizedForSize DefaultInstanceForType { + get { return TestOptimizedForSize.DefaultInstance; } + } + + public override TestOptimizedForSize BuildPartial() { + TestOptimizedForSize returnMe = result; + result = null; + return returnMe; + } + + + 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; + } + + public bool HasMsg { + get { return result.HasMsg; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage Msg { + get { return result.Msg; } + set { SetMsg(value); } + } + public Builder SetMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.hasMsg = true; + result.msg_ = value; + return this; + } + public Builder SetMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.hasMsg = true; + result.msg_ = builderForValue.Build(); + return this; + } + public Builder MergeMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + if (result.HasMsg && + result.msg_ != global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance) { + result.msg_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(result.msg_).MergeFrom(value).BuildPartial(); + } else { + result.msg_ = value; + } + result.hasMsg = true; + return this; + } + public Builder ClearMsg() { + result.hasMsg = false; + result.msg_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestRequiredOptimizedForSize : pb::GeneratedMessage { + private static readonly TestRequiredOptimizedForSize defaultInstance = new Builder().BuildPartial(); + public static TestRequiredOptimizedForSize DefaultInstance { + get { return defaultInstance; } + } + + public override TestRequiredOptimizedForSize DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestRequiredOptimizedForSize ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestRequiredOptimizedForSize__FieldAccessorTable; } + } + + private bool hasX; + private int x_ = 0; + public bool HasX { + get { return hasX; } + } + public int X { + get { return x_; } + } + + public static TestRequiredOptimizedForSize ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestRequiredOptimizedForSize prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestRequiredOptimizedForSize result = new TestRequiredOptimizedForSize(); + + protected override TestRequiredOptimizedForSize MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestRequiredOptimizedForSize(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestRequiredOptimizedForSize.Descriptor; } + } + + public override TestRequiredOptimizedForSize DefaultInstanceForType { + get { return TestRequiredOptimizedForSize.DefaultInstance; } + } + + public override TestRequiredOptimizedForSize BuildPartial() { + TestRequiredOptimizedForSize returnMe = result; + result = null; + return returnMe; + } + + + public bool HasX { + get { return result.HasX; } + } + public int X { + get { return result.X; } + set { SetX(value); } + } + public Builder SetX(int value) { + result.hasX = true; + result.x_ = value; + return this; + } + public Builder ClearX() { + result.hasX = false; + result.x_ = 0; + return this; + } + } + } + + public sealed partial class TestOptionalOptimizedForSize : pb::GeneratedMessage { + private static readonly TestOptionalOptimizedForSize defaultInstance = new Builder().BuildPartial(); + public static TestOptionalOptimizedForSize DefaultInstance { + get { return defaultInstance; } + } + + public override TestOptionalOptimizedForSize DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestOptionalOptimizedForSize ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptionalOptimizedForSize__FieldAccessorTable; } + } + + private bool hasO; + private global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize o_ = global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance; + public bool HasO { + get { return hasO; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize O { + get { return o_; } + } + + public static TestOptionalOptimizedForSize ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestOptionalOptimizedForSize prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestOptionalOptimizedForSize result = new TestOptionalOptimizedForSize(); + + protected override TestOptionalOptimizedForSize MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestOptionalOptimizedForSize(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestOptionalOptimizedForSize.Descriptor; } + } + + public override TestOptionalOptimizedForSize DefaultInstanceForType { + get { return TestOptionalOptimizedForSize.DefaultInstance; } + } + + public override TestOptionalOptimizedForSize BuildPartial() { + TestOptionalOptimizedForSize returnMe = result; + result = null; + return returnMe; + } + + + public bool HasO { + get { return result.HasO; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize O { + get { return result.O; } + set { SetO(value); } + } + public Builder SetO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize value) { + result.hasO = true; + result.o_ = value; + return this; + } + public Builder SetO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.Builder builderForValue) { + result.hasO = true; + result.o_ = builderForValue.Build(); + return this; + } + public Builder MergeO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize value) { + if (result.HasO && + result.o_ != global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance) { + result.o_ = global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.CreateBuilder(result.o_).MergeFrom(value).BuildPartial(); + } else { + result.o_ = value; + } + result.hasO = true; + return this; + } + public Builder ClearO() { + result.hasO = false; + result.o_ = global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance; + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs new file mode 100644 index 00000000..9e706b02 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs @@ -0,0 +1,11835 @@ +// 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; +namespace Google.ProtocolBuffers.TestProtos { + + public static partial class UnitTestProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "Ch5nb29nbGUvcHJvdG9idWYvdW5pdHRlc3QucHJvdG8SEXByb3RvYnVmX3Vu" + + "aXR0ZXN0GiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8a" + + "IGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlwdG9yLnByb3RvGiVnb29nbGUvcHJv" + + "dG9idWYvdW5pdHRlc3RfaW1wb3J0LnByb3RvIrsVCgxUZXN0QWxsVHlwZXMS" + + "FgoOb3B0aW9uYWxfaW50MzIYASABKAUSFgoOb3B0aW9uYWxfaW50NjQYAiAB" + + "KAMSFwoPb3B0aW9uYWxfdWludDMyGAMgASgNEhcKD29wdGlvbmFsX3VpbnQ2" + + "NBgEIAEoBBIXCg9vcHRpb25hbF9zaW50MzIYBSABKBESFwoPb3B0aW9uYWxf" + + "c2ludDY0GAYgASgSEhgKEG9wdGlvbmFsX2ZpeGVkMzIYByABKAcSGAoQb3B0" + + "aW9uYWxfZml4ZWQ2NBgIIAEoBhIZChFvcHRpb25hbF9zZml4ZWQzMhgJIAEo" + + "DxIZChFvcHRpb25hbF9zZml4ZWQ2NBgKIAEoEBIWCg5vcHRpb25hbF9mbG9h" + + "dBgLIAEoAhIXCg9vcHRpb25hbF9kb3VibGUYDCABKAESFQoNb3B0aW9uYWxf" + + "Ym9vbBgNIAEoCBIXCg9vcHRpb25hbF9zdHJpbmcYDiABKAkSFgoOb3B0aW9u" + + "YWxfYnl0ZXMYDyABKAwSRAoNb3B0aW9uYWxncm91cBgQIAEoCjItLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlcy5PcHRpb25hbEdyb3VwEk4KF29w" + + "dGlvbmFsX25lc3RlZF9tZXNzYWdlGBIgASgLMi0ucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbFR5cGVzLk5lc3RlZE1lc3NhZ2USQwoYb3B0aW9uYWxfZm9y" + + "ZWlnbl9tZXNzYWdlGBMgASgLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWln" + + "bk1lc3NhZ2USSAoXb3B0aW9uYWxfaW1wb3J0X21lc3NhZ2UYFCABKAsyJy5w" + + "cm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0TWVzc2FnZRJIChRvcHRp" + + "b25hbF9uZXN0ZWRfZW51bRgVIAEoDjIqLnByb3RvYnVmX3VuaXR0ZXN0LlRl" + + "c3RBbGxUeXBlcy5OZXN0ZWRFbnVtEj0KFW9wdGlvbmFsX2ZvcmVpZ25fZW51" + + "bRgWIAEoDjIeLnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25FbnVtEkIKFG9w" + + "dGlvbmFsX2ltcG9ydF9lbnVtGBcgASgOMiQucHJvdG9idWZfdW5pdHRlc3Rf" + + "aW1wb3J0LkltcG9ydEVudW0SIQoVb3B0aW9uYWxfc3RyaW5nX3BpZWNlGBgg" + + "ASgJQgIIAhIZCg1vcHRpb25hbF9jb3JkGBkgASgJQgIIARIWCg5yZXBlYXRl" + + "ZF9pbnQzMhgfIAMoBRIWCg5yZXBlYXRlZF9pbnQ2NBggIAMoAxIXCg9yZXBl" + + "YXRlZF91aW50MzIYISADKA0SFwoPcmVwZWF0ZWRfdWludDY0GCIgAygEEhcK" + + "D3JlcGVhdGVkX3NpbnQzMhgjIAMoERIXCg9yZXBlYXRlZF9zaW50NjQYJCAD" + + "KBISGAoQcmVwZWF0ZWRfZml4ZWQzMhglIAMoBxIYChByZXBlYXRlZF9maXhl" + + "ZDY0GCYgAygGEhkKEXJlcGVhdGVkX3NmaXhlZDMyGCcgAygPEhkKEXJlcGVh" + + "dGVkX3NmaXhlZDY0GCggAygQEhYKDnJlcGVhdGVkX2Zsb2F0GCkgAygCEhcK" + + "D3JlcGVhdGVkX2RvdWJsZRgqIAMoARIVCg1yZXBlYXRlZF9ib29sGCsgAygI" + + "EhcKD3JlcGVhdGVkX3N0cmluZxgsIAMoCRIWCg5yZXBlYXRlZF9ieXRlcxgt" + + "IAMoDBJECg1yZXBlYXRlZGdyb3VwGC4gAygKMi0ucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbFR5cGVzLlJlcGVhdGVkR3JvdXASTgoXcmVwZWF0ZWRfbmVz" + + "dGVkX21lc3NhZ2UYMCADKAsyLS5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" + + "VHlwZXMuTmVzdGVkTWVzc2FnZRJDChhyZXBlYXRlZF9mb3JlaWduX21lc3Nh" + + "Z2UYMSADKAsyIS5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduTWVzc2FnZRJI" + + "ChdyZXBlYXRlZF9pbXBvcnRfbWVzc2FnZRgyIAMoCzInLnByb3RvYnVmX3Vu" + + "aXR0ZXN0X2ltcG9ydC5JbXBvcnRNZXNzYWdlEkgKFHJlcGVhdGVkX25lc3Rl" + + "ZF9lbnVtGDMgAygOMioucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVz" + + "Lk5lc3RlZEVudW0SPQoVcmVwZWF0ZWRfZm9yZWlnbl9lbnVtGDQgAygOMh4u" + + "cHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW0SQgoUcmVwZWF0ZWRfaW1w" + + "b3J0X2VudW0YNSADKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1w" + + "b3J0RW51bRIhChVyZXBlYXRlZF9zdHJpbmdfcGllY2UYNiADKAlCAggCEhkK" + + "DXJlcGVhdGVkX2NvcmQYNyADKAlCAggBEhkKDWRlZmF1bHRfaW50MzIYPSAB" + + "KAU6AjQxEhkKDWRlZmF1bHRfaW50NjQYPiABKAM6AjQyEhoKDmRlZmF1bHRf" + + "dWludDMyGD8gASgNOgI0MxIaCg5kZWZhdWx0X3VpbnQ2NBhAIAEoBDoCNDQS" + + "GwoOZGVmYXVsdF9zaW50MzIYQSABKBE6Ay00NRIaCg5kZWZhdWx0X3NpbnQ2" + + "NBhCIAEoEjoCNDYSGwoPZGVmYXVsdF9maXhlZDMyGEMgASgHOgI0NxIbCg9k" + + "ZWZhdWx0X2ZpeGVkNjQYRCABKAY6AjQ4EhwKEGRlZmF1bHRfc2ZpeGVkMzIY" + + "RSABKA86AjQ5Eh0KEGRlZmF1bHRfc2ZpeGVkNjQYRiABKBA6Ay01MBIbCg1k" + + "ZWZhdWx0X2Zsb2F0GEcgASgCOgQ1MS41Eh0KDmRlZmF1bHRfZG91YmxlGEgg" + + "ASgBOgU1MjAwMBIaCgxkZWZhdWx0X2Jvb2wYSSABKAg6BHRydWUSHQoOZGVm" + + "YXVsdF9zdHJpbmcYSiABKAk6BWhlbGxvEhwKDWRlZmF1bHRfYnl0ZXMYSyAB" + + "KAw6BXdvcmxkEkwKE2RlZmF1bHRfbmVzdGVkX2VudW0YUSABKA4yKi5wcm90" + + "b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXMuTmVzdGVkRW51bToDQkFSEkkK" + + "FGRlZmF1bHRfZm9yZWlnbl9lbnVtGFIgASgOMh4ucHJvdG9idWZfdW5pdHRl" + + "c3QuRm9yZWlnbkVudW06C0ZPUkVJR05fQkFSEk0KE2RlZmF1bHRfaW1wb3J0" + + "X2VudW0YUyABKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0" + + "RW51bToKSU1QT1JUX0JBUhIlChRkZWZhdWx0X3N0cmluZ19waWVjZRhUIAEo" + + "CToDYWJjQgIIAhIdCgxkZWZhdWx0X2NvcmQYVSABKAk6AzEyM0ICCAEaGwoN" + + "TmVzdGVkTWVzc2FnZRIKCgJiYhgBIAEoBRoaCg1PcHRpb25hbEdyb3VwEgkK" + + "AWEYESABKAUaGgoNUmVwZWF0ZWRHcm91cBIJCgFhGC8gASgFIicKCk5lc3Rl" + + "ZEVudW0SBwoDRk9PEAESBwoDQkFSEAISBwoDQkFaEAMiGwoORm9yZWlnbk1l" + + "c3NhZ2USCQoBYxgBIAEoBSIdChFUZXN0QWxsRXh0ZW5zaW9ucyoICAEQgICA" + + "gAIiJAoXT3B0aW9uYWxHcm91cF9leHRlbnNpb24SCQoBYRgRIAEoBSIkChdS" + + "ZXBlYXRlZEdyb3VwX2V4dGVuc2lvbhIJCgFhGC8gASgFItUFCgxUZXN0UmVx" + + "dWlyZWQSCQoBYRgBIAIoBRIOCgZkdW1teTIYAiABKAUSCQoBYhgDIAIoBRIO" + + "CgZkdW1teTQYBCABKAUSDgoGZHVtbXk1GAUgASgFEg4KBmR1bW15NhgGIAEo" + + "BRIOCgZkdW1teTcYByABKAUSDgoGZHVtbXk4GAggASgFEg4KBmR1bW15ORgJ" + + "IAEoBRIPCgdkdW1teTEwGAogASgFEg8KB2R1bW15MTEYCyABKAUSDwoHZHVt" + + "bXkxMhgMIAEoBRIPCgdkdW1teTEzGA0gASgFEg8KB2R1bW15MTQYDiABKAUS" + + "DwoHZHVtbXkxNRgPIAEoBRIPCgdkdW1teTE2GBAgASgFEg8KB2R1bW15MTcY" + + "ESABKAUSDwoHZHVtbXkxOBgSIAEoBRIPCgdkdW1teTE5GBMgASgFEg8KB2R1" + + "bW15MjAYFCABKAUSDwoHZHVtbXkyMRgVIAEoBRIPCgdkdW1teTIyGBYgASgF" + + "Eg8KB2R1bW15MjMYFyABKAUSDwoHZHVtbXkyNBgYIAEoBRIPCgdkdW1teTI1" + + "GBkgASgFEg8KB2R1bW15MjYYGiABKAUSDwoHZHVtbXkyNxgbIAEoBRIPCgdk" + + "dW1teTI4GBwgASgFEg8KB2R1bW15MjkYHSABKAUSDwoHZHVtbXkzMBgeIAEo" + + "BRIPCgdkdW1teTMxGB8gASgFEg8KB2R1bW15MzIYICABKAUSCQoBYxghIAIo" + + "BTJWCgZzaW5nbGUSJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxjoByABKAsyHy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UmVxdWlyZWQy" + + "VQoFbXVsdGkSJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9u" + + "cxjpByADKAsyHy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UmVxdWlyZWQimgEK" + + "E1Rlc3RSZXF1aXJlZEZvcmVpZ24SOQoQb3B0aW9uYWxfbWVzc2FnZRgBIAEo" + + "CzIfLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RSZXF1aXJlZBI5ChByZXBlYXRl" + + "ZF9tZXNzYWdlGAIgAygLMh8ucHJvdG9idWZfdW5pdHRlc3QuVGVzdFJlcXVp" + + "cmVkEg0KBWR1bW15GAMgASgFIloKEVRlc3RGb3JlaWduTmVzdGVkEkUKDmZv" + + "cmVpZ25fbmVzdGVkGAEgASgLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs" + + "bFR5cGVzLk5lc3RlZE1lc3NhZ2UiEgoQVGVzdEVtcHR5TWVzc2FnZSIqCh5U" + + "ZXN0RW1wdHlNZXNzYWdlV2l0aEV4dGVuc2lvbnMqCAgBEICAgIACIjQKGFRl" + + "c3RSZWFsbHlMYXJnZVRhZ051bWJlchIJCgFhGAEgASgFEg0KAmJiGP///38g" + + "ASgFIlUKFFRlc3RSZWN1cnNpdmVNZXNzYWdlEjIKAWEYASABKAsyJy5wcm90" + + "b2J1Zl91bml0dGVzdC5UZXN0UmVjdXJzaXZlTWVzc2FnZRIJCgFpGAIgASgF" + + "IksKFFRlc3RNdXR1YWxSZWN1cnNpb25BEjMKAmJiGAEgASgLMicucHJvdG9i" + + "dWZfdW5pdHRlc3QuVGVzdE11dHVhbFJlY3Vyc2lvbkIiYgoUVGVzdE11dHVh" + + "bFJlY3Vyc2lvbkISMgoBYRgBIAEoCzInLnByb3RvYnVmX3VuaXR0ZXN0LlRl" + + "c3RNdXR1YWxSZWN1cnNpb25BEhYKDm9wdGlvbmFsX2ludDMyGAIgASgFIrMB" + + "ChJUZXN0RHVwRmllbGROdW1iZXISCQoBYRgBIAEoBRI2CgNmb28YAiABKAoy" + + "KS5wcm90b2J1Zl91bml0dGVzdC5UZXN0RHVwRmllbGROdW1iZXIuRm9vEjYK" + + "A2JhchgDIAEoCjIpLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3REdXBGaWVsZE51" + + "bWJlci5CYXIaEAoDRm9vEgkKAWEYASABKAUaEAoDQmFyEgkKAWEYASABKAUi" + + "gAIKGFRlc3ROZXN0ZWRNZXNzYWdlSGFzQml0cxJaChdvcHRpb25hbF9uZXN0" + + "ZWRfbWVzc2FnZRgBIAEoCzI5LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3ROZXN0" + + "ZWRNZXNzYWdlSGFzQml0cy5OZXN0ZWRNZXNzYWdlGocBCg1OZXN0ZWRNZXNz" + + "YWdlEiQKHG5lc3RlZG1lc3NhZ2VfcmVwZWF0ZWRfaW50MzIYASADKAUSUAol" + + "bmVzdGVkbWVzc2FnZV9yZXBlYXRlZF9mb3JlaWdubWVzc2FnZRgCIAMoCzIh" + + "LnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25NZXNzYWdlIuUDChdUZXN0Q2Ft" + + "ZWxDYXNlRmllbGROYW1lcxIWCg5QcmltaXRpdmVGaWVsZBgBIAEoBRITCgtT" + + "dHJpbmdGaWVsZBgCIAEoCRIxCglFbnVtRmllbGQYAyABKA4yHi5wcm90b2J1" + + "Zl91bml0dGVzdC5Gb3JlaWduRW51bRI3CgxNZXNzYWdlRmllbGQYBCABKAsy" + + "IS5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduTWVzc2FnZRIcChBTdHJpbmdQ" + + "aWVjZUZpZWxkGAUgASgJQgIIAhIVCglDb3JkRmllbGQYBiABKAlCAggBEh4K" + + "FlJlcGVhdGVkUHJpbWl0aXZlRmllbGQYByADKAUSGwoTUmVwZWF0ZWRTdHJp" + + "bmdGaWVsZBgIIAMoCRI5ChFSZXBlYXRlZEVudW1GaWVsZBgJIAMoDjIeLnBy" + + "b3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25FbnVtEj8KFFJlcGVhdGVkTWVzc2Fn" + + "ZUZpZWxkGAogAygLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3Nh" + + "Z2USJAoYUmVwZWF0ZWRTdHJpbmdQaWVjZUZpZWxkGAsgAygJQgIIAhIdChFS" + + "ZXBlYXRlZENvcmRGaWVsZBgMIAMoCUICCAEiVQoSVGVzdEZpZWxkT3JkZXJp" + + "bmdzEhEKCW15X3N0cmluZxgLIAEoCRIOCgZteV9pbnQYASABKAMSEAoIbXlf" + + "ZmxvYXQYZSABKAIqBAgCEAsqBAgMEGUikAIKGFRlc3RFeHRyZW1lRGVmYXVs" + + "dFZhbHVlcxI/Cg1lc2NhcGVkX2J5dGVzGAEgASgMOihcMDAwXDAwMVwwMDdc" + + "MDEwXDAxNFxuXHJcdFwwMTNcXFwnXCJcMzc2EiAKDGxhcmdlX3VpbnQzMhgC" + + "IAEoDToKNDI5NDk2NzI5NRIqCgxsYXJnZV91aW50NjQYAyABKAQ6FDE4NDQ2" + + "NzQ0MDczNzA5NTUxNjE1EiAKC3NtYWxsX2ludDMyGAQgASgFOgstMjE0NzQ4" + + "MzY0NxIpCgtzbWFsbF9pbnQ2NBgFIAEoAzoULTkyMjMzNzIwMzY4NTQ3NzU4" + + "MDcSGAoLdXRmOF9zdHJpbmcYBiABKAk6A+GItCIMCgpGb29SZXF1ZXN0Ig0K" + + "C0Zvb1Jlc3BvbnNlIgwKCkJhclJlcXVlc3QiDQoLQmFyUmVzcG9uc2UqQAoL" + + "Rm9yZWlnbkVudW0SDwoLRk9SRUlHTl9GT08QBBIPCgtGT1JFSUdOX0JBUhAF" + + "Eg8KC0ZPUkVJR05fQkFaEAYqRwoUVGVzdEVudW1XaXRoRHVwVmFsdWUSCAoE" + + "Rk9PMRABEggKBEJBUjEQAhIHCgNCQVoQAxIICgRGT08yEAESCAoEQkFSMhAC" + + "KokBCg5UZXN0U3BhcnNlRW51bRIMCghTUEFSU0VfQRB7Eg4KCFNQQVJTRV9C" + + "EKbnAxIPCghTUEFSU0VfQxCysYAGEhUKCFNQQVJTRV9EEPH//////////wES" + + "FQoIU1BBUlNFX0UQtN78////////ARIMCghTUEFSU0VfRhAAEgwKCFNQQVJT" + + "RV9HEAIymQEKC1Rlc3RTZXJ2aWNlEkQKA0ZvbxIdLnByb3RvYnVmX3VuaXR0" + + "ZXN0LkZvb1JlcXVlc3QaHi5wcm90b2J1Zl91bml0dGVzdC5Gb29SZXNwb25z" + + "ZRJECgNCYXISHS5wcm90b2J1Zl91bml0dGVzdC5CYXJSZXF1ZXN0Gh4ucHJv" + + "dG9idWZfdW5pdHRlc3QuQmFyUmVzcG9uc2U6RgoYb3B0aW9uYWxfaW50MzJf" + + "ZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lv" + + "bnMYASABKAU6RgoYb3B0aW9uYWxfaW50NjRfZXh0ZW5zaW9uEiQucHJvdG9i" + + "dWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYAiABKAM6RwoZb3B0aW9u" + + "YWxfdWludDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB" + + "bGxFeHRlbnNpb25zGAMgASgNOkcKGW9wdGlvbmFsX3VpbnQ2NF9leHRlbnNp" + + "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgEIAEo" + + "BDpHChlvcHRpb25hbF9zaW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" + + "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYBSABKBE6RwoZb3B0aW9uYWxfc2lu" + + "dDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl" + + "bnNpb25zGAYgASgSOkgKGm9wdGlvbmFsX2ZpeGVkMzJfZXh0ZW5zaW9uEiQu" + + "cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYByABKAc6SAoa" + + "b3B0aW9uYWxfZml4ZWQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVz" + + "dC5UZXN0QWxsRXh0ZW5zaW9ucxgIIAEoBjpJChtvcHRpb25hbF9zZml4ZWQz" + + "Ml9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxgJIAEoDzpJChtvcHRpb25hbF9zZml4ZWQ2NF9leHRlbnNpb24SJC5w" + + "cm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgKIAEoEDpGChhv" + + "cHRpb25hbF9mbG9hdF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" + + "ZXN0QWxsRXh0ZW5zaW9ucxgLIAEoAjpHChlvcHRpb25hbF9kb3VibGVfZXh0" + + "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" + + "DCABKAE6RQoXb3B0aW9uYWxfYm9vbF9leHRlbnNpb24SJC5wcm90b2J1Zl91" + + "bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgNIAEoCDpHChlvcHRpb25hbF9z" + + "dHJpbmdfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4" + + "dGVuc2lvbnMYDiABKAk6RgoYb3B0aW9uYWxfYnl0ZXNfZXh0ZW5zaW9uEiQu" + + "cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYDyABKAw6cQoX" + + "b3B0aW9uYWxncm91cF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" + + "ZXN0QWxsRXh0ZW5zaW9ucxgQIAEoCjIqLnByb3RvYnVmX3VuaXR0ZXN0Lk9w" + + "dGlvbmFsR3JvdXBfZXh0ZW5zaW9uOn4KIW9wdGlvbmFsX25lc3RlZF9tZXNz" + + "YWdlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl" + + "bnNpb25zGBIgASgLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVz" + + "Lk5lc3RlZE1lc3NhZ2U6cwoib3B0aW9uYWxfZm9yZWlnbl9tZXNzYWdlX2V4" + + "dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z" + + "GBMgASgLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2U6eAoh" + + "b3B0aW9uYWxfaW1wb3J0X21lc3NhZ2VfZXh0ZW5zaW9uEiQucHJvdG9idWZf" + + "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYFCABKAsyJy5wcm90b2J1Zl91" + + "bml0dGVzdF9pbXBvcnQuSW1wb3J0TWVzc2FnZTp4Ch5vcHRpb25hbF9uZXN0" + + "ZWRfZW51bV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" + + "RXh0ZW5zaW9ucxgVIAEoDjIqLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxU" + + "eXBlcy5OZXN0ZWRFbnVtOm0KH29wdGlvbmFsX2ZvcmVpZ25fZW51bV9leHRl" + + "bnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgW" + + "IAEoDjIeLnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25FbnVtOnIKHm9wdGlv" + + "bmFsX2ltcG9ydF9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0" + + "LlRlc3RBbGxFeHRlbnNpb25zGBcgASgOMiQucHJvdG9idWZfdW5pdHRlc3Rf" + + "aW1wb3J0LkltcG9ydEVudW06UQofb3B0aW9uYWxfc3RyaW5nX3BpZWNlX2V4" + + "dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z" + + "GBggASgJQgIIAjpJChdvcHRpb25hbF9jb3JkX2V4dGVuc2lvbhIkLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBkgASgJQgIIATpGChhy" + + "ZXBlYXRlZF9pbnQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" + + "ZXN0QWxsRXh0ZW5zaW9ucxgfIAMoBTpGChhyZXBlYXRlZF9pbnQ2NF9leHRl" + + "bnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgg" + + "IAMoAzpHChlyZXBlYXRlZF91aW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZf" + + "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYISADKA06RwoZcmVwZWF0ZWRf" + + "dWludDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF" + + "eHRlbnNpb25zGCIgAygEOkcKGXJlcGVhdGVkX3NpbnQzMl9leHRlbnNpb24S" + + "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgjIAMoETpH" + + "ChlyZXBlYXRlZF9zaW50NjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbEV4dGVuc2lvbnMYJCADKBI6SAoacmVwZWF0ZWRfZml4ZWQz" + + "Ml9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxglIAMoBzpIChpyZXBlYXRlZF9maXhlZDY0X2V4dGVuc2lvbhIkLnBy" + + "b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCYgAygGOkkKG3Jl" + + "cGVhdGVkX3NmaXhlZDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0" + + "LlRlc3RBbGxFeHRlbnNpb25zGCcgAygPOkkKG3JlcGVhdGVkX3NmaXhlZDY0" + + "X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNp" + + "b25zGCggAygQOkYKGHJlcGVhdGVkX2Zsb2F0X2V4dGVuc2lvbhIkLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCkgAygCOkcKGXJlcGVh" + + "dGVkX2RvdWJsZV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0" + + "QWxsRXh0ZW5zaW9ucxgqIAMoATpFChdyZXBlYXRlZF9ib29sX2V4dGVuc2lv" + + "bhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCsgAygI" + + "OkcKGXJlcGVhdGVkX3N0cmluZ19leHRlbnNpb24SJC5wcm90b2J1Zl91bml0" + + "dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgsIAMoCTpGChhyZXBlYXRlZF9ieXRl" + + "c19leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxgtIAMoDDpxChdyZXBlYXRlZGdyb3VwX2V4dGVuc2lvbhIkLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGC4gAygKMioucHJvdG9i" + + "dWZfdW5pdHRlc3QuUmVwZWF0ZWRHcm91cF9leHRlbnNpb246fgohcmVwZWF0" + + "ZWRfbmVzdGVkX21lc3NhZ2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbEV4dGVuc2lvbnMYMCADKAsyLS5wcm90b2J1Zl91bml0dGVz" + + "dC5UZXN0QWxsVHlwZXMuTmVzdGVkTWVzc2FnZTpzCiJyZXBlYXRlZF9mb3Jl" + + "aWduX21lc3NhZ2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" + + "dEFsbEV4dGVuc2lvbnMYMSADKAsyIS5wcm90b2J1Zl91bml0dGVzdC5Gb3Jl" + + "aWduTWVzc2FnZTp4CiFyZXBlYXRlZF9pbXBvcnRfbWVzc2FnZV9leHRlbnNp" + + "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgyIAMo" + + "CzInLnByb3RvYnVmX3VuaXR0ZXN0X2ltcG9ydC5JbXBvcnRNZXNzYWdlOngK" + + "HnJlcGVhdGVkX25lc3RlZF9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3Vu" + + "aXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGDMgAygOMioucHJvdG9idWZfdW5p" + + "dHRlc3QuVGVzdEFsbFR5cGVzLk5lc3RlZEVudW06bQofcmVwZWF0ZWRfZm9y" + + "ZWlnbl9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB" + + "bGxFeHRlbnNpb25zGDQgAygOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWln" + + "bkVudW06cgoecmVwZWF0ZWRfaW1wb3J0X2VudW1fZXh0ZW5zaW9uEiQucHJv" + + "dG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYNSADKA4yJC5wcm90" + + "b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bTpRCh9yZXBlYXRlZF9z" + + "dHJpbmdfcGllY2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" + + "dEFsbEV4dGVuc2lvbnMYNiADKAlCAggCOkkKF3JlcGVhdGVkX2NvcmRfZXh0" + + "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" + + "NyADKAlCAggBOkkKF2RlZmF1bHRfaW50MzJfZXh0ZW5zaW9uEiQucHJvdG9i" + + "dWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYPSABKAU6AjQxOkkKF2Rl" + + "ZmF1bHRfaW50NjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" + + "dEFsbEV4dGVuc2lvbnMYPiABKAM6AjQyOkoKGGRlZmF1bHRfdWludDMyX2V4" + + "dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z" + + "GD8gASgNOgI0MzpKChhkZWZhdWx0X3VpbnQ2NF9leHRlbnNpb24SJC5wcm90" + + "b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhAIAEoBDoCNDQ6SwoY" + + "ZGVmYXVsdF9zaW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu" + + "VGVzdEFsbEV4dGVuc2lvbnMYQSABKBE6Ay00NTpKChhkZWZhdWx0X3NpbnQ2" + + "NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxhCIAEoEjoCNDY6SwoZZGVmYXVsdF9maXhlZDMyX2V4dGVuc2lvbhIk" + + "LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGEMgASgHOgI0" + + "NzpLChlkZWZhdWx0X2ZpeGVkNjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" + + "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYRCABKAY6AjQ4OkwKGmRlZmF1bHRf" + + "c2ZpeGVkMzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs" + + "bEV4dGVuc2lvbnMYRSABKA86AjQ5Ok0KGmRlZmF1bHRfc2ZpeGVkNjRfZXh0" + + "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" + + "RiABKBA6Ay01MDpLChdkZWZhdWx0X2Zsb2F0X2V4dGVuc2lvbhIkLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGEcgASgCOgQ1MS41Ok0K" + + "GGRlZmF1bHRfZG91YmxlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0" + + "LlRlc3RBbGxFeHRlbnNpb25zGEggASgBOgU1MjAwMDpKChZkZWZhdWx0X2Jv" + + "b2xfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVu" + + "c2lvbnMYSSABKAg6BHRydWU6TQoYZGVmYXVsdF9zdHJpbmdfZXh0ZW5zaW9u" + + "EiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYSiABKAk6" + + "BWhlbGxvOkwKF2RlZmF1bHRfYnl0ZXNfZXh0ZW5zaW9uEiQucHJvdG9idWZf" + + "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYSyABKAw6BXdvcmxkOnwKHWRl" + + "ZmF1bHRfbmVzdGVkX2VudW1fZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbEV4dGVuc2lvbnMYUSABKA4yKi5wcm90b2J1Zl91bml0dGVz" + + "dC5UZXN0QWxsVHlwZXMuTmVzdGVkRW51bToDQkFSOnkKHmRlZmF1bHRfZm9y" + + "ZWlnbl9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB" + + "bGxFeHRlbnNpb25zGFIgASgOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWln" + + "bkVudW06C0ZPUkVJR05fQkFSOn0KHWRlZmF1bHRfaW1wb3J0X2VudW1fZXh0" + + "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" + + "UyABKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bToK" + + "SU1QT1JUX0JBUjpVCh5kZWZhdWx0X3N0cmluZ19waWVjZV9leHRlbnNpb24S" + + "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhUIAEoCToD" + + "YWJjQgIIAjpNChZkZWZhdWx0X2NvcmRfZXh0ZW5zaW9uEiQucHJvdG9idWZf" + + "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYVSABKAk6AzEyM0ICCAE6QgoT" + + "bXlfZXh0ZW5zaW9uX3N0cmluZxIlLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RG" + + "aWVsZE9yZGVyaW5ncxgyIAEoCTo/ChBteV9leHRlbnNpb25faW50EiUucHJv" + + "dG9idWZfdW5pdHRlc3QuVGVzdEZpZWxkT3JkZXJpbmdzGAUgASgFQktCDVVu" + + "aXR0ZXN0UHJvdG9IAYLiCSFHb29nbGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQ" + + "cm90b3OK4gkRVW5pdFRlc3RQcm90b0ZpbGU="), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.Descriptor, + }); + #endregion + + #region Extensions + public static readonly pb::GeneratedExtensionBase OptionalInt32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[0]); + public static readonly pb::GeneratedExtensionBase OptionalInt64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[1]); + public static readonly pb::GeneratedExtensionBase OptionalUint32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[2]); + public static readonly pb::GeneratedExtensionBase OptionalUint64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[3]); + public static readonly pb::GeneratedExtensionBase OptionalSint32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[4]); + public static readonly pb::GeneratedExtensionBase OptionalSint64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[5]); + public static readonly pb::GeneratedExtensionBase OptionalFixed32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[6]); + public static readonly pb::GeneratedExtensionBase OptionalFixed64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[7]); + public static readonly pb::GeneratedExtensionBase OptionalSfixed32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[8]); + public static readonly pb::GeneratedExtensionBase OptionalSfixed64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[9]); + public static readonly pb::GeneratedExtensionBase OptionalFloatExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[10]); + public static readonly pb::GeneratedExtensionBase OptionalDoubleExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[11]); + public static readonly pb::GeneratedExtensionBase OptionalBoolExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[12]); + public static readonly pb::GeneratedExtensionBase OptionalStringExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[13]); + public static readonly pb::GeneratedExtensionBase OptionalBytesExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[14]); + public static readonly pb::GeneratedExtensionBase OptionalGroupExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[15]); + public static readonly pb::GeneratedExtensionBase OptionalNestedMessageExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[16]); + public static readonly pb::GeneratedExtensionBase OptionalForeignMessageExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[17]); + public static readonly pb::GeneratedExtensionBase OptionalImportMessageExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[18]); + public static readonly pb::GeneratedExtensionBase OptionalNestedEnumExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[19]); + public static readonly pb::GeneratedExtensionBase OptionalForeignEnumExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[20]); + public static readonly pb::GeneratedExtensionBase OptionalImportEnumExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[21]); + public static readonly pb::GeneratedExtensionBase OptionalStringPieceExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[22]); + public static readonly pb::GeneratedExtensionBase OptionalCordExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[23]); + public static readonly + pb::GeneratedExtensionBase> RepeatedInt32Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[24]); + public static readonly + pb::GeneratedExtensionBase> RepeatedInt64Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[25]); + public static readonly + pb::GeneratedExtensionBase> RepeatedUint32Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[26]); + public static readonly + pb::GeneratedExtensionBase> RepeatedUint64Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[27]); + public static readonly + pb::GeneratedExtensionBase> RepeatedSint32Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[28]); + public static readonly + pb::GeneratedExtensionBase> RepeatedSint64Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[29]); + public static readonly + pb::GeneratedExtensionBase> RepeatedFixed32Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[30]); + public static readonly + pb::GeneratedExtensionBase> RepeatedFixed64Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[31]); + public static readonly + pb::GeneratedExtensionBase> RepeatedSfixed32Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[32]); + public static readonly + pb::GeneratedExtensionBase> RepeatedSfixed64Extension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[33]); + public static readonly + pb::GeneratedExtensionBase> RepeatedFloatExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[34]); + public static readonly + pb::GeneratedExtensionBase> RepeatedDoubleExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[35]); + public static readonly + pb::GeneratedExtensionBase> RepeatedBoolExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[36]); + public static readonly + pb::GeneratedExtensionBase> RepeatedStringExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[37]); + public static readonly + pb::GeneratedExtensionBase> RepeatedBytesExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[38]); + public static readonly + pb::GeneratedExtensionBase> RepeatedGroupExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[39]); + public static readonly + pb::GeneratedExtensionBase> RepeatedNestedMessageExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[40]); + public static readonly + pb::GeneratedExtensionBase> RepeatedForeignMessageExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[41]); + public static readonly + pb::GeneratedExtensionBase> RepeatedImportMessageExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[42]); + public static readonly + pb::GeneratedExtensionBase> RepeatedNestedEnumExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[43]); + public static readonly + pb::GeneratedExtensionBase> RepeatedForeignEnumExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[44]); + public static readonly + pb::GeneratedExtensionBase> RepeatedImportEnumExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[45]); + public static readonly + pb::GeneratedExtensionBase> RepeatedStringPieceExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[46]); + public static readonly + pb::GeneratedExtensionBase> RepeatedCordExtension = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[47]); + public static readonly pb::GeneratedExtensionBase DefaultInt32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[48]); + public static readonly pb::GeneratedExtensionBase DefaultInt64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[49]); + public static readonly pb::GeneratedExtensionBase DefaultUint32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[50]); + public static readonly pb::GeneratedExtensionBase DefaultUint64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[51]); + public static readonly pb::GeneratedExtensionBase DefaultSint32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[52]); + public static readonly pb::GeneratedExtensionBase DefaultSint64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[53]); + public static readonly pb::GeneratedExtensionBase DefaultFixed32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[54]); + public static readonly pb::GeneratedExtensionBase DefaultFixed64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[55]); + public static readonly pb::GeneratedExtensionBase DefaultSfixed32Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[56]); + public static readonly pb::GeneratedExtensionBase DefaultSfixed64Extension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[57]); + public static readonly pb::GeneratedExtensionBase DefaultFloatExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[58]); + public static readonly pb::GeneratedExtensionBase DefaultDoubleExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[59]); + public static readonly pb::GeneratedExtensionBase DefaultBoolExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[60]); + public static readonly pb::GeneratedExtensionBase DefaultStringExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[61]); + public static readonly pb::GeneratedExtensionBase DefaultBytesExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[62]); + public static readonly pb::GeneratedExtensionBase DefaultNestedEnumExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[63]); + public static readonly pb::GeneratedExtensionBase DefaultForeignEnumExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[64]); + public static readonly pb::GeneratedExtensionBase DefaultImportEnumExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[65]); + public static readonly pb::GeneratedExtensionBase DefaultStringPieceExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[66]); + public static readonly pb::GeneratedExtensionBase DefaultCordExtension = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[67]); + public static readonly pb::GeneratedExtensionBase MyExtensionString = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[68]); + public static readonly pb::GeneratedExtensionBase MyExtensionInt = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[69]); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllTypes__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestAllTypes__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestAllTypes__Descriptor, + new string[] { "OptionalInt32", "OptionalInt64", "OptionalUint32", "OptionalUint64", "OptionalSint32", "OptionalSint64", "OptionalFixed32", "OptionalFixed64", "OptionalSfixed32", "OptionalSfixed64", "OptionalFloat", "OptionalDouble", "OptionalBool", "OptionalString", "OptionalBytes", "OptionalGroup", "OptionalNestedMessage", "OptionalForeignMessage", "OptionalImportMessage", "OptionalNestedEnum", "OptionalForeignEnum", "OptionalImportEnum", "OptionalStringPiece", "OptionalCord", "RepeatedInt32", "RepeatedInt64", "RepeatedUint32", "RepeatedUint64", "RepeatedSint32", "RepeatedSint64", "RepeatedFixed32", "RepeatedFixed64", "RepeatedSfixed32", "RepeatedSfixed64", "RepeatedFloat", "RepeatedDouble", "RepeatedBool", "RepeatedString", "RepeatedBytes", "RepeatedGroup", "RepeatedNestedMessage", "RepeatedForeignMessage", "RepeatedImportMessage", "RepeatedNestedEnum", "RepeatedForeignEnum", "RepeatedImportEnum", "RepeatedStringPiece", "RepeatedCord", "DefaultInt32", "DefaultInt64", "DefaultUint32", "DefaultUint64", "DefaultSint32", "DefaultSint64", "DefaultFixed32", "DefaultFixed64", "DefaultSfixed32", "DefaultSfixed64", "DefaultFloat", "DefaultDouble", "DefaultBool", "DefaultString", "DefaultBytes", "DefaultNestedEnum", "DefaultForeignEnum", "DefaultImportEnum", "DefaultStringPiece", "DefaultCord", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllTypes_NestedMessage__Descriptor + = internal__static_protobuf_unittest_TestAllTypes__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestAllTypes_NestedMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestAllTypes_NestedMessage__Descriptor, + new string[] { "Bb", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__Descriptor + = internal__static_protobuf_unittest_TestAllTypes__Descriptor.NestedTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__Descriptor + = internal__static_protobuf_unittest_TestAllTypes__Descriptor.NestedTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ForeignMessage__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_ForeignMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_ForeignMessage__Descriptor, + new string[] { "C", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllExtensions__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestAllExtensions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestAllExtensions__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_OptionalGroup_extension__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_OptionalGroup_extension__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_OptionalGroup_extension__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_RepeatedGroup_extension__Descriptor + = Descriptor.MessageTypes[4]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_RepeatedGroup_extension__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_RepeatedGroup_extension__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRequired__Descriptor + = Descriptor.MessageTypes[5]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestRequired__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestRequired__Descriptor, + new string[] { "A", "Dummy2", "B", "Dummy4", "Dummy5", "Dummy6", "Dummy7", "Dummy8", "Dummy9", "Dummy10", "Dummy11", "Dummy12", "Dummy13", "Dummy14", "Dummy15", "Dummy16", "Dummy17", "Dummy18", "Dummy19", "Dummy20", "Dummy21", "Dummy22", "Dummy23", "Dummy24", "Dummy25", "Dummy26", "Dummy27", "Dummy28", "Dummy29", "Dummy30", "Dummy31", "Dummy32", "C", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRequiredForeign__Descriptor + = Descriptor.MessageTypes[6]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestRequiredForeign__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestRequiredForeign__Descriptor, + new string[] { "OptionalMessage", "RepeatedMessage", "Dummy", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestForeignNested__Descriptor + = Descriptor.MessageTypes[7]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestForeignNested__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestForeignNested__Descriptor, + new string[] { "ForeignNested", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestEmptyMessage__Descriptor + = Descriptor.MessageTypes[8]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestEmptyMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestEmptyMessage__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__Descriptor + = Descriptor.MessageTypes[9]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestReallyLargeTagNumber__Descriptor + = Descriptor.MessageTypes[10]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestReallyLargeTagNumber__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestReallyLargeTagNumber__Descriptor, + new string[] { "A", "Bb", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRecursiveMessage__Descriptor + = Descriptor.MessageTypes[11]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestRecursiveMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestRecursiveMessage__Descriptor, + new string[] { "A", "I", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMutualRecursionA__Descriptor + = Descriptor.MessageTypes[12]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestMutualRecursionA__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestMutualRecursionA__Descriptor, + new string[] { "Bb", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMutualRecursionB__Descriptor + = Descriptor.MessageTypes[13]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestMutualRecursionB__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestMutualRecursionB__Descriptor, + new string[] { "A", "OptionalInt32", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor + = Descriptor.MessageTypes[14]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestDupFieldNumber__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor, + new string[] { "A", "Foo", "Bar", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestDupFieldNumber_Foo__Descriptor + = internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestDupFieldNumber_Foo__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestDupFieldNumber_Foo__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestDupFieldNumber_Bar__Descriptor + = internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor.NestedTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestDupFieldNumber_Bar__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestDupFieldNumber_Bar__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestNestedMessageHasBits__Descriptor + = Descriptor.MessageTypes[15]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestNestedMessageHasBits__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestNestedMessageHasBits__Descriptor, + new string[] { "OptionalNestedMessage", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__Descriptor + = internal__static_protobuf_unittest_TestNestedMessageHasBits__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__Descriptor, + new string[] { "NestedmessageRepeatedInt32", "NestedmessageRepeatedForeignmessage", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestCamelCaseFieldNames__Descriptor + = Descriptor.MessageTypes[16]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestCamelCaseFieldNames__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestCamelCaseFieldNames__Descriptor, + new string[] { "PrimitiveField", "StringField", "EnumField", "MessageField", "StringPieceField", "CordField", "RepeatedPrimitiveField", "RepeatedStringField", "RepeatedEnumField", "RepeatedMessageField", "RepeatedStringPieceField", "RepeatedCordField", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestFieldOrderings__Descriptor + = Descriptor.MessageTypes[17]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestFieldOrderings__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestFieldOrderings__Descriptor, + new string[] { "MyString", "MyInt", "MyFloat", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestExtremeDefaultValues__Descriptor + = Descriptor.MessageTypes[18]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_TestExtremeDefaultValues__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_TestExtremeDefaultValues__Descriptor, + new string[] { "EscapedBytes", "LargeUint32", "LargeUint64", "SmallInt32", "SmallInt64", "Utf8String", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_FooRequest__Descriptor + = Descriptor.MessageTypes[19]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_FooRequest__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_FooRequest__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_FooResponse__Descriptor + = Descriptor.MessageTypes[20]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_FooResponse__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_FooResponse__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_BarRequest__Descriptor + = Descriptor.MessageTypes[21]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_BarRequest__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_BarRequest__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_BarResponse__Descriptor + = Descriptor.MessageTypes[22]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_protobuf_unittest_BarResponse__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_protobuf_unittest_BarResponse__Descriptor, + new string[] { }); + #endregion + } + #region Enums + public enum ForeignEnum { + FOREIGN_FOO = 4, + FOREIGN_BAR = 5, + FOREIGN_BAZ = 6, + } + + public enum TestEnumWithDupValue { + FOO1 = 1, + BAR1 = 2, + BAZ = 3, + FOO2 = 1, + BAR2 = 2, + } + + public enum TestSparseEnum { + SPARSE_A = 123, + SPARSE_B = 62374, + SPARSE_C = 12589234, + SPARSE_D = -15, + SPARSE_E = -53452, + SPARSE_F = 0, + SPARSE_G = 2, + } + + #endregion + + #region Messages + public sealed partial class TestAllTypes : pb::GeneratedMessage { + private static readonly TestAllTypes defaultInstance = new Builder().BuildPartial(); + public static TestAllTypes DefaultInstance { + get { return defaultInstance; } + } + + public override TestAllTypes DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestAllTypes ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum NestedEnum { + FOO = 1, + BAR = 2, + BAZ = 3, + } + + public sealed partial class NestedMessage : pb::GeneratedMessage { + private static readonly NestedMessage defaultInstance = new Builder().BuildPartial(); + public static NestedMessage DefaultInstance { + get { return defaultInstance; } + } + + public override NestedMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NestedMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_NestedMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_NestedMessage__FieldAccessorTable; } + } + + private bool hasBb; + private int bb_ = 0; + public bool HasBb { + get { return hasBb; } + } + public int Bb { + get { return bb_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasBb) { + output.WriteInt32(1, Bb); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasBb) { + size += pb::CodedOutputStream.ComputeInt32Size(1, Bb); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NestedMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NestedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NestedMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(NestedMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NestedMessage result = new NestedMessage(); + + protected override NestedMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NestedMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return NestedMessage.Descriptor; } + } + + public override NestedMessage DefaultInstanceForType { + get { return NestedMessage.DefaultInstance; } + } + + public override NestedMessage BuildPartial() { + NestedMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NestedMessage) { + return MergeFrom((NestedMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NestedMessage other) { + if (other == NestedMessage.DefaultInstance) return this; + if (other.HasBb) { + Bb = other.Bb; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + Bb = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasBb { + get { return result.HasBb; } + } + public int Bb { + get { return result.Bb; } + set { SetBb(value); } + } + public Builder SetBb(int value) { + result.hasBb = true; + result.bb_ = value; + return this; + } + public Builder ClearBb() { + result.hasBb = false; + result.bb_ = 0; + return this; + } + } + } + + public sealed partial class OptionalGroup : pb::GeneratedMessage { + private static readonly OptionalGroup defaultInstance = new Builder().BuildPartial(); + public static OptionalGroup DefaultInstance { + get { return defaultInstance; } + } + + public override OptionalGroup DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override OptionalGroup ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(17, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(17, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static OptionalGroup ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static OptionalGroup ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static OptionalGroup ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static OptionalGroup ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static OptionalGroup ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(OptionalGroup prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + OptionalGroup result = new OptionalGroup(); + + protected override OptionalGroup MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new OptionalGroup(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return OptionalGroup.Descriptor; } + } + + public override OptionalGroup DefaultInstanceForType { + get { return OptionalGroup.DefaultInstance; } + } + + public override OptionalGroup BuildPartial() { + OptionalGroup returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is OptionalGroup) { + return MergeFrom((OptionalGroup) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(OptionalGroup other) { + if (other == OptionalGroup.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 136: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + public sealed partial class RepeatedGroup : pb::GeneratedMessage { + private static readonly RepeatedGroup defaultInstance = new Builder().BuildPartial(); + public static RepeatedGroup DefaultInstance { + get { return defaultInstance; } + } + + public override RepeatedGroup DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override RepeatedGroup ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(47, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(47, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static RepeatedGroup ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(RepeatedGroup prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + RepeatedGroup result = new RepeatedGroup(); + + protected override RepeatedGroup MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new RepeatedGroup(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return RepeatedGroup.Descriptor; } + } + + public override RepeatedGroup DefaultInstanceForType { + get { return RepeatedGroup.DefaultInstance; } + } + + public override RepeatedGroup BuildPartial() { + RepeatedGroup returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is RepeatedGroup) { + return MergeFrom((RepeatedGroup) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(RepeatedGroup other) { + if (other == RepeatedGroup.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 376: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasOptionalInt32; + private int optionalInt32_ = 0; + public bool HasOptionalInt32 { + get { return hasOptionalInt32; } + } + public int OptionalInt32 { + get { return optionalInt32_; } + } + + private bool hasOptionalInt64; + private long optionalInt64_ = 0L; + public bool HasOptionalInt64 { + get { return hasOptionalInt64; } + } + public long OptionalInt64 { + get { return optionalInt64_; } + } + + private bool hasOptionalUint32; + private uint optionalUint32_ = 0; + public bool HasOptionalUint32 { + get { return hasOptionalUint32; } + } + public uint OptionalUint32 { + get { return optionalUint32_; } + } + + private bool hasOptionalUint64; + private ulong optionalUint64_ = 0UL; + public bool HasOptionalUint64 { + get { return hasOptionalUint64; } + } + public ulong OptionalUint64 { + get { return optionalUint64_; } + } + + private bool hasOptionalSint32; + private int optionalSint32_ = 0; + public bool HasOptionalSint32 { + get { return hasOptionalSint32; } + } + public int OptionalSint32 { + get { return optionalSint32_; } + } + + private bool hasOptionalSint64; + private long optionalSint64_ = 0; + public bool HasOptionalSint64 { + get { return hasOptionalSint64; } + } + public long OptionalSint64 { + get { return optionalSint64_; } + } + + private bool hasOptionalFixed32; + private uint optionalFixed32_ = 0; + public bool HasOptionalFixed32 { + get { return hasOptionalFixed32; } + } + public uint OptionalFixed32 { + get { return optionalFixed32_; } + } + + private bool hasOptionalFixed64; + private ulong optionalFixed64_ = 0; + public bool HasOptionalFixed64 { + get { return hasOptionalFixed64; } + } + public ulong OptionalFixed64 { + get { return optionalFixed64_; } + } + + private bool hasOptionalSfixed32; + private int optionalSfixed32_ = 0; + public bool HasOptionalSfixed32 { + get { return hasOptionalSfixed32; } + } + public int OptionalSfixed32 { + get { return optionalSfixed32_; } + } + + private bool hasOptionalSfixed64; + private long optionalSfixed64_ = 0; + public bool HasOptionalSfixed64 { + get { return hasOptionalSfixed64; } + } + public long OptionalSfixed64 { + get { return optionalSfixed64_; } + } + + private bool hasOptionalFloat; + private float optionalFloat_ = 0F; + public bool HasOptionalFloat { + get { return hasOptionalFloat; } + } + public float OptionalFloat { + get { return optionalFloat_; } + } + + private bool hasOptionalDouble; + private double optionalDouble_ = 0D; + public bool HasOptionalDouble { + get { return hasOptionalDouble; } + } + public double OptionalDouble { + get { return optionalDouble_; } + } + + private bool hasOptionalBool; + private bool optionalBool_ = false; + public bool HasOptionalBool { + get { return hasOptionalBool; } + } + public bool OptionalBool { + get { return optionalBool_; } + } + + private bool hasOptionalString; + private string optionalString_ = ""; + public bool HasOptionalString { + get { return hasOptionalString; } + } + public string OptionalString { + get { return optionalString_; } + } + + private bool hasOptionalBytes; + private pb::ByteString optionalBytes_ = pb::ByteString.Empty; + public bool HasOptionalBytes { + get { return hasOptionalBytes; } + } + public pb::ByteString OptionalBytes { + get { return optionalBytes_; } + } + + private bool hasOptionalGroup; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup optionalGroup_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.DefaultInstance; + public bool HasOptionalGroup { + get { return hasOptionalGroup; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup OptionalGroup { + get { return optionalGroup_; } + } + + private bool hasOptionalNestedMessage; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance; + public bool HasOptionalNestedMessage { + get { return hasOptionalNestedMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage OptionalNestedMessage { + get { return optionalNestedMessage_; } + } + + private bool hasOptionalForeignMessage; + private global::Google.ProtocolBuffers.TestProtos.ForeignMessage optionalForeignMessage_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + public bool HasOptionalForeignMessage { + get { return hasOptionalForeignMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage OptionalForeignMessage { + get { return optionalForeignMessage_; } + } + + private bool hasOptionalImportMessage; + private global::Google.ProtocolBuffers.TestProtos.ImportMessage optionalImportMessage_ = global::Google.ProtocolBuffers.TestProtos.ImportMessage.DefaultInstance; + public bool HasOptionalImportMessage { + get { return hasOptionalImportMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportMessage OptionalImportMessage { + get { return optionalImportMessage_; } + } + + private bool hasOptionalNestedEnum; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum optionalNestedEnum_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum.FOO; + public bool HasOptionalNestedEnum { + get { return hasOptionalNestedEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum OptionalNestedEnum { + get { return optionalNestedEnum_; } + } + + private bool hasOptionalForeignEnum; + private global::Google.ProtocolBuffers.TestProtos.ForeignEnum optionalForeignEnum_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_FOO; + public bool HasOptionalForeignEnum { + get { return hasOptionalForeignEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum OptionalForeignEnum { + get { return optionalForeignEnum_; } + } + + private bool hasOptionalImportEnum; + private global::Google.ProtocolBuffers.TestProtos.ImportEnum optionalImportEnum_ = global::Google.ProtocolBuffers.TestProtos.ImportEnum.IMPORT_FOO; + public bool HasOptionalImportEnum { + get { return hasOptionalImportEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum OptionalImportEnum { + get { return optionalImportEnum_; } + } + + private bool hasOptionalStringPiece; + private string optionalStringPiece_ = ""; + public bool HasOptionalStringPiece { + get { return hasOptionalStringPiece; } + } + public string OptionalStringPiece { + get { return optionalStringPiece_; } + } + + private bool hasOptionalCord; + private string optionalCord_ = ""; + public bool HasOptionalCord { + get { return hasOptionalCord; } + } + public string OptionalCord { + get { return optionalCord_; } + } + + private pbc::PopsicleList repeatedInt32_ = new pbc::PopsicleList(); + public scg::IList RepeatedInt32List { + get { return pbc::Lists.AsReadOnly(repeatedInt32_); } + } + public int RepeatedInt32Count { + get { return repeatedInt32_.Count; } + } + public int GetRepeatedInt32(int index) { + return repeatedInt32_[index]; + } + + private pbc::PopsicleList repeatedInt64_ = new pbc::PopsicleList(); + public scg::IList RepeatedInt64List { + get { return pbc::Lists.AsReadOnly(repeatedInt64_); } + } + public int RepeatedInt64Count { + get { return repeatedInt64_.Count; } + } + public long GetRepeatedInt64(int index) { + return repeatedInt64_[index]; + } + + private pbc::PopsicleList repeatedUint32_ = new pbc::PopsicleList(); + public scg::IList RepeatedUint32List { + get { return pbc::Lists.AsReadOnly(repeatedUint32_); } + } + public int RepeatedUint32Count { + get { return repeatedUint32_.Count; } + } + public uint GetRepeatedUint32(int index) { + return repeatedUint32_[index]; + } + + private pbc::PopsicleList repeatedUint64_ = new pbc::PopsicleList(); + public scg::IList RepeatedUint64List { + get { return pbc::Lists.AsReadOnly(repeatedUint64_); } + } + public int RepeatedUint64Count { + get { return repeatedUint64_.Count; } + } + public ulong GetRepeatedUint64(int index) { + return repeatedUint64_[index]; + } + + private pbc::PopsicleList repeatedSint32_ = new pbc::PopsicleList(); + public scg::IList RepeatedSint32List { + get { return pbc::Lists.AsReadOnly(repeatedSint32_); } + } + public int RepeatedSint32Count { + get { return repeatedSint32_.Count; } + } + public int GetRepeatedSint32(int index) { + return repeatedSint32_[index]; + } + + private pbc::PopsicleList repeatedSint64_ = new pbc::PopsicleList(); + public scg::IList RepeatedSint64List { + get { return pbc::Lists.AsReadOnly(repeatedSint64_); } + } + public int RepeatedSint64Count { + get { return repeatedSint64_.Count; } + } + public long GetRepeatedSint64(int index) { + return repeatedSint64_[index]; + } + + private pbc::PopsicleList repeatedFixed32_ = new pbc::PopsicleList(); + public scg::IList RepeatedFixed32List { + get { return pbc::Lists.AsReadOnly(repeatedFixed32_); } + } + public int RepeatedFixed32Count { + get { return repeatedFixed32_.Count; } + } + public uint GetRepeatedFixed32(int index) { + return repeatedFixed32_[index]; + } + + private pbc::PopsicleList repeatedFixed64_ = new pbc::PopsicleList(); + public scg::IList RepeatedFixed64List { + get { return pbc::Lists.AsReadOnly(repeatedFixed64_); } + } + public int RepeatedFixed64Count { + get { return repeatedFixed64_.Count; } + } + public ulong GetRepeatedFixed64(int index) { + return repeatedFixed64_[index]; + } + + private pbc::PopsicleList repeatedSfixed32_ = new pbc::PopsicleList(); + public scg::IList RepeatedSfixed32List { + get { return pbc::Lists.AsReadOnly(repeatedSfixed32_); } + } + public int RepeatedSfixed32Count { + get { return repeatedSfixed32_.Count; } + } + public int GetRepeatedSfixed32(int index) { + return repeatedSfixed32_[index]; + } + + private pbc::PopsicleList repeatedSfixed64_ = new pbc::PopsicleList(); + public scg::IList RepeatedSfixed64List { + get { return pbc::Lists.AsReadOnly(repeatedSfixed64_); } + } + public int RepeatedSfixed64Count { + get { return repeatedSfixed64_.Count; } + } + public long GetRepeatedSfixed64(int index) { + return repeatedSfixed64_[index]; + } + + private pbc::PopsicleList repeatedFloat_ = new pbc::PopsicleList(); + public scg::IList RepeatedFloatList { + get { return pbc::Lists.AsReadOnly(repeatedFloat_); } + } + public int RepeatedFloatCount { + get { return repeatedFloat_.Count; } + } + public float GetRepeatedFloat(int index) { + return repeatedFloat_[index]; + } + + private pbc::PopsicleList repeatedDouble_ = new pbc::PopsicleList(); + public scg::IList RepeatedDoubleList { + get { return pbc::Lists.AsReadOnly(repeatedDouble_); } + } + public int RepeatedDoubleCount { + get { return repeatedDouble_.Count; } + } + public double GetRepeatedDouble(int index) { + return repeatedDouble_[index]; + } + + private pbc::PopsicleList repeatedBool_ = new pbc::PopsicleList(); + public scg::IList RepeatedBoolList { + get { return pbc::Lists.AsReadOnly(repeatedBool_); } + } + public int RepeatedBoolCount { + get { return repeatedBool_.Count; } + } + public bool GetRepeatedBool(int index) { + return repeatedBool_[index]; + } + + private pbc::PopsicleList repeatedString_ = new pbc::PopsicleList(); + public scg::IList RepeatedStringList { + get { return pbc::Lists.AsReadOnly(repeatedString_); } + } + public int RepeatedStringCount { + get { return repeatedString_.Count; } + } + public string GetRepeatedString(int index) { + return repeatedString_[index]; + } + + private pbc::PopsicleList repeatedBytes_ = new pbc::PopsicleList(); + public scg::IList RepeatedBytesList { + get { return pbc::Lists.AsReadOnly(repeatedBytes_); } + } + public int RepeatedBytesCount { + get { return repeatedBytes_.Count; } + } + public pb::ByteString GetRepeatedBytes(int index) { + return repeatedBytes_[index]; + } + + private pbc::PopsicleList repeatedGroup_ = new pbc::PopsicleList(); + public scg::IList RepeatedGroupList { + get { return repeatedGroup_; } + } + public int RepeatedGroupCount { + get { return repeatedGroup_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup GetRepeatedGroup(int index) { + return repeatedGroup_[index]; + } + + private pbc::PopsicleList repeatedNestedMessage_ = new pbc::PopsicleList(); + public scg::IList RepeatedNestedMessageList { + get { return repeatedNestedMessage_; } + } + public int RepeatedNestedMessageCount { + get { return repeatedNestedMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage GetRepeatedNestedMessage(int index) { + return repeatedNestedMessage_[index]; + } + + private pbc::PopsicleList repeatedForeignMessage_ = new pbc::PopsicleList(); + public scg::IList RepeatedForeignMessageList { + get { return repeatedForeignMessage_; } + } + public int RepeatedForeignMessageCount { + get { return repeatedForeignMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetRepeatedForeignMessage(int index) { + return repeatedForeignMessage_[index]; + } + + private pbc::PopsicleList repeatedImportMessage_ = new pbc::PopsicleList(); + public scg::IList RepeatedImportMessageList { + get { return repeatedImportMessage_; } + } + public int RepeatedImportMessageCount { + get { return repeatedImportMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportMessage GetRepeatedImportMessage(int index) { + return repeatedImportMessage_[index]; + } + + private pbc::PopsicleList repeatedNestedEnum_ = new pbc::PopsicleList(); + public scg::IList RepeatedNestedEnumList { + get { return pbc::Lists.AsReadOnly(repeatedNestedEnum_); } + } + public int RepeatedNestedEnumCount { + get { return repeatedNestedEnum_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum GetRepeatedNestedEnum(int index) { + return repeatedNestedEnum_[index]; + } + + private pbc::PopsicleList repeatedForeignEnum_ = new pbc::PopsicleList(); + public scg::IList RepeatedForeignEnumList { + get { return pbc::Lists.AsReadOnly(repeatedForeignEnum_); } + } + public int RepeatedForeignEnumCount { + get { return repeatedForeignEnum_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetRepeatedForeignEnum(int index) { + return repeatedForeignEnum_[index]; + } + + private pbc::PopsicleList repeatedImportEnum_ = new pbc::PopsicleList(); + public scg::IList RepeatedImportEnumList { + get { return pbc::Lists.AsReadOnly(repeatedImportEnum_); } + } + public int RepeatedImportEnumCount { + get { return repeatedImportEnum_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum GetRepeatedImportEnum(int index) { + return repeatedImportEnum_[index]; + } + + private pbc::PopsicleList repeatedStringPiece_ = new pbc::PopsicleList(); + public scg::IList RepeatedStringPieceList { + get { return pbc::Lists.AsReadOnly(repeatedStringPiece_); } + } + public int RepeatedStringPieceCount { + get { return repeatedStringPiece_.Count; } + } + public string GetRepeatedStringPiece(int index) { + return repeatedStringPiece_[index]; + } + + private pbc::PopsicleList repeatedCord_ = new pbc::PopsicleList(); + public scg::IList RepeatedCordList { + get { return pbc::Lists.AsReadOnly(repeatedCord_); } + } + public int RepeatedCordCount { + get { return repeatedCord_.Count; } + } + public string GetRepeatedCord(int index) { + return repeatedCord_[index]; + } + + private bool hasDefaultInt32; + private int defaultInt32_ = 41; + public bool HasDefaultInt32 { + get { return hasDefaultInt32; } + } + public int DefaultInt32 { + get { return defaultInt32_; } + } + + private bool hasDefaultInt64; + private long defaultInt64_ = 42L; + public bool HasDefaultInt64 { + get { return hasDefaultInt64; } + } + public long DefaultInt64 { + get { return defaultInt64_; } + } + + private bool hasDefaultUint32; + private uint defaultUint32_ = 43; + public bool HasDefaultUint32 { + get { return hasDefaultUint32; } + } + public uint DefaultUint32 { + get { return defaultUint32_; } + } + + private bool hasDefaultUint64; + private ulong defaultUint64_ = 44UL; + public bool HasDefaultUint64 { + get { return hasDefaultUint64; } + } + public ulong DefaultUint64 { + get { return defaultUint64_; } + } + + private bool hasDefaultSint32; + private int defaultSint32_ = -45; + public bool HasDefaultSint32 { + get { return hasDefaultSint32; } + } + public int DefaultSint32 { + get { return defaultSint32_; } + } + + private bool hasDefaultSint64; + private long defaultSint64_ = 46; + public bool HasDefaultSint64 { + get { return hasDefaultSint64; } + } + public long DefaultSint64 { + get { return defaultSint64_; } + } + + private bool hasDefaultFixed32; + private uint defaultFixed32_ = 47; + public bool HasDefaultFixed32 { + get { return hasDefaultFixed32; } + } + public uint DefaultFixed32 { + get { return defaultFixed32_; } + } + + private bool hasDefaultFixed64; + private ulong defaultFixed64_ = 48; + public bool HasDefaultFixed64 { + get { return hasDefaultFixed64; } + } + public ulong DefaultFixed64 { + get { return defaultFixed64_; } + } + + private bool hasDefaultSfixed32; + private int defaultSfixed32_ = 49; + public bool HasDefaultSfixed32 { + get { return hasDefaultSfixed32; } + } + public int DefaultSfixed32 { + get { return defaultSfixed32_; } + } + + private bool hasDefaultSfixed64; + private long defaultSfixed64_ = -50; + public bool HasDefaultSfixed64 { + get { return hasDefaultSfixed64; } + } + public long DefaultSfixed64 { + get { return defaultSfixed64_; } + } + + private bool hasDefaultFloat; + private float defaultFloat_ = 51.5F; + public bool HasDefaultFloat { + get { return hasDefaultFloat; } + } + public float DefaultFloat { + get { return defaultFloat_; } + } + + private bool hasDefaultDouble; + private double defaultDouble_ = 52000D; + public bool HasDefaultDouble { + get { return hasDefaultDouble; } + } + public double DefaultDouble { + get { return defaultDouble_; } + } + + private bool hasDefaultBool; + private bool defaultBool_ = true; + public bool HasDefaultBool { + get { return hasDefaultBool; } + } + public bool DefaultBool { + get { return defaultBool_; } + } + + private bool hasDefaultString; + private string defaultString_ = "hello"; + public bool HasDefaultString { + get { return hasDefaultString; } + } + public string DefaultString { + get { return defaultString_; } + } + + private bool hasDefaultBytes; + private pb::ByteString defaultBytes_ = (pb::ByteString) global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Descriptor.Fields[62].DefaultValue; + public bool HasDefaultBytes { + get { return hasDefaultBytes; } + } + public pb::ByteString DefaultBytes { + get { return defaultBytes_; } + } + + private bool hasDefaultNestedEnum; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum defaultNestedEnum_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum.BAR; + public bool HasDefaultNestedEnum { + get { return hasDefaultNestedEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum DefaultNestedEnum { + get { return defaultNestedEnum_; } + } + + private bool hasDefaultForeignEnum; + private global::Google.ProtocolBuffers.TestProtos.ForeignEnum defaultForeignEnum_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_BAR; + public bool HasDefaultForeignEnum { + get { return hasDefaultForeignEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum DefaultForeignEnum { + get { return defaultForeignEnum_; } + } + + private bool hasDefaultImportEnum; + private global::Google.ProtocolBuffers.TestProtos.ImportEnum defaultImportEnum_ = global::Google.ProtocolBuffers.TestProtos.ImportEnum.IMPORT_BAR; + public bool HasDefaultImportEnum { + get { return hasDefaultImportEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum DefaultImportEnum { + get { return defaultImportEnum_; } + } + + private bool hasDefaultStringPiece; + private string defaultStringPiece_ = "abc"; + public bool HasDefaultStringPiece { + get { return hasDefaultStringPiece; } + } + public string DefaultStringPiece { + get { return defaultStringPiece_; } + } + + private bool hasDefaultCord; + private string defaultCord_ = "123"; + public bool HasDefaultCord { + get { return hasDefaultCord; } + } + public string DefaultCord { + get { return defaultCord_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasOptionalInt32) { + output.WriteInt32(1, OptionalInt32); + } + if (HasOptionalInt64) { + output.WriteInt64(2, OptionalInt64); + } + if (HasOptionalUint32) { + output.WriteUInt32(3, OptionalUint32); + } + if (HasOptionalUint64) { + output.WriteUInt64(4, OptionalUint64); + } + if (HasOptionalSint32) { + output.WriteSInt32(5, OptionalSint32); + } + if (HasOptionalSint64) { + output.WriteSInt64(6, OptionalSint64); + } + if (HasOptionalFixed32) { + output.WriteFixed32(7, OptionalFixed32); + } + if (HasOptionalFixed64) { + output.WriteFixed64(8, OptionalFixed64); + } + if (HasOptionalSfixed32) { + output.WriteSFixed32(9, OptionalSfixed32); + } + if (HasOptionalSfixed64) { + output.WriteSFixed64(10, OptionalSfixed64); + } + if (HasOptionalFloat) { + output.WriteFloat(11, OptionalFloat); + } + if (HasOptionalDouble) { + output.WriteDouble(12, OptionalDouble); + } + if (HasOptionalBool) { + output.WriteBool(13, OptionalBool); + } + if (HasOptionalString) { + output.WriteString(14, OptionalString); + } + if (HasOptionalBytes) { + output.WriteBytes(15, OptionalBytes); + } + if (HasOptionalGroup) { + output.WriteGroup(16, OptionalGroup); + } + if (HasOptionalNestedMessage) { + output.WriteMessage(18, OptionalNestedMessage); + } + if (HasOptionalForeignMessage) { + output.WriteMessage(19, OptionalForeignMessage); + } + if (HasOptionalImportMessage) { + output.WriteMessage(20, OptionalImportMessage); + } + if (HasOptionalNestedEnum) { + output.WriteEnum(21, (int) OptionalNestedEnum); + } + if (HasOptionalForeignEnum) { + output.WriteEnum(22, (int) OptionalForeignEnum); + } + if (HasOptionalImportEnum) { + output.WriteEnum(23, (int) OptionalImportEnum); + } + if (HasOptionalStringPiece) { + output.WriteString(24, OptionalStringPiece); + } + if (HasOptionalCord) { + output.WriteString(25, OptionalCord); + } + foreach (int element in RepeatedInt32List) { + output.WriteInt32(31, element); + } + foreach (long element in RepeatedInt64List) { + output.WriteInt64(32, element); + } + foreach (uint element in RepeatedUint32List) { + output.WriteUInt32(33, element); + } + foreach (ulong element in RepeatedUint64List) { + output.WriteUInt64(34, element); + } + foreach (int element in RepeatedSint32List) { + output.WriteSInt32(35, element); + } + foreach (long element in RepeatedSint64List) { + output.WriteSInt64(36, element); + } + foreach (uint element in RepeatedFixed32List) { + output.WriteFixed32(37, element); + } + foreach (ulong element in RepeatedFixed64List) { + output.WriteFixed64(38, element); + } + foreach (int element in RepeatedSfixed32List) { + output.WriteSFixed32(39, element); + } + foreach (long element in RepeatedSfixed64List) { + output.WriteSFixed64(40, element); + } + foreach (float element in RepeatedFloatList) { + output.WriteFloat(41, element); + } + foreach (double element in RepeatedDoubleList) { + output.WriteDouble(42, element); + } + foreach (bool element in RepeatedBoolList) { + output.WriteBool(43, element); + } + foreach (string element in RepeatedStringList) { + output.WriteString(44, element); + } + foreach (pb::ByteString element in RepeatedBytesList) { + output.WriteBytes(45, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup element in RepeatedGroupList) { + output.WriteGroup(46, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage element in RepeatedNestedMessageList) { + output.WriteMessage(48, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedForeignMessageList) { + output.WriteMessage(49, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ImportMessage element in RepeatedImportMessageList) { + output.WriteMessage(50, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum element in RepeatedNestedEnumList) { + output.WriteEnum(51, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedForeignEnumList) { + output.WriteEnum(52, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ImportEnum element in RepeatedImportEnumList) { + output.WriteEnum(53, (int) element); + } + foreach (string element in RepeatedStringPieceList) { + output.WriteString(54, element); + } + foreach (string element in RepeatedCordList) { + output.WriteString(55, element); + } + if (HasDefaultInt32) { + output.WriteInt32(61, DefaultInt32); + } + if (HasDefaultInt64) { + output.WriteInt64(62, DefaultInt64); + } + if (HasDefaultUint32) { + output.WriteUInt32(63, DefaultUint32); + } + if (HasDefaultUint64) { + output.WriteUInt64(64, DefaultUint64); + } + if (HasDefaultSint32) { + output.WriteSInt32(65, DefaultSint32); + } + if (HasDefaultSint64) { + output.WriteSInt64(66, DefaultSint64); + } + if (HasDefaultFixed32) { + output.WriteFixed32(67, DefaultFixed32); + } + if (HasDefaultFixed64) { + output.WriteFixed64(68, DefaultFixed64); + } + if (HasDefaultSfixed32) { + output.WriteSFixed32(69, DefaultSfixed32); + } + if (HasDefaultSfixed64) { + output.WriteSFixed64(70, DefaultSfixed64); + } + if (HasDefaultFloat) { + output.WriteFloat(71, DefaultFloat); + } + if (HasDefaultDouble) { + output.WriteDouble(72, DefaultDouble); + } + if (HasDefaultBool) { + output.WriteBool(73, DefaultBool); + } + if (HasDefaultString) { + output.WriteString(74, DefaultString); + } + if (HasDefaultBytes) { + output.WriteBytes(75, DefaultBytes); + } + if (HasDefaultNestedEnum) { + output.WriteEnum(81, (int) DefaultNestedEnum); + } + if (HasDefaultForeignEnum) { + output.WriteEnum(82, (int) DefaultForeignEnum); + } + if (HasDefaultImportEnum) { + output.WriteEnum(83, (int) DefaultImportEnum); + } + if (HasDefaultStringPiece) { + output.WriteString(84, DefaultStringPiece); + } + if (HasDefaultCord) { + output.WriteString(85, DefaultCord); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasOptionalInt32) { + size += pb::CodedOutputStream.ComputeInt32Size(1, OptionalInt32); + } + if (HasOptionalInt64) { + size += pb::CodedOutputStream.ComputeInt64Size(2, OptionalInt64); + } + if (HasOptionalUint32) { + size += pb::CodedOutputStream.ComputeUInt32Size(3, OptionalUint32); + } + if (HasOptionalUint64) { + size += pb::CodedOutputStream.ComputeUInt64Size(4, OptionalUint64); + } + if (HasOptionalSint32) { + size += pb::CodedOutputStream.ComputeSInt32Size(5, OptionalSint32); + } + if (HasOptionalSint64) { + size += pb::CodedOutputStream.ComputeSInt64Size(6, OptionalSint64); + } + if (HasOptionalFixed32) { + size += pb::CodedOutputStream.ComputeFixed32Size(7, OptionalFixed32); + } + if (HasOptionalFixed64) { + size += pb::CodedOutputStream.ComputeFixed64Size(8, OptionalFixed64); + } + if (HasOptionalSfixed32) { + size += pb::CodedOutputStream.ComputeSFixed32Size(9, OptionalSfixed32); + } + if (HasOptionalSfixed64) { + size += pb::CodedOutputStream.ComputeSFixed64Size(10, OptionalSfixed64); + } + if (HasOptionalFloat) { + size += pb::CodedOutputStream.ComputeFloatSize(11, OptionalFloat); + } + if (HasOptionalDouble) { + size += pb::CodedOutputStream.ComputeDoubleSize(12, OptionalDouble); + } + if (HasOptionalBool) { + size += pb::CodedOutputStream.ComputeBoolSize(13, OptionalBool); + } + if (HasOptionalString) { + size += pb::CodedOutputStream.ComputeStringSize(14, OptionalString); + } + if (HasOptionalBytes) { + size += pb::CodedOutputStream.ComputeBytesSize(15, OptionalBytes); + } + if (HasOptionalGroup) { + size += pb::CodedOutputStream.ComputeGroupSize(16, OptionalGroup); + } + if (HasOptionalNestedMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(18, OptionalNestedMessage); + } + if (HasOptionalForeignMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(19, OptionalForeignMessage); + } + if (HasOptionalImportMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(20, OptionalImportMessage); + } + if (HasOptionalNestedEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(21, (int) OptionalNestedEnum); + } + if (HasOptionalForeignEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(22, (int) OptionalForeignEnum); + } + if (HasOptionalImportEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(23, (int) OptionalImportEnum); + } + if (HasOptionalStringPiece) { + size += pb::CodedOutputStream.ComputeStringSize(24, OptionalStringPiece); + } + if (HasOptionalCord) { + size += pb::CodedOutputStream.ComputeStringSize(25, OptionalCord); + } + foreach (int element in RepeatedInt32List) { + size += pb::CodedOutputStream.ComputeInt32Size(31, element); + } + foreach (long element in RepeatedInt64List) { + size += pb::CodedOutputStream.ComputeInt64Size(32, element); + } + foreach (uint element in RepeatedUint32List) { + size += pb::CodedOutputStream.ComputeUInt32Size(33, element); + } + foreach (ulong element in RepeatedUint64List) { + size += pb::CodedOutputStream.ComputeUInt64Size(34, element); + } + foreach (int element in RepeatedSint32List) { + size += pb::CodedOutputStream.ComputeSInt32Size(35, element); + } + foreach (long element in RepeatedSint64List) { + size += pb::CodedOutputStream.ComputeSInt64Size(36, element); + } + foreach (uint element in RepeatedFixed32List) { + size += pb::CodedOutputStream.ComputeFixed32Size(37, element); + } + foreach (ulong element in RepeatedFixed64List) { + size += pb::CodedOutputStream.ComputeFixed64Size(38, element); + } + foreach (int element in RepeatedSfixed32List) { + size += pb::CodedOutputStream.ComputeSFixed32Size(39, element); + } + foreach (long element in RepeatedSfixed64List) { + size += pb::CodedOutputStream.ComputeSFixed64Size(40, element); + } + foreach (float element in RepeatedFloatList) { + size += pb::CodedOutputStream.ComputeFloatSize(41, element); + } + foreach (double element in RepeatedDoubleList) { + size += pb::CodedOutputStream.ComputeDoubleSize(42, element); + } + foreach (bool element in RepeatedBoolList) { + size += pb::CodedOutputStream.ComputeBoolSize(43, element); + } + foreach (string element in RepeatedStringList) { + size += pb::CodedOutputStream.ComputeStringSize(44, element); + } + foreach (pb::ByteString element in RepeatedBytesList) { + size += pb::CodedOutputStream.ComputeBytesSize(45, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup element in RepeatedGroupList) { + size += pb::CodedOutputStream.ComputeGroupSize(46, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage element in RepeatedNestedMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(48, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedForeignMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(49, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ImportMessage element in RepeatedImportMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(50, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum element in RepeatedNestedEnumList) { + size += pb::CodedOutputStream.ComputeEnumSize(51, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedForeignEnumList) { + size += pb::CodedOutputStream.ComputeEnumSize(52, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ImportEnum element in RepeatedImportEnumList) { + size += pb::CodedOutputStream.ComputeEnumSize(53, (int) element); + } + foreach (string element in RepeatedStringPieceList) { + size += pb::CodedOutputStream.ComputeStringSize(54, element); + } + foreach (string element in RepeatedCordList) { + size += pb::CodedOutputStream.ComputeStringSize(55, element); + } + if (HasDefaultInt32) { + size += pb::CodedOutputStream.ComputeInt32Size(61, DefaultInt32); + } + if (HasDefaultInt64) { + size += pb::CodedOutputStream.ComputeInt64Size(62, DefaultInt64); + } + if (HasDefaultUint32) { + size += pb::CodedOutputStream.ComputeUInt32Size(63, DefaultUint32); + } + if (HasDefaultUint64) { + size += pb::CodedOutputStream.ComputeUInt64Size(64, DefaultUint64); + } + if (HasDefaultSint32) { + size += pb::CodedOutputStream.ComputeSInt32Size(65, DefaultSint32); + } + if (HasDefaultSint64) { + size += pb::CodedOutputStream.ComputeSInt64Size(66, DefaultSint64); + } + if (HasDefaultFixed32) { + size += pb::CodedOutputStream.ComputeFixed32Size(67, DefaultFixed32); + } + if (HasDefaultFixed64) { + size += pb::CodedOutputStream.ComputeFixed64Size(68, DefaultFixed64); + } + if (HasDefaultSfixed32) { + size += pb::CodedOutputStream.ComputeSFixed32Size(69, DefaultSfixed32); + } + if (HasDefaultSfixed64) { + size += pb::CodedOutputStream.ComputeSFixed64Size(70, DefaultSfixed64); + } + if (HasDefaultFloat) { + size += pb::CodedOutputStream.ComputeFloatSize(71, DefaultFloat); + } + if (HasDefaultDouble) { + size += pb::CodedOutputStream.ComputeDoubleSize(72, DefaultDouble); + } + if (HasDefaultBool) { + size += pb::CodedOutputStream.ComputeBoolSize(73, DefaultBool); + } + if (HasDefaultString) { + size += pb::CodedOutputStream.ComputeStringSize(74, DefaultString); + } + if (HasDefaultBytes) { + size += pb::CodedOutputStream.ComputeBytesSize(75, DefaultBytes); + } + if (HasDefaultNestedEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(81, (int) DefaultNestedEnum); + } + if (HasDefaultForeignEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(82, (int) DefaultForeignEnum); + } + if (HasDefaultImportEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(83, (int) DefaultImportEnum); + } + if (HasDefaultStringPiece) { + size += pb::CodedOutputStream.ComputeStringSize(84, DefaultStringPiece); + } + if (HasDefaultCord) { + size += pb::CodedOutputStream.ComputeStringSize(85, DefaultCord); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestAllTypes ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestAllTypes ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestAllTypes ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestAllTypes ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestAllTypes ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestAllTypes ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestAllTypes ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestAllTypes ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestAllTypes prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestAllTypes result = new TestAllTypes(); + + protected override TestAllTypes MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestAllTypes(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestAllTypes.Descriptor; } + } + + public override TestAllTypes DefaultInstanceForType { + get { return TestAllTypes.DefaultInstance; } + } + + public override TestAllTypes BuildPartial() { + result.repeatedInt32_.MakeReadOnly(); + result.repeatedInt64_.MakeReadOnly(); + result.repeatedUint32_.MakeReadOnly(); + result.repeatedUint64_.MakeReadOnly(); + result.repeatedSint32_.MakeReadOnly(); + result.repeatedSint64_.MakeReadOnly(); + result.repeatedFixed32_.MakeReadOnly(); + result.repeatedFixed64_.MakeReadOnly(); + result.repeatedSfixed32_.MakeReadOnly(); + result.repeatedSfixed64_.MakeReadOnly(); + result.repeatedFloat_.MakeReadOnly(); + result.repeatedDouble_.MakeReadOnly(); + result.repeatedBool_.MakeReadOnly(); + result.repeatedString_.MakeReadOnly(); + result.repeatedBytes_.MakeReadOnly(); + result.repeatedGroup_.MakeReadOnly(); + result.repeatedNestedMessage_.MakeReadOnly(); + result.repeatedForeignMessage_.MakeReadOnly(); + result.repeatedImportMessage_.MakeReadOnly(); + result.repeatedNestedEnum_.MakeReadOnly(); + result.repeatedForeignEnum_.MakeReadOnly(); + result.repeatedImportEnum_.MakeReadOnly(); + result.repeatedStringPiece_.MakeReadOnly(); + result.repeatedCord_.MakeReadOnly(); + TestAllTypes returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestAllTypes) { + return MergeFrom((TestAllTypes) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestAllTypes other) { + if (other == TestAllTypes.DefaultInstance) return this; + if (other.HasOptionalInt32) { + OptionalInt32 = other.OptionalInt32; + } + if (other.HasOptionalInt64) { + OptionalInt64 = other.OptionalInt64; + } + if (other.HasOptionalUint32) { + OptionalUint32 = other.OptionalUint32; + } + if (other.HasOptionalUint64) { + OptionalUint64 = other.OptionalUint64; + } + if (other.HasOptionalSint32) { + OptionalSint32 = other.OptionalSint32; + } + if (other.HasOptionalSint64) { + OptionalSint64 = other.OptionalSint64; + } + if (other.HasOptionalFixed32) { + OptionalFixed32 = other.OptionalFixed32; + } + if (other.HasOptionalFixed64) { + OptionalFixed64 = other.OptionalFixed64; + } + if (other.HasOptionalSfixed32) { + OptionalSfixed32 = other.OptionalSfixed32; + } + if (other.HasOptionalSfixed64) { + OptionalSfixed64 = other.OptionalSfixed64; + } + if (other.HasOptionalFloat) { + OptionalFloat = other.OptionalFloat; + } + if (other.HasOptionalDouble) { + OptionalDouble = other.OptionalDouble; + } + if (other.HasOptionalBool) { + OptionalBool = other.OptionalBool; + } + if (other.HasOptionalString) { + OptionalString = other.OptionalString; + } + if (other.HasOptionalBytes) { + OptionalBytes = other.OptionalBytes; + } + if (other.HasOptionalGroup) { + MergeOptionalGroup(other.OptionalGroup); + } + if (other.HasOptionalNestedMessage) { + MergeOptionalNestedMessage(other.OptionalNestedMessage); + } + if (other.HasOptionalForeignMessage) { + MergeOptionalForeignMessage(other.OptionalForeignMessage); + } + if (other.HasOptionalImportMessage) { + MergeOptionalImportMessage(other.OptionalImportMessage); + } + if (other.HasOptionalNestedEnum) { + OptionalNestedEnum = other.OptionalNestedEnum; + } + if (other.HasOptionalForeignEnum) { + OptionalForeignEnum = other.OptionalForeignEnum; + } + if (other.HasOptionalImportEnum) { + OptionalImportEnum = other.OptionalImportEnum; + } + if (other.HasOptionalStringPiece) { + OptionalStringPiece = other.OptionalStringPiece; + } + if (other.HasOptionalCord) { + OptionalCord = other.OptionalCord; + } + if (other.repeatedInt32_.Count != 0) { + base.AddRange(other.repeatedInt32_, result.repeatedInt32_); + } + if (other.repeatedInt64_.Count != 0) { + base.AddRange(other.repeatedInt64_, result.repeatedInt64_); + } + if (other.repeatedUint32_.Count != 0) { + base.AddRange(other.repeatedUint32_, result.repeatedUint32_); + } + if (other.repeatedUint64_.Count != 0) { + base.AddRange(other.repeatedUint64_, result.repeatedUint64_); + } + if (other.repeatedSint32_.Count != 0) { + base.AddRange(other.repeatedSint32_, result.repeatedSint32_); + } + if (other.repeatedSint64_.Count != 0) { + base.AddRange(other.repeatedSint64_, result.repeatedSint64_); + } + if (other.repeatedFixed32_.Count != 0) { + base.AddRange(other.repeatedFixed32_, result.repeatedFixed32_); + } + if (other.repeatedFixed64_.Count != 0) { + base.AddRange(other.repeatedFixed64_, result.repeatedFixed64_); + } + if (other.repeatedSfixed32_.Count != 0) { + base.AddRange(other.repeatedSfixed32_, result.repeatedSfixed32_); + } + if (other.repeatedSfixed64_.Count != 0) { + base.AddRange(other.repeatedSfixed64_, result.repeatedSfixed64_); + } + if (other.repeatedFloat_.Count != 0) { + base.AddRange(other.repeatedFloat_, result.repeatedFloat_); + } + if (other.repeatedDouble_.Count != 0) { + base.AddRange(other.repeatedDouble_, result.repeatedDouble_); + } + if (other.repeatedBool_.Count != 0) { + base.AddRange(other.repeatedBool_, result.repeatedBool_); + } + if (other.repeatedString_.Count != 0) { + base.AddRange(other.repeatedString_, result.repeatedString_); + } + if (other.repeatedBytes_.Count != 0) { + base.AddRange(other.repeatedBytes_, result.repeatedBytes_); + } + if (other.repeatedGroup_.Count != 0) { + base.AddRange(other.repeatedGroup_, result.repeatedGroup_); + } + if (other.repeatedNestedMessage_.Count != 0) { + base.AddRange(other.repeatedNestedMessage_, result.repeatedNestedMessage_); + } + if (other.repeatedForeignMessage_.Count != 0) { + base.AddRange(other.repeatedForeignMessage_, result.repeatedForeignMessage_); + } + if (other.repeatedImportMessage_.Count != 0) { + base.AddRange(other.repeatedImportMessage_, result.repeatedImportMessage_); + } + if (other.repeatedNestedEnum_.Count != 0) { + base.AddRange(other.repeatedNestedEnum_, result.repeatedNestedEnum_); + } + if (other.repeatedForeignEnum_.Count != 0) { + base.AddRange(other.repeatedForeignEnum_, result.repeatedForeignEnum_); + } + if (other.repeatedImportEnum_.Count != 0) { + base.AddRange(other.repeatedImportEnum_, result.repeatedImportEnum_); + } + if (other.repeatedStringPiece_.Count != 0) { + base.AddRange(other.repeatedStringPiece_, result.repeatedStringPiece_); + } + if (other.repeatedCord_.Count != 0) { + base.AddRange(other.repeatedCord_, result.repeatedCord_); + } + if (other.HasDefaultInt32) { + DefaultInt32 = other.DefaultInt32; + } + if (other.HasDefaultInt64) { + DefaultInt64 = other.DefaultInt64; + } + if (other.HasDefaultUint32) { + DefaultUint32 = other.DefaultUint32; + } + if (other.HasDefaultUint64) { + DefaultUint64 = other.DefaultUint64; + } + if (other.HasDefaultSint32) { + DefaultSint32 = other.DefaultSint32; + } + if (other.HasDefaultSint64) { + DefaultSint64 = other.DefaultSint64; + } + if (other.HasDefaultFixed32) { + DefaultFixed32 = other.DefaultFixed32; + } + if (other.HasDefaultFixed64) { + DefaultFixed64 = other.DefaultFixed64; + } + if (other.HasDefaultSfixed32) { + DefaultSfixed32 = other.DefaultSfixed32; + } + if (other.HasDefaultSfixed64) { + DefaultSfixed64 = other.DefaultSfixed64; + } + if (other.HasDefaultFloat) { + DefaultFloat = other.DefaultFloat; + } + if (other.HasDefaultDouble) { + DefaultDouble = other.DefaultDouble; + } + if (other.HasDefaultBool) { + DefaultBool = other.DefaultBool; + } + if (other.HasDefaultString) { + DefaultString = other.DefaultString; + } + if (other.HasDefaultBytes) { + DefaultBytes = other.DefaultBytes; + } + if (other.HasDefaultNestedEnum) { + DefaultNestedEnum = other.DefaultNestedEnum; + } + if (other.HasDefaultForeignEnum) { + DefaultForeignEnum = other.DefaultForeignEnum; + } + if (other.HasDefaultImportEnum) { + DefaultImportEnum = other.DefaultImportEnum; + } + if (other.HasDefaultStringPiece) { + DefaultStringPiece = other.DefaultStringPiece; + } + if (other.HasDefaultCord) { + DefaultCord = other.DefaultCord; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + OptionalInt32 = input.ReadInt32(); + break; + } + case 16: { + OptionalInt64 = input.ReadInt64(); + break; + } + case 24: { + OptionalUint32 = input.ReadUInt32(); + break; + } + case 32: { + OptionalUint64 = input.ReadUInt64(); + break; + } + case 40: { + OptionalSint32 = input.ReadSInt32(); + break; + } + case 48: { + OptionalSint64 = input.ReadSInt64(); + break; + } + case 61: { + OptionalFixed32 = input.ReadFixed32(); + break; + } + case 65: { + OptionalFixed64 = input.ReadFixed64(); + break; + } + case 77: { + OptionalSfixed32 = input.ReadSFixed32(); + break; + } + case 81: { + OptionalSfixed64 = input.ReadSFixed64(); + break; + } + case 93: { + OptionalFloat = input.ReadFloat(); + break; + } + case 97: { + OptionalDouble = input.ReadDouble(); + break; + } + case 104: { + OptionalBool = input.ReadBool(); + break; + } + case 114: { + OptionalString = input.ReadString(); + break; + } + case 122: { + OptionalBytes = input.ReadBytes(); + break; + } + case 131: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.CreateBuilder(); + if (HasOptionalGroup) { + subBuilder.MergeFrom(OptionalGroup); + } + input.ReadGroup(16, subBuilder, extensionRegistry); + OptionalGroup = subBuilder.BuildPartial(); + break; + } + case 146: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(); + if (HasOptionalNestedMessage) { + subBuilder.MergeFrom(OptionalNestedMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalNestedMessage = subBuilder.BuildPartial(); + break; + } + case 154: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + if (HasOptionalForeignMessage) { + subBuilder.MergeFrom(OptionalForeignMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalForeignMessage = subBuilder.BuildPartial(); + break; + } + case 162: { + global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ImportMessage.CreateBuilder(); + if (HasOptionalImportMessage) { + subBuilder.MergeFrom(OptionalImportMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalImportMessage = subBuilder.BuildPartial(); + break; + } + case 168: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum), rawValue)) { + unknownFields.MergeVarintField(21, (ulong) rawValue); + } else { + OptionalNestedEnum = (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum) rawValue; + } + break; + } + case 176: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(22, (ulong) rawValue); + } else { + OptionalForeignEnum = (global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue; + } + break; + } + case 184: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ImportEnum), rawValue)) { + unknownFields.MergeVarintField(23, (ulong) rawValue); + } else { + OptionalImportEnum = (global::Google.ProtocolBuffers.TestProtos.ImportEnum) rawValue; + } + break; + } + case 194: { + OptionalStringPiece = input.ReadString(); + break; + } + case 202: { + OptionalCord = input.ReadString(); + break; + } + case 248: { + AddRepeatedInt32(input.ReadInt32()); + break; + } + case 256: { + AddRepeatedInt64(input.ReadInt64()); + break; + } + case 264: { + AddRepeatedUint32(input.ReadUInt32()); + break; + } + case 272: { + AddRepeatedUint64(input.ReadUInt64()); + break; + } + case 280: { + AddRepeatedSint32(input.ReadSInt32()); + break; + } + case 288: { + AddRepeatedSint64(input.ReadSInt64()); + break; + } + case 301: { + AddRepeatedFixed32(input.ReadFixed32()); + break; + } + case 305: { + AddRepeatedFixed64(input.ReadFixed64()); + break; + } + case 317: { + AddRepeatedSfixed32(input.ReadSFixed32()); + break; + } + case 321: { + AddRepeatedSfixed64(input.ReadSFixed64()); + break; + } + case 333: { + AddRepeatedFloat(input.ReadFloat()); + break; + } + case 337: { + AddRepeatedDouble(input.ReadDouble()); + break; + } + case 344: { + AddRepeatedBool(input.ReadBool()); + break; + } + case 354: { + AddRepeatedString(input.ReadString()); + break; + } + case 362: { + AddRepeatedBytes(input.ReadBytes()); + break; + } + case 371: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.CreateBuilder(); + input.ReadGroup(46, subBuilder, extensionRegistry); + AddRepeatedGroup(subBuilder.BuildPartial()); + break; + } + case 386: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedNestedMessage(subBuilder.BuildPartial()); + break; + } + case 394: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedForeignMessage(subBuilder.BuildPartial()); + break; + } + case 402: { + global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ImportMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedImportMessage(subBuilder.BuildPartial()); + break; + } + case 408: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum), rawValue)) { + unknownFields.MergeVarintField(51, (ulong) rawValue); + } else { + AddRepeatedNestedEnum((global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum) rawValue); + } + break; + } + case 416: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(52, (ulong) rawValue); + } else { + AddRepeatedForeignEnum((global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue); + } + break; + } + case 424: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ImportEnum), rawValue)) { + unknownFields.MergeVarintField(53, (ulong) rawValue); + } else { + AddRepeatedImportEnum((global::Google.ProtocolBuffers.TestProtos.ImportEnum) rawValue); + } + break; + } + case 434: { + AddRepeatedStringPiece(input.ReadString()); + break; + } + case 442: { + AddRepeatedCord(input.ReadString()); + break; + } + case 488: { + DefaultInt32 = input.ReadInt32(); + break; + } + case 496: { + DefaultInt64 = input.ReadInt64(); + break; + } + case 504: { + DefaultUint32 = input.ReadUInt32(); + break; + } + case 512: { + DefaultUint64 = input.ReadUInt64(); + break; + } + case 520: { + DefaultSint32 = input.ReadSInt32(); + break; + } + case 528: { + DefaultSint64 = input.ReadSInt64(); + break; + } + case 541: { + DefaultFixed32 = input.ReadFixed32(); + break; + } + case 545: { + DefaultFixed64 = input.ReadFixed64(); + break; + } + case 557: { + DefaultSfixed32 = input.ReadSFixed32(); + break; + } + case 561: { + DefaultSfixed64 = input.ReadSFixed64(); + break; + } + case 573: { + DefaultFloat = input.ReadFloat(); + break; + } + case 577: { + DefaultDouble = input.ReadDouble(); + break; + } + case 584: { + DefaultBool = input.ReadBool(); + break; + } + case 594: { + DefaultString = input.ReadString(); + break; + } + case 602: { + DefaultBytes = input.ReadBytes(); + break; + } + case 648: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum), rawValue)) { + unknownFields.MergeVarintField(81, (ulong) rawValue); + } else { + DefaultNestedEnum = (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum) rawValue; + } + break; + } + case 656: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(82, (ulong) rawValue); + } else { + DefaultForeignEnum = (global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue; + } + break; + } + case 664: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ImportEnum), rawValue)) { + unknownFields.MergeVarintField(83, (ulong) rawValue); + } else { + DefaultImportEnum = (global::Google.ProtocolBuffers.TestProtos.ImportEnum) rawValue; + } + break; + } + case 674: { + DefaultStringPiece = input.ReadString(); + break; + } + case 682: { + DefaultCord = input.ReadString(); + break; + } + } + } + } + + + public bool HasOptionalInt32 { + get { return result.HasOptionalInt32; } + } + public int OptionalInt32 { + get { return result.OptionalInt32; } + set { SetOptionalInt32(value); } + } + public Builder SetOptionalInt32(int value) { + result.hasOptionalInt32 = true; + result.optionalInt32_ = value; + return this; + } + public Builder ClearOptionalInt32() { + result.hasOptionalInt32 = false; + result.optionalInt32_ = 0; + return this; + } + + public bool HasOptionalInt64 { + get { return result.HasOptionalInt64; } + } + public long OptionalInt64 { + get { return result.OptionalInt64; } + set { SetOptionalInt64(value); } + } + public Builder SetOptionalInt64(long value) { + result.hasOptionalInt64 = true; + result.optionalInt64_ = value; + return this; + } + public Builder ClearOptionalInt64() { + result.hasOptionalInt64 = false; + result.optionalInt64_ = 0L; + return this; + } + + public bool HasOptionalUint32 { + get { return result.HasOptionalUint32; } + } + public uint OptionalUint32 { + get { return result.OptionalUint32; } + set { SetOptionalUint32(value); } + } + public Builder SetOptionalUint32(uint value) { + result.hasOptionalUint32 = true; + result.optionalUint32_ = value; + return this; + } + public Builder ClearOptionalUint32() { + result.hasOptionalUint32 = false; + result.optionalUint32_ = 0; + return this; + } + + public bool HasOptionalUint64 { + get { return result.HasOptionalUint64; } + } + public ulong OptionalUint64 { + get { return result.OptionalUint64; } + set { SetOptionalUint64(value); } + } + public Builder SetOptionalUint64(ulong value) { + result.hasOptionalUint64 = true; + result.optionalUint64_ = value; + return this; + } + public Builder ClearOptionalUint64() { + result.hasOptionalUint64 = false; + result.optionalUint64_ = 0UL; + return this; + } + + public bool HasOptionalSint32 { + get { return result.HasOptionalSint32; } + } + public int OptionalSint32 { + get { return result.OptionalSint32; } + set { SetOptionalSint32(value); } + } + public Builder SetOptionalSint32(int value) { + result.hasOptionalSint32 = true; + result.optionalSint32_ = value; + return this; + } + public Builder ClearOptionalSint32() { + result.hasOptionalSint32 = false; + result.optionalSint32_ = 0; + return this; + } + + public bool HasOptionalSint64 { + get { return result.HasOptionalSint64; } + } + public long OptionalSint64 { + get { return result.OptionalSint64; } + set { SetOptionalSint64(value); } + } + public Builder SetOptionalSint64(long value) { + result.hasOptionalSint64 = true; + result.optionalSint64_ = value; + return this; + } + public Builder ClearOptionalSint64() { + result.hasOptionalSint64 = false; + result.optionalSint64_ = 0; + return this; + } + + public bool HasOptionalFixed32 { + get { return result.HasOptionalFixed32; } + } + public uint OptionalFixed32 { + get { return result.OptionalFixed32; } + set { SetOptionalFixed32(value); } + } + public Builder SetOptionalFixed32(uint value) { + result.hasOptionalFixed32 = true; + result.optionalFixed32_ = value; + return this; + } + public Builder ClearOptionalFixed32() { + result.hasOptionalFixed32 = false; + result.optionalFixed32_ = 0; + return this; + } + + public bool HasOptionalFixed64 { + get { return result.HasOptionalFixed64; } + } + public ulong OptionalFixed64 { + get { return result.OptionalFixed64; } + set { SetOptionalFixed64(value); } + } + public Builder SetOptionalFixed64(ulong value) { + result.hasOptionalFixed64 = true; + result.optionalFixed64_ = value; + return this; + } + public Builder ClearOptionalFixed64() { + result.hasOptionalFixed64 = false; + result.optionalFixed64_ = 0; + return this; + } + + public bool HasOptionalSfixed32 { + get { return result.HasOptionalSfixed32; } + } + public int OptionalSfixed32 { + get { return result.OptionalSfixed32; } + set { SetOptionalSfixed32(value); } + } + public Builder SetOptionalSfixed32(int value) { + result.hasOptionalSfixed32 = true; + result.optionalSfixed32_ = value; + return this; + } + public Builder ClearOptionalSfixed32() { + result.hasOptionalSfixed32 = false; + result.optionalSfixed32_ = 0; + return this; + } + + public bool HasOptionalSfixed64 { + get { return result.HasOptionalSfixed64; } + } + public long OptionalSfixed64 { + get { return result.OptionalSfixed64; } + set { SetOptionalSfixed64(value); } + } + public Builder SetOptionalSfixed64(long value) { + result.hasOptionalSfixed64 = true; + result.optionalSfixed64_ = value; + return this; + } + public Builder ClearOptionalSfixed64() { + result.hasOptionalSfixed64 = false; + result.optionalSfixed64_ = 0; + return this; + } + + public bool HasOptionalFloat { + get { return result.HasOptionalFloat; } + } + public float OptionalFloat { + get { return result.OptionalFloat; } + set { SetOptionalFloat(value); } + } + public Builder SetOptionalFloat(float value) { + result.hasOptionalFloat = true; + result.optionalFloat_ = value; + return this; + } + public Builder ClearOptionalFloat() { + result.hasOptionalFloat = false; + result.optionalFloat_ = 0F; + return this; + } + + public bool HasOptionalDouble { + get { return result.HasOptionalDouble; } + } + public double OptionalDouble { + get { return result.OptionalDouble; } + set { SetOptionalDouble(value); } + } + public Builder SetOptionalDouble(double value) { + result.hasOptionalDouble = true; + result.optionalDouble_ = value; + return this; + } + public Builder ClearOptionalDouble() { + result.hasOptionalDouble = false; + result.optionalDouble_ = 0D; + return this; + } + + public bool HasOptionalBool { + get { return result.HasOptionalBool; } + } + public bool OptionalBool { + get { return result.OptionalBool; } + set { SetOptionalBool(value); } + } + public Builder SetOptionalBool(bool value) { + result.hasOptionalBool = true; + result.optionalBool_ = value; + return this; + } + public Builder ClearOptionalBool() { + result.hasOptionalBool = false; + result.optionalBool_ = false; + return this; + } + + public bool HasOptionalString { + get { return result.HasOptionalString; } + } + public string OptionalString { + get { return result.OptionalString; } + set { SetOptionalString(value); } + } + public Builder SetOptionalString(string value) { + result.hasOptionalString = true; + result.optionalString_ = value; + return this; + } + public Builder ClearOptionalString() { + result.hasOptionalString = false; + result.optionalString_ = ""; + return this; + } + + public bool HasOptionalBytes { + get { return result.HasOptionalBytes; } + } + public pb::ByteString OptionalBytes { + get { return result.OptionalBytes; } + set { SetOptionalBytes(value); } + } + public Builder SetOptionalBytes(pb::ByteString value) { + result.hasOptionalBytes = true; + result.optionalBytes_ = value; + return this; + } + public Builder ClearOptionalBytes() { + result.hasOptionalBytes = false; + result.optionalBytes_ = pb::ByteString.Empty; + return this; + } + + public bool HasOptionalGroup { + get { return result.HasOptionalGroup; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup OptionalGroup { + get { return result.OptionalGroup; } + set { SetOptionalGroup(value); } + } + public Builder SetOptionalGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup value) { + result.hasOptionalGroup = true; + result.optionalGroup_ = value; + return this; + } + public Builder SetOptionalGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.Builder builderForValue) { + result.hasOptionalGroup = true; + result.optionalGroup_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup value) { + if (result.HasOptionalGroup && + result.optionalGroup_ != global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.DefaultInstance) { + result.optionalGroup_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.CreateBuilder(result.optionalGroup_).MergeFrom(value).BuildPartial(); + } else { + result.optionalGroup_ = value; + } + result.hasOptionalGroup = true; + return this; + } + public Builder ClearOptionalGroup() { + result.hasOptionalGroup = false; + result.optionalGroup_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.DefaultInstance; + return this; + } + + public bool HasOptionalNestedMessage { + get { return result.HasOptionalNestedMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage OptionalNestedMessage { + get { return result.OptionalNestedMessage; } + set { SetOptionalNestedMessage(value); } + } + public Builder SetOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + result.hasOptionalNestedMessage = true; + result.optionalNestedMessage_ = value; + return this; + } + public Builder SetOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder builderForValue) { + result.hasOptionalNestedMessage = true; + result.optionalNestedMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + if (result.HasOptionalNestedMessage && + result.optionalNestedMessage_ != global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance) { + result.optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(result.optionalNestedMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalNestedMessage_ = value; + } + result.hasOptionalNestedMessage = true; + return this; + } + public Builder ClearOptionalNestedMessage() { + result.hasOptionalNestedMessage = false; + result.optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance; + return this; + } + + public bool HasOptionalForeignMessage { + get { return result.HasOptionalForeignMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage OptionalForeignMessage { + get { return result.OptionalForeignMessage; } + set { SetOptionalForeignMessage(value); } + } + public Builder SetOptionalForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.hasOptionalForeignMessage = true; + result.optionalForeignMessage_ = value; + return this; + } + public Builder SetOptionalForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.hasOptionalForeignMessage = true; + result.optionalForeignMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + if (result.HasOptionalForeignMessage && + result.optionalForeignMessage_ != global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance) { + result.optionalForeignMessage_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(result.optionalForeignMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalForeignMessage_ = value; + } + result.hasOptionalForeignMessage = true; + return this; + } + public Builder ClearOptionalForeignMessage() { + result.hasOptionalForeignMessage = false; + result.optionalForeignMessage_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + return this; + } + + public bool HasOptionalImportMessage { + get { return result.HasOptionalImportMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportMessage OptionalImportMessage { + get { return result.OptionalImportMessage; } + set { SetOptionalImportMessage(value); } + } + public Builder SetOptionalImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage value) { + result.hasOptionalImportMessage = true; + result.optionalImportMessage_ = value; + return this; + } + public Builder SetOptionalImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder builderForValue) { + result.hasOptionalImportMessage = true; + result.optionalImportMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage value) { + if (result.HasOptionalImportMessage && + result.optionalImportMessage_ != global::Google.ProtocolBuffers.TestProtos.ImportMessage.DefaultInstance) { + result.optionalImportMessage_ = global::Google.ProtocolBuffers.TestProtos.ImportMessage.CreateBuilder(result.optionalImportMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalImportMessage_ = value; + } + result.hasOptionalImportMessage = true; + return this; + } + public Builder ClearOptionalImportMessage() { + result.hasOptionalImportMessage = false; + result.optionalImportMessage_ = global::Google.ProtocolBuffers.TestProtos.ImportMessage.DefaultInstance; + return this; + } + + public bool HasOptionalNestedEnum { + get { return result.HasOptionalNestedEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum OptionalNestedEnum { + get { return result.OptionalNestedEnum; } + set { SetOptionalNestedEnum(value); } + } + public Builder SetOptionalNestedEnum(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum value) { + result.hasOptionalNestedEnum = true; + result.optionalNestedEnum_ = value; + return this; + } + public Builder ClearOptionalNestedEnum() { + result.hasOptionalNestedEnum = false; + result.optionalNestedEnum_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum.FOO; + return this; + } + + public bool HasOptionalForeignEnum { + get { return result.HasOptionalForeignEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum OptionalForeignEnum { + get { return result.OptionalForeignEnum; } + set { SetOptionalForeignEnum(value); } + } + public Builder SetOptionalForeignEnum(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.hasOptionalForeignEnum = true; + result.optionalForeignEnum_ = value; + return this; + } + public Builder ClearOptionalForeignEnum() { + result.hasOptionalForeignEnum = false; + result.optionalForeignEnum_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_FOO; + return this; + } + + public bool HasOptionalImportEnum { + get { return result.HasOptionalImportEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum OptionalImportEnum { + get { return result.OptionalImportEnum; } + set { SetOptionalImportEnum(value); } + } + public Builder SetOptionalImportEnum(global::Google.ProtocolBuffers.TestProtos.ImportEnum value) { + result.hasOptionalImportEnum = true; + result.optionalImportEnum_ = value; + return this; + } + public Builder ClearOptionalImportEnum() { + result.hasOptionalImportEnum = false; + result.optionalImportEnum_ = global::Google.ProtocolBuffers.TestProtos.ImportEnum.IMPORT_FOO; + return this; + } + + public bool HasOptionalStringPiece { + get { return result.HasOptionalStringPiece; } + } + public string OptionalStringPiece { + get { return result.OptionalStringPiece; } + set { SetOptionalStringPiece(value); } + } + public Builder SetOptionalStringPiece(string value) { + result.hasOptionalStringPiece = true; + result.optionalStringPiece_ = value; + return this; + } + public Builder ClearOptionalStringPiece() { + result.hasOptionalStringPiece = false; + result.optionalStringPiece_ = ""; + return this; + } + + public bool HasOptionalCord { + get { return result.HasOptionalCord; } + } + public string OptionalCord { + get { return result.OptionalCord; } + set { SetOptionalCord(value); } + } + public Builder SetOptionalCord(string value) { + result.hasOptionalCord = true; + result.optionalCord_ = value; + return this; + } + public Builder ClearOptionalCord() { + result.hasOptionalCord = false; + result.optionalCord_ = ""; + return this; + } + + public scg::IList RepeatedInt32List { + get { return result.repeatedInt32_; } + } + public int RepeatedInt32Count { + get { return result.RepeatedInt32Count; } + } + public int GetRepeatedInt32(int index) { + return result.GetRepeatedInt32(index); + } + public Builder SetRepeatedInt32(int index, int value) { + result.repeatedInt32_[index] = value; + return this; + } + public Builder AddRepeatedInt32(int value) { + result.repeatedInt32_.Add(value); + return this; + } + public Builder AddRangeRepeatedInt32(scg::IEnumerable values) { + base.AddRange(values, result.repeatedInt32_); + return this; + } + public Builder ClearRepeatedInt32() { + result.repeatedInt32_.Clear(); + return this; + } + + public scg::IList RepeatedInt64List { + get { return result.repeatedInt64_; } + } + public int RepeatedInt64Count { + get { return result.RepeatedInt64Count; } + } + public long GetRepeatedInt64(int index) { + return result.GetRepeatedInt64(index); + } + public Builder SetRepeatedInt64(int index, long value) { + result.repeatedInt64_[index] = value; + return this; + } + public Builder AddRepeatedInt64(long value) { + result.repeatedInt64_.Add(value); + return this; + } + public Builder AddRangeRepeatedInt64(scg::IEnumerable values) { + base.AddRange(values, result.repeatedInt64_); + return this; + } + public Builder ClearRepeatedInt64() { + result.repeatedInt64_.Clear(); + return this; + } + + public scg::IList RepeatedUint32List { + get { return result.repeatedUint32_; } + } + public int RepeatedUint32Count { + get { return result.RepeatedUint32Count; } + } + public uint GetRepeatedUint32(int index) { + return result.GetRepeatedUint32(index); + } + public Builder SetRepeatedUint32(int index, uint value) { + result.repeatedUint32_[index] = value; + return this; + } + public Builder AddRepeatedUint32(uint value) { + result.repeatedUint32_.Add(value); + return this; + } + public Builder AddRangeRepeatedUint32(scg::IEnumerable values) { + base.AddRange(values, result.repeatedUint32_); + return this; + } + public Builder ClearRepeatedUint32() { + result.repeatedUint32_.Clear(); + return this; + } + + public scg::IList RepeatedUint64List { + get { return result.repeatedUint64_; } + } + public int RepeatedUint64Count { + get { return result.RepeatedUint64Count; } + } + public ulong GetRepeatedUint64(int index) { + return result.GetRepeatedUint64(index); + } + public Builder SetRepeatedUint64(int index, ulong value) { + result.repeatedUint64_[index] = value; + return this; + } + public Builder AddRepeatedUint64(ulong value) { + result.repeatedUint64_.Add(value); + return this; + } + public Builder AddRangeRepeatedUint64(scg::IEnumerable values) { + base.AddRange(values, result.repeatedUint64_); + return this; + } + public Builder ClearRepeatedUint64() { + result.repeatedUint64_.Clear(); + return this; + } + + public scg::IList RepeatedSint32List { + get { return result.repeatedSint32_; } + } + public int RepeatedSint32Count { + get { return result.RepeatedSint32Count; } + } + public int GetRepeatedSint32(int index) { + return result.GetRepeatedSint32(index); + } + public Builder SetRepeatedSint32(int index, int value) { + result.repeatedSint32_[index] = value; + return this; + } + public Builder AddRepeatedSint32(int value) { + result.repeatedSint32_.Add(value); + return this; + } + public Builder AddRangeRepeatedSint32(scg::IEnumerable values) { + base.AddRange(values, result.repeatedSint32_); + return this; + } + public Builder ClearRepeatedSint32() { + result.repeatedSint32_.Clear(); + return this; + } + + public scg::IList RepeatedSint64List { + get { return result.repeatedSint64_; } + } + public int RepeatedSint64Count { + get { return result.RepeatedSint64Count; } + } + public long GetRepeatedSint64(int index) { + return result.GetRepeatedSint64(index); + } + public Builder SetRepeatedSint64(int index, long value) { + result.repeatedSint64_[index] = value; + return this; + } + public Builder AddRepeatedSint64(long value) { + result.repeatedSint64_.Add(value); + return this; + } + public Builder AddRangeRepeatedSint64(scg::IEnumerable values) { + base.AddRange(values, result.repeatedSint64_); + return this; + } + public Builder ClearRepeatedSint64() { + result.repeatedSint64_.Clear(); + return this; + } + + public scg::IList RepeatedFixed32List { + get { return result.repeatedFixed32_; } + } + public int RepeatedFixed32Count { + get { return result.RepeatedFixed32Count; } + } + public uint GetRepeatedFixed32(int index) { + return result.GetRepeatedFixed32(index); + } + public Builder SetRepeatedFixed32(int index, uint value) { + result.repeatedFixed32_[index] = value; + return this; + } + public Builder AddRepeatedFixed32(uint value) { + result.repeatedFixed32_.Add(value); + return this; + } + public Builder AddRangeRepeatedFixed32(scg::IEnumerable values) { + base.AddRange(values, result.repeatedFixed32_); + return this; + } + public Builder ClearRepeatedFixed32() { + result.repeatedFixed32_.Clear(); + return this; + } + + public scg::IList RepeatedFixed64List { + get { return result.repeatedFixed64_; } + } + public int RepeatedFixed64Count { + get { return result.RepeatedFixed64Count; } + } + public ulong GetRepeatedFixed64(int index) { + return result.GetRepeatedFixed64(index); + } + public Builder SetRepeatedFixed64(int index, ulong value) { + result.repeatedFixed64_[index] = value; + return this; + } + public Builder AddRepeatedFixed64(ulong value) { + result.repeatedFixed64_.Add(value); + return this; + } + public Builder AddRangeRepeatedFixed64(scg::IEnumerable values) { + base.AddRange(values, result.repeatedFixed64_); + return this; + } + public Builder ClearRepeatedFixed64() { + result.repeatedFixed64_.Clear(); + return this; + } + + public scg::IList RepeatedSfixed32List { + get { return result.repeatedSfixed32_; } + } + public int RepeatedSfixed32Count { + get { return result.RepeatedSfixed32Count; } + } + public int GetRepeatedSfixed32(int index) { + return result.GetRepeatedSfixed32(index); + } + public Builder SetRepeatedSfixed32(int index, int value) { + result.repeatedSfixed32_[index] = value; + return this; + } + public Builder AddRepeatedSfixed32(int value) { + result.repeatedSfixed32_.Add(value); + return this; + } + public Builder AddRangeRepeatedSfixed32(scg::IEnumerable values) { + base.AddRange(values, result.repeatedSfixed32_); + return this; + } + public Builder ClearRepeatedSfixed32() { + result.repeatedSfixed32_.Clear(); + return this; + } + + public scg::IList RepeatedSfixed64List { + get { return result.repeatedSfixed64_; } + } + public int RepeatedSfixed64Count { + get { return result.RepeatedSfixed64Count; } + } + public long GetRepeatedSfixed64(int index) { + return result.GetRepeatedSfixed64(index); + } + public Builder SetRepeatedSfixed64(int index, long value) { + result.repeatedSfixed64_[index] = value; + return this; + } + public Builder AddRepeatedSfixed64(long value) { + result.repeatedSfixed64_.Add(value); + return this; + } + public Builder AddRangeRepeatedSfixed64(scg::IEnumerable values) { + base.AddRange(values, result.repeatedSfixed64_); + return this; + } + public Builder ClearRepeatedSfixed64() { + result.repeatedSfixed64_.Clear(); + return this; + } + + public scg::IList RepeatedFloatList { + get { return result.repeatedFloat_; } + } + public int RepeatedFloatCount { + get { return result.RepeatedFloatCount; } + } + public float GetRepeatedFloat(int index) { + return result.GetRepeatedFloat(index); + } + public Builder SetRepeatedFloat(int index, float value) { + result.repeatedFloat_[index] = value; + return this; + } + public Builder AddRepeatedFloat(float value) { + result.repeatedFloat_.Add(value); + return this; + } + public Builder AddRangeRepeatedFloat(scg::IEnumerable values) { + base.AddRange(values, result.repeatedFloat_); + return this; + } + public Builder ClearRepeatedFloat() { + result.repeatedFloat_.Clear(); + return this; + } + + public scg::IList RepeatedDoubleList { + get { return result.repeatedDouble_; } + } + public int RepeatedDoubleCount { + get { return result.RepeatedDoubleCount; } + } + public double GetRepeatedDouble(int index) { + return result.GetRepeatedDouble(index); + } + public Builder SetRepeatedDouble(int index, double value) { + result.repeatedDouble_[index] = value; + return this; + } + public Builder AddRepeatedDouble(double value) { + result.repeatedDouble_.Add(value); + return this; + } + public Builder AddRangeRepeatedDouble(scg::IEnumerable values) { + base.AddRange(values, result.repeatedDouble_); + return this; + } + public Builder ClearRepeatedDouble() { + result.repeatedDouble_.Clear(); + return this; + } + + public scg::IList RepeatedBoolList { + get { return result.repeatedBool_; } + } + public int RepeatedBoolCount { + get { return result.RepeatedBoolCount; } + } + public bool GetRepeatedBool(int index) { + return result.GetRepeatedBool(index); + } + public Builder SetRepeatedBool(int index, bool value) { + result.repeatedBool_[index] = value; + return this; + } + public Builder AddRepeatedBool(bool value) { + result.repeatedBool_.Add(value); + return this; + } + public Builder AddRangeRepeatedBool(scg::IEnumerable values) { + base.AddRange(values, result.repeatedBool_); + return this; + } + public Builder ClearRepeatedBool() { + result.repeatedBool_.Clear(); + return this; + } + + public scg::IList RepeatedStringList { + get { return result.repeatedString_; } + } + public int RepeatedStringCount { + get { return result.RepeatedStringCount; } + } + public string GetRepeatedString(int index) { + return result.GetRepeatedString(index); + } + public Builder SetRepeatedString(int index, string value) { + result.repeatedString_[index] = value; + return this; + } + public Builder AddRepeatedString(string value) { + result.repeatedString_.Add(value); + return this; + } + public Builder AddRangeRepeatedString(scg::IEnumerable values) { + base.AddRange(values, result.repeatedString_); + return this; + } + public Builder ClearRepeatedString() { + result.repeatedString_.Clear(); + return this; + } + + public scg::IList RepeatedBytesList { + get { return result.repeatedBytes_; } + } + public int RepeatedBytesCount { + get { return result.RepeatedBytesCount; } + } + public pb::ByteString GetRepeatedBytes(int index) { + return result.GetRepeatedBytes(index); + } + public Builder SetRepeatedBytes(int index, pb::ByteString value) { + result.repeatedBytes_[index] = value; + return this; + } + public Builder AddRepeatedBytes(pb::ByteString value) { + result.repeatedBytes_.Add(value); + return this; + } + public Builder AddRangeRepeatedBytes(scg::IEnumerable values) { + base.AddRange(values, result.repeatedBytes_); + return this; + } + public Builder ClearRepeatedBytes() { + result.repeatedBytes_.Clear(); + return this; + } + + public scg::IList RepeatedGroupList { + get { return result.repeatedGroup_; } + } + public int RepeatedGroupCount { + get { return result.RepeatedGroupCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup GetRepeatedGroup(int index) { + return result.GetRepeatedGroup(index); + } + public Builder SetRepeatedGroup(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup value) { + result.repeatedGroup_[index] = value; + return this; + } + public Builder SetRepeatedGroup(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.Builder builderForValue) { + result.repeatedGroup_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup value) { + result.repeatedGroup_.Add(value); + return this; + } + public Builder AddRepeatedGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.Builder builderForValue) { + result.repeatedGroup_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedGroup(scg::IEnumerable values) { + base.AddRange(values, result.repeatedGroup_); + return this; + } + public Builder ClearRepeatedGroup() { + result.repeatedGroup_.Clear(); + return this; + } + + public scg::IList RepeatedNestedMessageList { + get { return result.repeatedNestedMessage_; } + } + public int RepeatedNestedMessageCount { + get { return result.RepeatedNestedMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage GetRepeatedNestedMessage(int index) { + return result.GetRepeatedNestedMessage(index); + } + public Builder SetRepeatedNestedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + result.repeatedNestedMessage_[index] = value; + return this; + } + public Builder SetRepeatedNestedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder builderForValue) { + result.repeatedNestedMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + result.repeatedNestedMessage_.Add(value); + return this; + } + public Builder AddRepeatedNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder builderForValue) { + result.repeatedNestedMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedNestedMessage(scg::IEnumerable values) { + base.AddRange(values, result.repeatedNestedMessage_); + return this; + } + public Builder ClearRepeatedNestedMessage() { + result.repeatedNestedMessage_.Clear(); + return this; + } + + public scg::IList RepeatedForeignMessageList { + get { return result.repeatedForeignMessage_; } + } + public int RepeatedForeignMessageCount { + get { return result.RepeatedForeignMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetRepeatedForeignMessage(int index) { + return result.GetRepeatedForeignMessage(index); + } + public Builder SetRepeatedForeignMessage(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.repeatedForeignMessage_[index] = value; + return this; + } + public Builder SetRepeatedForeignMessage(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.repeatedForeignMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.repeatedForeignMessage_.Add(value); + return this; + } + public Builder AddRepeatedForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.repeatedForeignMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedForeignMessage(scg::IEnumerable values) { + base.AddRange(values, result.repeatedForeignMessage_); + return this; + } + public Builder ClearRepeatedForeignMessage() { + result.repeatedForeignMessage_.Clear(); + return this; + } + + public scg::IList RepeatedImportMessageList { + get { return result.repeatedImportMessage_; } + } + public int RepeatedImportMessageCount { + get { return result.RepeatedImportMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportMessage GetRepeatedImportMessage(int index) { + return result.GetRepeatedImportMessage(index); + } + public Builder SetRepeatedImportMessage(int index, global::Google.ProtocolBuffers.TestProtos.ImportMessage value) { + result.repeatedImportMessage_[index] = value; + return this; + } + public Builder SetRepeatedImportMessage(int index, global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder builderForValue) { + result.repeatedImportMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage value) { + result.repeatedImportMessage_.Add(value); + return this; + } + public Builder AddRepeatedImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder builderForValue) { + result.repeatedImportMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedImportMessage(scg::IEnumerable values) { + base.AddRange(values, result.repeatedImportMessage_); + return this; + } + public Builder ClearRepeatedImportMessage() { + result.repeatedImportMessage_.Clear(); + return this; + } + + public scg::IList RepeatedNestedEnumList { + get { return result.repeatedNestedEnum_; } + } + public int RepeatedNestedEnumCount { + get { return result.RepeatedNestedEnumCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum GetRepeatedNestedEnum(int index) { + return result.GetRepeatedNestedEnum(index); + } + public Builder SetRepeatedNestedEnum(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum value) { + result.repeatedNestedEnum_[index] = value; + return this; + } + public Builder AddRepeatedNestedEnum(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum value) { + result.repeatedNestedEnum_.Add(value); + return this; + } + public Builder AddRangeRepeatedNestedEnum(scg::IEnumerable values) { + base.AddRange(values, result.repeatedNestedEnum_); + return this; + } + public Builder ClearRepeatedNestedEnum() { + result.repeatedNestedEnum_.Clear(); + return this; + } + + public scg::IList RepeatedForeignEnumList { + get { return result.repeatedForeignEnum_; } + } + public int RepeatedForeignEnumCount { + get { return result.RepeatedForeignEnumCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetRepeatedForeignEnum(int index) { + return result.GetRepeatedForeignEnum(index); + } + public Builder SetRepeatedForeignEnum(int index, global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.repeatedForeignEnum_[index] = value; + return this; + } + public Builder AddRepeatedForeignEnum(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.repeatedForeignEnum_.Add(value); + return this; + } + public Builder AddRangeRepeatedForeignEnum(scg::IEnumerable values) { + base.AddRange(values, result.repeatedForeignEnum_); + return this; + } + public Builder ClearRepeatedForeignEnum() { + result.repeatedForeignEnum_.Clear(); + return this; + } + + public scg::IList RepeatedImportEnumList { + get { return result.repeatedImportEnum_; } + } + public int RepeatedImportEnumCount { + get { return result.RepeatedImportEnumCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum GetRepeatedImportEnum(int index) { + return result.GetRepeatedImportEnum(index); + } + public Builder SetRepeatedImportEnum(int index, global::Google.ProtocolBuffers.TestProtos.ImportEnum value) { + result.repeatedImportEnum_[index] = value; + return this; + } + public Builder AddRepeatedImportEnum(global::Google.ProtocolBuffers.TestProtos.ImportEnum value) { + result.repeatedImportEnum_.Add(value); + return this; + } + public Builder AddRangeRepeatedImportEnum(scg::IEnumerable values) { + base.AddRange(values, result.repeatedImportEnum_); + return this; + } + public Builder ClearRepeatedImportEnum() { + result.repeatedImportEnum_.Clear(); + return this; + } + + public scg::IList RepeatedStringPieceList { + get { return result.repeatedStringPiece_; } + } + public int RepeatedStringPieceCount { + get { return result.RepeatedStringPieceCount; } + } + public string GetRepeatedStringPiece(int index) { + return result.GetRepeatedStringPiece(index); + } + public Builder SetRepeatedStringPiece(int index, string value) { + result.repeatedStringPiece_[index] = value; + return this; + } + public Builder AddRepeatedStringPiece(string value) { + result.repeatedStringPiece_.Add(value); + return this; + } + public Builder AddRangeRepeatedStringPiece(scg::IEnumerable values) { + base.AddRange(values, result.repeatedStringPiece_); + return this; + } + public Builder ClearRepeatedStringPiece() { + result.repeatedStringPiece_.Clear(); + return this; + } + + public scg::IList RepeatedCordList { + get { return result.repeatedCord_; } + } + public int RepeatedCordCount { + get { return result.RepeatedCordCount; } + } + public string GetRepeatedCord(int index) { + return result.GetRepeatedCord(index); + } + public Builder SetRepeatedCord(int index, string value) { + result.repeatedCord_[index] = value; + return this; + } + public Builder AddRepeatedCord(string value) { + result.repeatedCord_.Add(value); + return this; + } + public Builder AddRangeRepeatedCord(scg::IEnumerable values) { + base.AddRange(values, result.repeatedCord_); + return this; + } + public Builder ClearRepeatedCord() { + result.repeatedCord_.Clear(); + return this; + } + + public bool HasDefaultInt32 { + get { return result.HasDefaultInt32; } + } + public int DefaultInt32 { + get { return result.DefaultInt32; } + set { SetDefaultInt32(value); } + } + public Builder SetDefaultInt32(int value) { + result.hasDefaultInt32 = true; + result.defaultInt32_ = value; + return this; + } + public Builder ClearDefaultInt32() { + result.hasDefaultInt32 = false; + result.defaultInt32_ = 41; + return this; + } + + public bool HasDefaultInt64 { + get { return result.HasDefaultInt64; } + } + public long DefaultInt64 { + get { return result.DefaultInt64; } + set { SetDefaultInt64(value); } + } + public Builder SetDefaultInt64(long value) { + result.hasDefaultInt64 = true; + result.defaultInt64_ = value; + return this; + } + public Builder ClearDefaultInt64() { + result.hasDefaultInt64 = false; + result.defaultInt64_ = 42L; + return this; + } + + public bool HasDefaultUint32 { + get { return result.HasDefaultUint32; } + } + public uint DefaultUint32 { + get { return result.DefaultUint32; } + set { SetDefaultUint32(value); } + } + public Builder SetDefaultUint32(uint value) { + result.hasDefaultUint32 = true; + result.defaultUint32_ = value; + return this; + } + public Builder ClearDefaultUint32() { + result.hasDefaultUint32 = false; + result.defaultUint32_ = 43; + return this; + } + + public bool HasDefaultUint64 { + get { return result.HasDefaultUint64; } + } + public ulong DefaultUint64 { + get { return result.DefaultUint64; } + set { SetDefaultUint64(value); } + } + public Builder SetDefaultUint64(ulong value) { + result.hasDefaultUint64 = true; + result.defaultUint64_ = value; + return this; + } + public Builder ClearDefaultUint64() { + result.hasDefaultUint64 = false; + result.defaultUint64_ = 44UL; + return this; + } + + public bool HasDefaultSint32 { + get { return result.HasDefaultSint32; } + } + public int DefaultSint32 { + get { return result.DefaultSint32; } + set { SetDefaultSint32(value); } + } + public Builder SetDefaultSint32(int value) { + result.hasDefaultSint32 = true; + result.defaultSint32_ = value; + return this; + } + public Builder ClearDefaultSint32() { + result.hasDefaultSint32 = false; + result.defaultSint32_ = -45; + return this; + } + + public bool HasDefaultSint64 { + get { return result.HasDefaultSint64; } + } + public long DefaultSint64 { + get { return result.DefaultSint64; } + set { SetDefaultSint64(value); } + } + public Builder SetDefaultSint64(long value) { + result.hasDefaultSint64 = true; + result.defaultSint64_ = value; + return this; + } + public Builder ClearDefaultSint64() { + result.hasDefaultSint64 = false; + result.defaultSint64_ = 46; + return this; + } + + public bool HasDefaultFixed32 { + get { return result.HasDefaultFixed32; } + } + public uint DefaultFixed32 { + get { return result.DefaultFixed32; } + set { SetDefaultFixed32(value); } + } + public Builder SetDefaultFixed32(uint value) { + result.hasDefaultFixed32 = true; + result.defaultFixed32_ = value; + return this; + } + public Builder ClearDefaultFixed32() { + result.hasDefaultFixed32 = false; + result.defaultFixed32_ = 47; + return this; + } + + public bool HasDefaultFixed64 { + get { return result.HasDefaultFixed64; } + } + public ulong DefaultFixed64 { + get { return result.DefaultFixed64; } + set { SetDefaultFixed64(value); } + } + public Builder SetDefaultFixed64(ulong value) { + result.hasDefaultFixed64 = true; + result.defaultFixed64_ = value; + return this; + } + public Builder ClearDefaultFixed64() { + result.hasDefaultFixed64 = false; + result.defaultFixed64_ = 48; + return this; + } + + public bool HasDefaultSfixed32 { + get { return result.HasDefaultSfixed32; } + } + public int DefaultSfixed32 { + get { return result.DefaultSfixed32; } + set { SetDefaultSfixed32(value); } + } + public Builder SetDefaultSfixed32(int value) { + result.hasDefaultSfixed32 = true; + result.defaultSfixed32_ = value; + return this; + } + public Builder ClearDefaultSfixed32() { + result.hasDefaultSfixed32 = false; + result.defaultSfixed32_ = 49; + return this; + } + + public bool HasDefaultSfixed64 { + get { return result.HasDefaultSfixed64; } + } + public long DefaultSfixed64 { + get { return result.DefaultSfixed64; } + set { SetDefaultSfixed64(value); } + } + public Builder SetDefaultSfixed64(long value) { + result.hasDefaultSfixed64 = true; + result.defaultSfixed64_ = value; + return this; + } + public Builder ClearDefaultSfixed64() { + result.hasDefaultSfixed64 = false; + result.defaultSfixed64_ = -50; + return this; + } + + public bool HasDefaultFloat { + get { return result.HasDefaultFloat; } + } + public float DefaultFloat { + get { return result.DefaultFloat; } + set { SetDefaultFloat(value); } + } + public Builder SetDefaultFloat(float value) { + result.hasDefaultFloat = true; + result.defaultFloat_ = value; + return this; + } + public Builder ClearDefaultFloat() { + result.hasDefaultFloat = false; + result.defaultFloat_ = 51.5F; + return this; + } + + public bool HasDefaultDouble { + get { return result.HasDefaultDouble; } + } + public double DefaultDouble { + get { return result.DefaultDouble; } + set { SetDefaultDouble(value); } + } + public Builder SetDefaultDouble(double value) { + result.hasDefaultDouble = true; + result.defaultDouble_ = value; + return this; + } + public Builder ClearDefaultDouble() { + result.hasDefaultDouble = false; + result.defaultDouble_ = 52000D; + return this; + } + + public bool HasDefaultBool { + get { return result.HasDefaultBool; } + } + public bool DefaultBool { + get { return result.DefaultBool; } + set { SetDefaultBool(value); } + } + public Builder SetDefaultBool(bool value) { + result.hasDefaultBool = true; + result.defaultBool_ = value; + return this; + } + public Builder ClearDefaultBool() { + result.hasDefaultBool = false; + result.defaultBool_ = true; + return this; + } + + public bool HasDefaultString { + get { return result.HasDefaultString; } + } + public string DefaultString { + get { return result.DefaultString; } + set { SetDefaultString(value); } + } + public Builder SetDefaultString(string value) { + result.hasDefaultString = true; + result.defaultString_ = value; + return this; + } + public Builder ClearDefaultString() { + result.hasDefaultString = false; + result.defaultString_ = "hello"; + return this; + } + + public bool HasDefaultBytes { + get { return result.HasDefaultBytes; } + } + public pb::ByteString DefaultBytes { + get { return result.DefaultBytes; } + set { SetDefaultBytes(value); } + } + public Builder SetDefaultBytes(pb::ByteString value) { + result.hasDefaultBytes = true; + result.defaultBytes_ = value; + return this; + } + public Builder ClearDefaultBytes() { + result.hasDefaultBytes = false; + result.defaultBytes_ = (pb::ByteString) global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Descriptor.Fields[62].DefaultValue; + return this; + } + + public bool HasDefaultNestedEnum { + get { return result.HasDefaultNestedEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum DefaultNestedEnum { + get { return result.DefaultNestedEnum; } + set { SetDefaultNestedEnum(value); } + } + public Builder SetDefaultNestedEnum(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum value) { + result.hasDefaultNestedEnum = true; + result.defaultNestedEnum_ = value; + return this; + } + public Builder ClearDefaultNestedEnum() { + result.hasDefaultNestedEnum = false; + result.defaultNestedEnum_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum.BAR; + return this; + } + + public bool HasDefaultForeignEnum { + get { return result.HasDefaultForeignEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum DefaultForeignEnum { + get { return result.DefaultForeignEnum; } + set { SetDefaultForeignEnum(value); } + } + public Builder SetDefaultForeignEnum(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.hasDefaultForeignEnum = true; + result.defaultForeignEnum_ = value; + return this; + } + public Builder ClearDefaultForeignEnum() { + result.hasDefaultForeignEnum = false; + result.defaultForeignEnum_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_BAR; + return this; + } + + public bool HasDefaultImportEnum { + get { return result.HasDefaultImportEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum DefaultImportEnum { + get { return result.DefaultImportEnum; } + set { SetDefaultImportEnum(value); } + } + public Builder SetDefaultImportEnum(global::Google.ProtocolBuffers.TestProtos.ImportEnum value) { + result.hasDefaultImportEnum = true; + result.defaultImportEnum_ = value; + return this; + } + public Builder ClearDefaultImportEnum() { + result.hasDefaultImportEnum = false; + result.defaultImportEnum_ = global::Google.ProtocolBuffers.TestProtos.ImportEnum.IMPORT_BAR; + return this; + } + + public bool HasDefaultStringPiece { + get { return result.HasDefaultStringPiece; } + } + public string DefaultStringPiece { + get { return result.DefaultStringPiece; } + set { SetDefaultStringPiece(value); } + } + public Builder SetDefaultStringPiece(string value) { + result.hasDefaultStringPiece = true; + result.defaultStringPiece_ = value; + return this; + } + public Builder ClearDefaultStringPiece() { + result.hasDefaultStringPiece = false; + result.defaultStringPiece_ = "abc"; + return this; + } + + public bool HasDefaultCord { + get { return result.HasDefaultCord; } + } + public string DefaultCord { + get { return result.DefaultCord; } + set { SetDefaultCord(value); } + } + public Builder SetDefaultCord(string value) { + result.hasDefaultCord = true; + result.defaultCord_ = value; + return this; + } + public Builder ClearDefaultCord() { + result.hasDefaultCord = false; + result.defaultCord_ = "123"; + return this; + } + } + } + + public sealed partial class ForeignMessage : pb::GeneratedMessage { + private static readonly ForeignMessage defaultInstance = new Builder().BuildPartial(); + public static ForeignMessage DefaultInstance { + get { return defaultInstance; } + } + + public override ForeignMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ForeignMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_ForeignMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_ForeignMessage__FieldAccessorTable; } + } + + private bool hasC; + private int c_ = 0; + public bool HasC { + get { return hasC; } + } + public int C { + get { return c_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasC) { + output.WriteInt32(1, C); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasC) { + size += pb::CodedOutputStream.ComputeInt32Size(1, C); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ForeignMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ForeignMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ForeignMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ForeignMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ForeignMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ForeignMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ForeignMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ForeignMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ForeignMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ForeignMessage result = new ForeignMessage(); + + protected override ForeignMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ForeignMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ForeignMessage.Descriptor; } + } + + public override ForeignMessage DefaultInstanceForType { + get { return ForeignMessage.DefaultInstance; } + } + + public override ForeignMessage BuildPartial() { + ForeignMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ForeignMessage) { + return MergeFrom((ForeignMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ForeignMessage other) { + if (other == ForeignMessage.DefaultInstance) return this; + if (other.HasC) { + C = other.C; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + C = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasC { + get { return result.HasC; } + } + public int C { + get { return result.C; } + set { SetC(value); } + } + public Builder SetC(int value) { + result.hasC = true; + result.c_ = value; + return this; + } + public Builder ClearC() { + result.hasC = false; + result.c_ = 0; + return this; + } + } + } + + public sealed partial class TestAllExtensions : pb::ExtendableMessage { + private static readonly TestAllExtensions defaultInstance = new Builder().BuildPartial(); + public static TestAllExtensions DefaultInstance { + get { return defaultInstance; } + } + + public override TestAllExtensions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestAllExtensions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllExtensions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllExtensions__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestAllExtensions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestAllExtensions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestAllExtensions result = new TestAllExtensions(); + + protected override TestAllExtensions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestAllExtensions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestAllExtensions.Descriptor; } + } + + public override TestAllExtensions DefaultInstanceForType { + get { return TestAllExtensions.DefaultInstance; } + } + + public override TestAllExtensions BuildPartial() { + TestAllExtensions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestAllExtensions) { + return MergeFrom((TestAllExtensions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestAllExtensions other) { + if (other == TestAllExtensions.DefaultInstance) return this; + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class OptionalGroup_extension : pb::GeneratedMessage { + private static readonly OptionalGroup_extension defaultInstance = new Builder().BuildPartial(); + public static OptionalGroup_extension DefaultInstance { + get { return defaultInstance; } + } + + public override OptionalGroup_extension DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override OptionalGroup_extension ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_OptionalGroup_extension__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_OptionalGroup_extension__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(17, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(17, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static OptionalGroup_extension ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(OptionalGroup_extension prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + OptionalGroup_extension result = new OptionalGroup_extension(); + + protected override OptionalGroup_extension MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new OptionalGroup_extension(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return OptionalGroup_extension.Descriptor; } + } + + public override OptionalGroup_extension DefaultInstanceForType { + get { return OptionalGroup_extension.DefaultInstance; } + } + + public override OptionalGroup_extension BuildPartial() { + OptionalGroup_extension returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is OptionalGroup_extension) { + return MergeFrom((OptionalGroup_extension) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(OptionalGroup_extension other) { + if (other == OptionalGroup_extension.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 136: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + public sealed partial class RepeatedGroup_extension : pb::GeneratedMessage { + private static readonly RepeatedGroup_extension defaultInstance = new Builder().BuildPartial(); + public static RepeatedGroup_extension DefaultInstance { + get { return defaultInstance; } + } + + public override RepeatedGroup_extension DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override RepeatedGroup_extension ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_RepeatedGroup_extension__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_RepeatedGroup_extension__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(47, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(47, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static RepeatedGroup_extension ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(RepeatedGroup_extension prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + RepeatedGroup_extension result = new RepeatedGroup_extension(); + + protected override RepeatedGroup_extension MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new RepeatedGroup_extension(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return RepeatedGroup_extension.Descriptor; } + } + + public override RepeatedGroup_extension DefaultInstanceForType { + get { return RepeatedGroup_extension.DefaultInstance; } + } + + public override RepeatedGroup_extension BuildPartial() { + RepeatedGroup_extension returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is RepeatedGroup_extension) { + return MergeFrom((RepeatedGroup_extension) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(RepeatedGroup_extension other) { + if (other == RepeatedGroup_extension.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 376: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + public sealed partial class TestRequired : pb::GeneratedMessage { + private static readonly TestRequired defaultInstance = new Builder().BuildPartial(); + public static TestRequired DefaultInstance { + get { return defaultInstance; } + } + + public override TestRequired DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestRequired ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRequired__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRequired__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase Single = + pb::GeneratedSingleExtension.CreateInstance(Descriptor.Extensions[0]); + public static readonly + pb::GeneratedExtensionBase> Multi = + pb::GeneratedRepeatExtension.CreateInstance(Descriptor.Extensions[1]); + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + private bool hasDummy2; + private int dummy2_ = 0; + public bool HasDummy2 { + get { return hasDummy2; } + } + public int Dummy2 { + get { return dummy2_; } + } + + private bool hasB; + private int b_ = 0; + public bool HasB { + get { return hasB; } + } + public int B { + get { return b_; } + } + + private bool hasDummy4; + private int dummy4_ = 0; + public bool HasDummy4 { + get { return hasDummy4; } + } + public int Dummy4 { + get { return dummy4_; } + } + + private bool hasDummy5; + private int dummy5_ = 0; + public bool HasDummy5 { + get { return hasDummy5; } + } + public int Dummy5 { + get { return dummy5_; } + } + + private bool hasDummy6; + private int dummy6_ = 0; + public bool HasDummy6 { + get { return hasDummy6; } + } + public int Dummy6 { + get { return dummy6_; } + } + + private bool hasDummy7; + private int dummy7_ = 0; + public bool HasDummy7 { + get { return hasDummy7; } + } + public int Dummy7 { + get { return dummy7_; } + } + + private bool hasDummy8; + private int dummy8_ = 0; + public bool HasDummy8 { + get { return hasDummy8; } + } + public int Dummy8 { + get { return dummy8_; } + } + + private bool hasDummy9; + private int dummy9_ = 0; + public bool HasDummy9 { + get { return hasDummy9; } + } + public int Dummy9 { + get { return dummy9_; } + } + + private bool hasDummy10; + private int dummy10_ = 0; + public bool HasDummy10 { + get { return hasDummy10; } + } + public int Dummy10 { + get { return dummy10_; } + } + + private bool hasDummy11; + private int dummy11_ = 0; + public bool HasDummy11 { + get { return hasDummy11; } + } + public int Dummy11 { + get { return dummy11_; } + } + + private bool hasDummy12; + private int dummy12_ = 0; + public bool HasDummy12 { + get { return hasDummy12; } + } + public int Dummy12 { + get { return dummy12_; } + } + + private bool hasDummy13; + private int dummy13_ = 0; + public bool HasDummy13 { + get { return hasDummy13; } + } + public int Dummy13 { + get { return dummy13_; } + } + + private bool hasDummy14; + private int dummy14_ = 0; + public bool HasDummy14 { + get { return hasDummy14; } + } + public int Dummy14 { + get { return dummy14_; } + } + + private bool hasDummy15; + private int dummy15_ = 0; + public bool HasDummy15 { + get { return hasDummy15; } + } + public int Dummy15 { + get { return dummy15_; } + } + + private bool hasDummy16; + private int dummy16_ = 0; + public bool HasDummy16 { + get { return hasDummy16; } + } + public int Dummy16 { + get { return dummy16_; } + } + + private bool hasDummy17; + private int dummy17_ = 0; + public bool HasDummy17 { + get { return hasDummy17; } + } + public int Dummy17 { + get { return dummy17_; } + } + + private bool hasDummy18; + private int dummy18_ = 0; + public bool HasDummy18 { + get { return hasDummy18; } + } + public int Dummy18 { + get { return dummy18_; } + } + + private bool hasDummy19; + private int dummy19_ = 0; + public bool HasDummy19 { + get { return hasDummy19; } + } + public int Dummy19 { + get { return dummy19_; } + } + + private bool hasDummy20; + private int dummy20_ = 0; + public bool HasDummy20 { + get { return hasDummy20; } + } + public int Dummy20 { + get { return dummy20_; } + } + + private bool hasDummy21; + private int dummy21_ = 0; + public bool HasDummy21 { + get { return hasDummy21; } + } + public int Dummy21 { + get { return dummy21_; } + } + + private bool hasDummy22; + private int dummy22_ = 0; + public bool HasDummy22 { + get { return hasDummy22; } + } + public int Dummy22 { + get { return dummy22_; } + } + + private bool hasDummy23; + private int dummy23_ = 0; + public bool HasDummy23 { + get { return hasDummy23; } + } + public int Dummy23 { + get { return dummy23_; } + } + + private bool hasDummy24; + private int dummy24_ = 0; + public bool HasDummy24 { + get { return hasDummy24; } + } + public int Dummy24 { + get { return dummy24_; } + } + + private bool hasDummy25; + private int dummy25_ = 0; + public bool HasDummy25 { + get { return hasDummy25; } + } + public int Dummy25 { + get { return dummy25_; } + } + + private bool hasDummy26; + private int dummy26_ = 0; + public bool HasDummy26 { + get { return hasDummy26; } + } + public int Dummy26 { + get { return dummy26_; } + } + + private bool hasDummy27; + private int dummy27_ = 0; + public bool HasDummy27 { + get { return hasDummy27; } + } + public int Dummy27 { + get { return dummy27_; } + } + + private bool hasDummy28; + private int dummy28_ = 0; + public bool HasDummy28 { + get { return hasDummy28; } + } + public int Dummy28 { + get { return dummy28_; } + } + + private bool hasDummy29; + private int dummy29_ = 0; + public bool HasDummy29 { + get { return hasDummy29; } + } + public int Dummy29 { + get { return dummy29_; } + } + + private bool hasDummy30; + private int dummy30_ = 0; + public bool HasDummy30 { + get { return hasDummy30; } + } + public int Dummy30 { + get { return dummy30_; } + } + + private bool hasDummy31; + private int dummy31_ = 0; + public bool HasDummy31 { + get { return hasDummy31; } + } + public int Dummy31 { + get { return dummy31_; } + } + + private bool hasDummy32; + private int dummy32_ = 0; + public bool HasDummy32 { + get { return hasDummy32; } + } + public int Dummy32 { + get { return dummy32_; } + } + + private bool hasC; + private int c_ = 0; + public bool HasC { + get { return hasC; } + } + public int C { + get { return c_; } + } + + public override bool IsInitialized { + get { + if (!hasA) return false; + if (!hasB) return false; + if (!hasC) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + if (HasDummy2) { + output.WriteInt32(2, Dummy2); + } + if (HasB) { + output.WriteInt32(3, B); + } + if (HasDummy4) { + output.WriteInt32(4, Dummy4); + } + if (HasDummy5) { + output.WriteInt32(5, Dummy5); + } + if (HasDummy6) { + output.WriteInt32(6, Dummy6); + } + if (HasDummy7) { + output.WriteInt32(7, Dummy7); + } + if (HasDummy8) { + output.WriteInt32(8, Dummy8); + } + if (HasDummy9) { + output.WriteInt32(9, Dummy9); + } + if (HasDummy10) { + output.WriteInt32(10, Dummy10); + } + if (HasDummy11) { + output.WriteInt32(11, Dummy11); + } + if (HasDummy12) { + output.WriteInt32(12, Dummy12); + } + if (HasDummy13) { + output.WriteInt32(13, Dummy13); + } + if (HasDummy14) { + output.WriteInt32(14, Dummy14); + } + if (HasDummy15) { + output.WriteInt32(15, Dummy15); + } + if (HasDummy16) { + output.WriteInt32(16, Dummy16); + } + if (HasDummy17) { + output.WriteInt32(17, Dummy17); + } + if (HasDummy18) { + output.WriteInt32(18, Dummy18); + } + if (HasDummy19) { + output.WriteInt32(19, Dummy19); + } + if (HasDummy20) { + output.WriteInt32(20, Dummy20); + } + if (HasDummy21) { + output.WriteInt32(21, Dummy21); + } + if (HasDummy22) { + output.WriteInt32(22, Dummy22); + } + if (HasDummy23) { + output.WriteInt32(23, Dummy23); + } + if (HasDummy24) { + output.WriteInt32(24, Dummy24); + } + if (HasDummy25) { + output.WriteInt32(25, Dummy25); + } + if (HasDummy26) { + output.WriteInt32(26, Dummy26); + } + if (HasDummy27) { + output.WriteInt32(27, Dummy27); + } + if (HasDummy28) { + output.WriteInt32(28, Dummy28); + } + if (HasDummy29) { + output.WriteInt32(29, Dummy29); + } + if (HasDummy30) { + output.WriteInt32(30, Dummy30); + } + if (HasDummy31) { + output.WriteInt32(31, Dummy31); + } + if (HasDummy32) { + output.WriteInt32(32, Dummy32); + } + if (HasC) { + output.WriteInt32(33, C); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + if (HasDummy2) { + size += pb::CodedOutputStream.ComputeInt32Size(2, Dummy2); + } + if (HasB) { + size += pb::CodedOutputStream.ComputeInt32Size(3, B); + } + if (HasDummy4) { + size += pb::CodedOutputStream.ComputeInt32Size(4, Dummy4); + } + if (HasDummy5) { + size += pb::CodedOutputStream.ComputeInt32Size(5, Dummy5); + } + if (HasDummy6) { + size += pb::CodedOutputStream.ComputeInt32Size(6, Dummy6); + } + if (HasDummy7) { + size += pb::CodedOutputStream.ComputeInt32Size(7, Dummy7); + } + if (HasDummy8) { + size += pb::CodedOutputStream.ComputeInt32Size(8, Dummy8); + } + if (HasDummy9) { + size += pb::CodedOutputStream.ComputeInt32Size(9, Dummy9); + } + if (HasDummy10) { + size += pb::CodedOutputStream.ComputeInt32Size(10, Dummy10); + } + if (HasDummy11) { + size += pb::CodedOutputStream.ComputeInt32Size(11, Dummy11); + } + if (HasDummy12) { + size += pb::CodedOutputStream.ComputeInt32Size(12, Dummy12); + } + if (HasDummy13) { + size += pb::CodedOutputStream.ComputeInt32Size(13, Dummy13); + } + if (HasDummy14) { + size += pb::CodedOutputStream.ComputeInt32Size(14, Dummy14); + } + if (HasDummy15) { + size += pb::CodedOutputStream.ComputeInt32Size(15, Dummy15); + } + if (HasDummy16) { + size += pb::CodedOutputStream.ComputeInt32Size(16, Dummy16); + } + if (HasDummy17) { + size += pb::CodedOutputStream.ComputeInt32Size(17, Dummy17); + } + if (HasDummy18) { + size += pb::CodedOutputStream.ComputeInt32Size(18, Dummy18); + } + if (HasDummy19) { + size += pb::CodedOutputStream.ComputeInt32Size(19, Dummy19); + } + if (HasDummy20) { + size += pb::CodedOutputStream.ComputeInt32Size(20, Dummy20); + } + if (HasDummy21) { + size += pb::CodedOutputStream.ComputeInt32Size(21, Dummy21); + } + if (HasDummy22) { + size += pb::CodedOutputStream.ComputeInt32Size(22, Dummy22); + } + if (HasDummy23) { + size += pb::CodedOutputStream.ComputeInt32Size(23, Dummy23); + } + if (HasDummy24) { + size += pb::CodedOutputStream.ComputeInt32Size(24, Dummy24); + } + if (HasDummy25) { + size += pb::CodedOutputStream.ComputeInt32Size(25, Dummy25); + } + if (HasDummy26) { + size += pb::CodedOutputStream.ComputeInt32Size(26, Dummy26); + } + if (HasDummy27) { + size += pb::CodedOutputStream.ComputeInt32Size(27, Dummy27); + } + if (HasDummy28) { + size += pb::CodedOutputStream.ComputeInt32Size(28, Dummy28); + } + if (HasDummy29) { + size += pb::CodedOutputStream.ComputeInt32Size(29, Dummy29); + } + if (HasDummy30) { + size += pb::CodedOutputStream.ComputeInt32Size(30, Dummy30); + } + if (HasDummy31) { + size += pb::CodedOutputStream.ComputeInt32Size(31, Dummy31); + } + if (HasDummy32) { + size += pb::CodedOutputStream.ComputeInt32Size(32, Dummy32); + } + if (HasC) { + size += pb::CodedOutputStream.ComputeInt32Size(33, C); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestRequired ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequired ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequired ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequired ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequired ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequired ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestRequired ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequired ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestRequired prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestRequired result = new TestRequired(); + + protected override TestRequired MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestRequired(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestRequired.Descriptor; } + } + + public override TestRequired DefaultInstanceForType { + get { return TestRequired.DefaultInstance; } + } + + public override TestRequired BuildPartial() { + TestRequired returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestRequired) { + return MergeFrom((TestRequired) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestRequired other) { + if (other == TestRequired.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + if (other.HasDummy2) { + Dummy2 = other.Dummy2; + } + if (other.HasB) { + B = other.B; + } + if (other.HasDummy4) { + Dummy4 = other.Dummy4; + } + if (other.HasDummy5) { + Dummy5 = other.Dummy5; + } + if (other.HasDummy6) { + Dummy6 = other.Dummy6; + } + if (other.HasDummy7) { + Dummy7 = other.Dummy7; + } + if (other.HasDummy8) { + Dummy8 = other.Dummy8; + } + if (other.HasDummy9) { + Dummy9 = other.Dummy9; + } + if (other.HasDummy10) { + Dummy10 = other.Dummy10; + } + if (other.HasDummy11) { + Dummy11 = other.Dummy11; + } + if (other.HasDummy12) { + Dummy12 = other.Dummy12; + } + if (other.HasDummy13) { + Dummy13 = other.Dummy13; + } + if (other.HasDummy14) { + Dummy14 = other.Dummy14; + } + if (other.HasDummy15) { + Dummy15 = other.Dummy15; + } + if (other.HasDummy16) { + Dummy16 = other.Dummy16; + } + if (other.HasDummy17) { + Dummy17 = other.Dummy17; + } + if (other.HasDummy18) { + Dummy18 = other.Dummy18; + } + if (other.HasDummy19) { + Dummy19 = other.Dummy19; + } + if (other.HasDummy20) { + Dummy20 = other.Dummy20; + } + if (other.HasDummy21) { + Dummy21 = other.Dummy21; + } + if (other.HasDummy22) { + Dummy22 = other.Dummy22; + } + if (other.HasDummy23) { + Dummy23 = other.Dummy23; + } + if (other.HasDummy24) { + Dummy24 = other.Dummy24; + } + if (other.HasDummy25) { + Dummy25 = other.Dummy25; + } + if (other.HasDummy26) { + Dummy26 = other.Dummy26; + } + if (other.HasDummy27) { + Dummy27 = other.Dummy27; + } + if (other.HasDummy28) { + Dummy28 = other.Dummy28; + } + if (other.HasDummy29) { + Dummy29 = other.Dummy29; + } + if (other.HasDummy30) { + Dummy30 = other.Dummy30; + } + if (other.HasDummy31) { + Dummy31 = other.Dummy31; + } + if (other.HasDummy32) { + Dummy32 = other.Dummy32; + } + if (other.HasC) { + C = other.C; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + case 16: { + Dummy2 = input.ReadInt32(); + break; + } + case 24: { + B = input.ReadInt32(); + break; + } + case 32: { + Dummy4 = input.ReadInt32(); + break; + } + case 40: { + Dummy5 = input.ReadInt32(); + break; + } + case 48: { + Dummy6 = input.ReadInt32(); + break; + } + case 56: { + Dummy7 = input.ReadInt32(); + break; + } + case 64: { + Dummy8 = input.ReadInt32(); + break; + } + case 72: { + Dummy9 = input.ReadInt32(); + break; + } + case 80: { + Dummy10 = input.ReadInt32(); + break; + } + case 88: { + Dummy11 = input.ReadInt32(); + break; + } + case 96: { + Dummy12 = input.ReadInt32(); + break; + } + case 104: { + Dummy13 = input.ReadInt32(); + break; + } + case 112: { + Dummy14 = input.ReadInt32(); + break; + } + case 120: { + Dummy15 = input.ReadInt32(); + break; + } + case 128: { + Dummy16 = input.ReadInt32(); + break; + } + case 136: { + Dummy17 = input.ReadInt32(); + break; + } + case 144: { + Dummy18 = input.ReadInt32(); + break; + } + case 152: { + Dummy19 = input.ReadInt32(); + break; + } + case 160: { + Dummy20 = input.ReadInt32(); + break; + } + case 168: { + Dummy21 = input.ReadInt32(); + break; + } + case 176: { + Dummy22 = input.ReadInt32(); + break; + } + case 184: { + Dummy23 = input.ReadInt32(); + break; + } + case 192: { + Dummy24 = input.ReadInt32(); + break; + } + case 200: { + Dummy25 = input.ReadInt32(); + break; + } + case 208: { + Dummy26 = input.ReadInt32(); + break; + } + case 216: { + Dummy27 = input.ReadInt32(); + break; + } + case 224: { + Dummy28 = input.ReadInt32(); + break; + } + case 232: { + Dummy29 = input.ReadInt32(); + break; + } + case 240: { + Dummy30 = input.ReadInt32(); + break; + } + case 248: { + Dummy31 = input.ReadInt32(); + break; + } + case 256: { + Dummy32 = input.ReadInt32(); + break; + } + case 264: { + C = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + + public bool HasDummy2 { + get { return result.HasDummy2; } + } + public int Dummy2 { + get { return result.Dummy2; } + set { SetDummy2(value); } + } + public Builder SetDummy2(int value) { + result.hasDummy2 = true; + result.dummy2_ = value; + return this; + } + public Builder ClearDummy2() { + result.hasDummy2 = false; + result.dummy2_ = 0; + return this; + } + + public bool HasB { + get { return result.HasB; } + } + public int B { + get { return result.B; } + set { SetB(value); } + } + public Builder SetB(int value) { + result.hasB = true; + result.b_ = value; + return this; + } + public Builder ClearB() { + result.hasB = false; + result.b_ = 0; + return this; + } + + public bool HasDummy4 { + get { return result.HasDummy4; } + } + public int Dummy4 { + get { return result.Dummy4; } + set { SetDummy4(value); } + } + public Builder SetDummy4(int value) { + result.hasDummy4 = true; + result.dummy4_ = value; + return this; + } + public Builder ClearDummy4() { + result.hasDummy4 = false; + result.dummy4_ = 0; + return this; + } + + public bool HasDummy5 { + get { return result.HasDummy5; } + } + public int Dummy5 { + get { return result.Dummy5; } + set { SetDummy5(value); } + } + public Builder SetDummy5(int value) { + result.hasDummy5 = true; + result.dummy5_ = value; + return this; + } + public Builder ClearDummy5() { + result.hasDummy5 = false; + result.dummy5_ = 0; + return this; + } + + public bool HasDummy6 { + get { return result.HasDummy6; } + } + public int Dummy6 { + get { return result.Dummy6; } + set { SetDummy6(value); } + } + public Builder SetDummy6(int value) { + result.hasDummy6 = true; + result.dummy6_ = value; + return this; + } + public Builder ClearDummy6() { + result.hasDummy6 = false; + result.dummy6_ = 0; + return this; + } + + public bool HasDummy7 { + get { return result.HasDummy7; } + } + public int Dummy7 { + get { return result.Dummy7; } + set { SetDummy7(value); } + } + public Builder SetDummy7(int value) { + result.hasDummy7 = true; + result.dummy7_ = value; + return this; + } + public Builder ClearDummy7() { + result.hasDummy7 = false; + result.dummy7_ = 0; + return this; + } + + public bool HasDummy8 { + get { return result.HasDummy8; } + } + public int Dummy8 { + get { return result.Dummy8; } + set { SetDummy8(value); } + } + public Builder SetDummy8(int value) { + result.hasDummy8 = true; + result.dummy8_ = value; + return this; + } + public Builder ClearDummy8() { + result.hasDummy8 = false; + result.dummy8_ = 0; + return this; + } + + public bool HasDummy9 { + get { return result.HasDummy9; } + } + public int Dummy9 { + get { return result.Dummy9; } + set { SetDummy9(value); } + } + public Builder SetDummy9(int value) { + result.hasDummy9 = true; + result.dummy9_ = value; + return this; + } + public Builder ClearDummy9() { + result.hasDummy9 = false; + result.dummy9_ = 0; + return this; + } + + public bool HasDummy10 { + get { return result.HasDummy10; } + } + public int Dummy10 { + get { return result.Dummy10; } + set { SetDummy10(value); } + } + public Builder SetDummy10(int value) { + result.hasDummy10 = true; + result.dummy10_ = value; + return this; + } + public Builder ClearDummy10() { + result.hasDummy10 = false; + result.dummy10_ = 0; + return this; + } + + public bool HasDummy11 { + get { return result.HasDummy11; } + } + public int Dummy11 { + get { return result.Dummy11; } + set { SetDummy11(value); } + } + public Builder SetDummy11(int value) { + result.hasDummy11 = true; + result.dummy11_ = value; + return this; + } + public Builder ClearDummy11() { + result.hasDummy11 = false; + result.dummy11_ = 0; + return this; + } + + public bool HasDummy12 { + get { return result.HasDummy12; } + } + public int Dummy12 { + get { return result.Dummy12; } + set { SetDummy12(value); } + } + public Builder SetDummy12(int value) { + result.hasDummy12 = true; + result.dummy12_ = value; + return this; + } + public Builder ClearDummy12() { + result.hasDummy12 = false; + result.dummy12_ = 0; + return this; + } + + public bool HasDummy13 { + get { return result.HasDummy13; } + } + public int Dummy13 { + get { return result.Dummy13; } + set { SetDummy13(value); } + } + public Builder SetDummy13(int value) { + result.hasDummy13 = true; + result.dummy13_ = value; + return this; + } + public Builder ClearDummy13() { + result.hasDummy13 = false; + result.dummy13_ = 0; + return this; + } + + public bool HasDummy14 { + get { return result.HasDummy14; } + } + public int Dummy14 { + get { return result.Dummy14; } + set { SetDummy14(value); } + } + public Builder SetDummy14(int value) { + result.hasDummy14 = true; + result.dummy14_ = value; + return this; + } + public Builder ClearDummy14() { + result.hasDummy14 = false; + result.dummy14_ = 0; + return this; + } + + public bool HasDummy15 { + get { return result.HasDummy15; } + } + public int Dummy15 { + get { return result.Dummy15; } + set { SetDummy15(value); } + } + public Builder SetDummy15(int value) { + result.hasDummy15 = true; + result.dummy15_ = value; + return this; + } + public Builder ClearDummy15() { + result.hasDummy15 = false; + result.dummy15_ = 0; + return this; + } + + public bool HasDummy16 { + get { return result.HasDummy16; } + } + public int Dummy16 { + get { return result.Dummy16; } + set { SetDummy16(value); } + } + public Builder SetDummy16(int value) { + result.hasDummy16 = true; + result.dummy16_ = value; + return this; + } + public Builder ClearDummy16() { + result.hasDummy16 = false; + result.dummy16_ = 0; + return this; + } + + public bool HasDummy17 { + get { return result.HasDummy17; } + } + public int Dummy17 { + get { return result.Dummy17; } + set { SetDummy17(value); } + } + public Builder SetDummy17(int value) { + result.hasDummy17 = true; + result.dummy17_ = value; + return this; + } + public Builder ClearDummy17() { + result.hasDummy17 = false; + result.dummy17_ = 0; + return this; + } + + public bool HasDummy18 { + get { return result.HasDummy18; } + } + public int Dummy18 { + get { return result.Dummy18; } + set { SetDummy18(value); } + } + public Builder SetDummy18(int value) { + result.hasDummy18 = true; + result.dummy18_ = value; + return this; + } + public Builder ClearDummy18() { + result.hasDummy18 = false; + result.dummy18_ = 0; + return this; + } + + public bool HasDummy19 { + get { return result.HasDummy19; } + } + public int Dummy19 { + get { return result.Dummy19; } + set { SetDummy19(value); } + } + public Builder SetDummy19(int value) { + result.hasDummy19 = true; + result.dummy19_ = value; + return this; + } + public Builder ClearDummy19() { + result.hasDummy19 = false; + result.dummy19_ = 0; + return this; + } + + public bool HasDummy20 { + get { return result.HasDummy20; } + } + public int Dummy20 { + get { return result.Dummy20; } + set { SetDummy20(value); } + } + public Builder SetDummy20(int value) { + result.hasDummy20 = true; + result.dummy20_ = value; + return this; + } + public Builder ClearDummy20() { + result.hasDummy20 = false; + result.dummy20_ = 0; + return this; + } + + public bool HasDummy21 { + get { return result.HasDummy21; } + } + public int Dummy21 { + get { return result.Dummy21; } + set { SetDummy21(value); } + } + public Builder SetDummy21(int value) { + result.hasDummy21 = true; + result.dummy21_ = value; + return this; + } + public Builder ClearDummy21() { + result.hasDummy21 = false; + result.dummy21_ = 0; + return this; + } + + public bool HasDummy22 { + get { return result.HasDummy22; } + } + public int Dummy22 { + get { return result.Dummy22; } + set { SetDummy22(value); } + } + public Builder SetDummy22(int value) { + result.hasDummy22 = true; + result.dummy22_ = value; + return this; + } + public Builder ClearDummy22() { + result.hasDummy22 = false; + result.dummy22_ = 0; + return this; + } + + public bool HasDummy23 { + get { return result.HasDummy23; } + } + public int Dummy23 { + get { return result.Dummy23; } + set { SetDummy23(value); } + } + public Builder SetDummy23(int value) { + result.hasDummy23 = true; + result.dummy23_ = value; + return this; + } + public Builder ClearDummy23() { + result.hasDummy23 = false; + result.dummy23_ = 0; + return this; + } + + public bool HasDummy24 { + get { return result.HasDummy24; } + } + public int Dummy24 { + get { return result.Dummy24; } + set { SetDummy24(value); } + } + public Builder SetDummy24(int value) { + result.hasDummy24 = true; + result.dummy24_ = value; + return this; + } + public Builder ClearDummy24() { + result.hasDummy24 = false; + result.dummy24_ = 0; + return this; + } + + public bool HasDummy25 { + get { return result.HasDummy25; } + } + public int Dummy25 { + get { return result.Dummy25; } + set { SetDummy25(value); } + } + public Builder SetDummy25(int value) { + result.hasDummy25 = true; + result.dummy25_ = value; + return this; + } + public Builder ClearDummy25() { + result.hasDummy25 = false; + result.dummy25_ = 0; + return this; + } + + public bool HasDummy26 { + get { return result.HasDummy26; } + } + public int Dummy26 { + get { return result.Dummy26; } + set { SetDummy26(value); } + } + public Builder SetDummy26(int value) { + result.hasDummy26 = true; + result.dummy26_ = value; + return this; + } + public Builder ClearDummy26() { + result.hasDummy26 = false; + result.dummy26_ = 0; + return this; + } + + public bool HasDummy27 { + get { return result.HasDummy27; } + } + public int Dummy27 { + get { return result.Dummy27; } + set { SetDummy27(value); } + } + public Builder SetDummy27(int value) { + result.hasDummy27 = true; + result.dummy27_ = value; + return this; + } + public Builder ClearDummy27() { + result.hasDummy27 = false; + result.dummy27_ = 0; + return this; + } + + public bool HasDummy28 { + get { return result.HasDummy28; } + } + public int Dummy28 { + get { return result.Dummy28; } + set { SetDummy28(value); } + } + public Builder SetDummy28(int value) { + result.hasDummy28 = true; + result.dummy28_ = value; + return this; + } + public Builder ClearDummy28() { + result.hasDummy28 = false; + result.dummy28_ = 0; + return this; + } + + public bool HasDummy29 { + get { return result.HasDummy29; } + } + public int Dummy29 { + get { return result.Dummy29; } + set { SetDummy29(value); } + } + public Builder SetDummy29(int value) { + result.hasDummy29 = true; + result.dummy29_ = value; + return this; + } + public Builder ClearDummy29() { + result.hasDummy29 = false; + result.dummy29_ = 0; + return this; + } + + public bool HasDummy30 { + get { return result.HasDummy30; } + } + public int Dummy30 { + get { return result.Dummy30; } + set { SetDummy30(value); } + } + public Builder SetDummy30(int value) { + result.hasDummy30 = true; + result.dummy30_ = value; + return this; + } + public Builder ClearDummy30() { + result.hasDummy30 = false; + result.dummy30_ = 0; + return this; + } + + public bool HasDummy31 { + get { return result.HasDummy31; } + } + public int Dummy31 { + get { return result.Dummy31; } + set { SetDummy31(value); } + } + public Builder SetDummy31(int value) { + result.hasDummy31 = true; + result.dummy31_ = value; + return this; + } + public Builder ClearDummy31() { + result.hasDummy31 = false; + result.dummy31_ = 0; + return this; + } + + public bool HasDummy32 { + get { return result.HasDummy32; } + } + public int Dummy32 { + get { return result.Dummy32; } + set { SetDummy32(value); } + } + public Builder SetDummy32(int value) { + result.hasDummy32 = true; + result.dummy32_ = value; + return this; + } + public Builder ClearDummy32() { + result.hasDummy32 = false; + result.dummy32_ = 0; + return this; + } + + public bool HasC { + get { return result.HasC; } + } + public int C { + get { return result.C; } + set { SetC(value); } + } + public Builder SetC(int value) { + result.hasC = true; + result.c_ = value; + return this; + } + public Builder ClearC() { + result.hasC = false; + result.c_ = 0; + return this; + } + } + } + + public sealed partial class TestRequiredForeign : pb::GeneratedMessage { + private static readonly TestRequiredForeign defaultInstance = new Builder().BuildPartial(); + public static TestRequiredForeign DefaultInstance { + get { return defaultInstance; } + } + + public override TestRequiredForeign DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestRequiredForeign ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRequiredForeign__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRequiredForeign__FieldAccessorTable; } + } + + private bool hasOptionalMessage; + private global::Google.ProtocolBuffers.TestProtos.TestRequired optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestRequired.DefaultInstance; + public bool HasOptionalMessage { + get { return hasOptionalMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequired OptionalMessage { + get { return optionalMessage_; } + } + + private pbc::PopsicleList repeatedMessage_ = new pbc::PopsicleList(); + public scg::IList RepeatedMessageList { + get { return repeatedMessage_; } + } + public int RepeatedMessageCount { + get { return repeatedMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequired GetRepeatedMessage(int index) { + return repeatedMessage_[index]; + } + + private bool hasDummy; + private int dummy_ = 0; + public bool HasDummy { + get { return hasDummy; } + } + public int Dummy { + get { return dummy_; } + } + + public override bool IsInitialized { + get { + if (HasOptionalMessage) { + if (!OptionalMessage.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestRequired element in RepeatedMessageList) { + if (!element.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasOptionalMessage) { + output.WriteMessage(1, OptionalMessage); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestRequired element in RepeatedMessageList) { + output.WriteMessage(2, element); + } + if (HasDummy) { + output.WriteInt32(3, Dummy); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasOptionalMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(1, OptionalMessage); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestRequired element in RepeatedMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + if (HasDummy) { + size += pb::CodedOutputStream.ComputeInt32Size(3, Dummy); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestRequiredForeign ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestRequiredForeign prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestRequiredForeign result = new TestRequiredForeign(); + + protected override TestRequiredForeign MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestRequiredForeign(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestRequiredForeign.Descriptor; } + } + + public override TestRequiredForeign DefaultInstanceForType { + get { return TestRequiredForeign.DefaultInstance; } + } + + public override TestRequiredForeign BuildPartial() { + result.repeatedMessage_.MakeReadOnly(); + TestRequiredForeign returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestRequiredForeign) { + return MergeFrom((TestRequiredForeign) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestRequiredForeign other) { + if (other == TestRequiredForeign.DefaultInstance) return this; + if (other.HasOptionalMessage) { + MergeOptionalMessage(other.OptionalMessage); + } + if (other.repeatedMessage_.Count != 0) { + base.AddRange(other.repeatedMessage_, result.repeatedMessage_); + } + if (other.HasDummy) { + Dummy = other.Dummy; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestRequired.CreateBuilder(); + if (HasOptionalMessage) { + subBuilder.MergeFrom(OptionalMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalMessage = subBuilder.BuildPartial(); + break; + } + case 18: { + global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestRequired.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedMessage(subBuilder.BuildPartial()); + break; + } + case 24: { + Dummy = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasOptionalMessage { + get { return result.HasOptionalMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequired OptionalMessage { + get { return result.OptionalMessage; } + set { SetOptionalMessage(value); } + } + public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired value) { + result.hasOptionalMessage = true; + result.optionalMessage_ = value; + return this; + } + public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder builderForValue) { + result.hasOptionalMessage = true; + result.optionalMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired value) { + if (result.HasOptionalMessage && + result.optionalMessage_ != global::Google.ProtocolBuffers.TestProtos.TestRequired.DefaultInstance) { + result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestRequired.CreateBuilder(result.optionalMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalMessage_ = value; + } + result.hasOptionalMessage = true; + return this; + } + public Builder ClearOptionalMessage() { + result.hasOptionalMessage = false; + result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestRequired.DefaultInstance; + return this; + } + + public scg::IList RepeatedMessageList { + get { return result.repeatedMessage_; } + } + public int RepeatedMessageCount { + get { return result.RepeatedMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequired GetRepeatedMessage(int index) { + return result.GetRepeatedMessage(index); + } + public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestRequired value) { + result.repeatedMessage_[index] = value; + return this; + } + public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder builderForValue) { + result.repeatedMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired value) { + result.repeatedMessage_.Add(value); + return this; + } + public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder builderForValue) { + result.repeatedMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedMessage(scg::IEnumerable values) { + base.AddRange(values, result.repeatedMessage_); + return this; + } + public Builder ClearRepeatedMessage() { + result.repeatedMessage_.Clear(); + return this; + } + + public bool HasDummy { + get { return result.HasDummy; } + } + public int Dummy { + get { return result.Dummy; } + set { SetDummy(value); } + } + public Builder SetDummy(int value) { + result.hasDummy = true; + result.dummy_ = value; + return this; + } + public Builder ClearDummy() { + result.hasDummy = false; + result.dummy_ = 0; + return this; + } + } + } + + public sealed partial class TestForeignNested : pb::GeneratedMessage { + private static readonly TestForeignNested defaultInstance = new Builder().BuildPartial(); + public static TestForeignNested DefaultInstance { + get { return defaultInstance; } + } + + public override TestForeignNested DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestForeignNested ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestForeignNested__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestForeignNested__FieldAccessorTable; } + } + + private bool hasForeignNested; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage foreignNested_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance; + public bool HasForeignNested { + get { return hasForeignNested; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage ForeignNested { + get { return foreignNested_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasForeignNested) { + output.WriteMessage(1, ForeignNested); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasForeignNested) { + size += pb::CodedOutputStream.ComputeMessageSize(1, ForeignNested); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestForeignNested ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestForeignNested ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestForeignNested ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestForeignNested ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestForeignNested ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestForeignNested ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestForeignNested ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestForeignNested ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestForeignNested prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestForeignNested result = new TestForeignNested(); + + protected override TestForeignNested MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestForeignNested(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestForeignNested.Descriptor; } + } + + public override TestForeignNested DefaultInstanceForType { + get { return TestForeignNested.DefaultInstance; } + } + + public override TestForeignNested BuildPartial() { + TestForeignNested returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestForeignNested) { + return MergeFrom((TestForeignNested) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestForeignNested other) { + if (other == TestForeignNested.DefaultInstance) return this; + if (other.HasForeignNested) { + MergeForeignNested(other.ForeignNested); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(); + if (HasForeignNested) { + subBuilder.MergeFrom(ForeignNested); + } + input.ReadMessage(subBuilder, extensionRegistry); + ForeignNested = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasForeignNested { + get { return result.HasForeignNested; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage ForeignNested { + get { return result.ForeignNested; } + set { SetForeignNested(value); } + } + public Builder SetForeignNested(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + result.hasForeignNested = true; + result.foreignNested_ = value; + return this; + } + public Builder SetForeignNested(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder builderForValue) { + result.hasForeignNested = true; + result.foreignNested_ = builderForValue.Build(); + return this; + } + public Builder MergeForeignNested(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + if (result.HasForeignNested && + result.foreignNested_ != global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance) { + result.foreignNested_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(result.foreignNested_).MergeFrom(value).BuildPartial(); + } else { + result.foreignNested_ = value; + } + result.hasForeignNested = true; + return this; + } + public Builder ClearForeignNested() { + result.hasForeignNested = false; + result.foreignNested_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestEmptyMessage : pb::GeneratedMessage { + private static readonly TestEmptyMessage defaultInstance = new Builder().BuildPartial(); + public static TestEmptyMessage DefaultInstance { + get { return defaultInstance; } + } + + public override TestEmptyMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestEmptyMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestEmptyMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestEmptyMessage__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestEmptyMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestEmptyMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestEmptyMessage result = new TestEmptyMessage(); + + protected override TestEmptyMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestEmptyMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestEmptyMessage.Descriptor; } + } + + public override TestEmptyMessage DefaultInstanceForType { + get { return TestEmptyMessage.DefaultInstance; } + } + + public override TestEmptyMessage BuildPartial() { + TestEmptyMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestEmptyMessage) { + return MergeFrom((TestEmptyMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestEmptyMessage other) { + if (other == TestEmptyMessage.DefaultInstance) return this; + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class TestEmptyMessageWithExtensions : pb::ExtendableMessage { + private static readonly TestEmptyMessageWithExtensions defaultInstance = new Builder().BuildPartial(); + public static TestEmptyMessageWithExtensions DefaultInstance { + get { return defaultInstance; } + } + + public override TestEmptyMessageWithExtensions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestEmptyMessageWithExtensions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestEmptyMessageWithExtensions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestEmptyMessageWithExtensions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestEmptyMessageWithExtensions result = new TestEmptyMessageWithExtensions(); + + protected override TestEmptyMessageWithExtensions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestEmptyMessageWithExtensions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestEmptyMessageWithExtensions.Descriptor; } + } + + public override TestEmptyMessageWithExtensions DefaultInstanceForType { + get { return TestEmptyMessageWithExtensions.DefaultInstance; } + } + + public override TestEmptyMessageWithExtensions BuildPartial() { + TestEmptyMessageWithExtensions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestEmptyMessageWithExtensions) { + return MergeFrom((TestEmptyMessageWithExtensions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestEmptyMessageWithExtensions other) { + if (other == TestEmptyMessageWithExtensions.DefaultInstance) return this; + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class TestReallyLargeTagNumber : pb::GeneratedMessage { + private static readonly TestReallyLargeTagNumber defaultInstance = new Builder().BuildPartial(); + public static TestReallyLargeTagNumber DefaultInstance { + get { return defaultInstance; } + } + + public override TestReallyLargeTagNumber DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestReallyLargeTagNumber ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestReallyLargeTagNumber__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestReallyLargeTagNumber__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + private bool hasBb; + private int bb_ = 0; + public bool HasBb { + get { return hasBb; } + } + public int Bb { + get { return bb_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + if (HasBb) { + output.WriteInt32(268435455, Bb); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + if (HasBb) { + size += pb::CodedOutputStream.ComputeInt32Size(268435455, Bb); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestReallyLargeTagNumber ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestReallyLargeTagNumber prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestReallyLargeTagNumber result = new TestReallyLargeTagNumber(); + + protected override TestReallyLargeTagNumber MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestReallyLargeTagNumber(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestReallyLargeTagNumber.Descriptor; } + } + + public override TestReallyLargeTagNumber DefaultInstanceForType { + get { return TestReallyLargeTagNumber.DefaultInstance; } + } + + public override TestReallyLargeTagNumber BuildPartial() { + TestReallyLargeTagNumber returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestReallyLargeTagNumber) { + return MergeFrom((TestReallyLargeTagNumber) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestReallyLargeTagNumber other) { + if (other == TestReallyLargeTagNumber.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + if (other.HasBb) { + Bb = other.Bb; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + case 2147483640: { + Bb = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + + public bool HasBb { + get { return result.HasBb; } + } + public int Bb { + get { return result.Bb; } + set { SetBb(value); } + } + public Builder SetBb(int value) { + result.hasBb = true; + result.bb_ = value; + return this; + } + public Builder ClearBb() { + result.hasBb = false; + result.bb_ = 0; + return this; + } + } + } + + public sealed partial class TestRecursiveMessage : pb::GeneratedMessage { + private static readonly TestRecursiveMessage defaultInstance = new Builder().BuildPartial(); + public static TestRecursiveMessage DefaultInstance { + get { return defaultInstance; } + } + + public override TestRecursiveMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestRecursiveMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRecursiveMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRecursiveMessage__FieldAccessorTable; } + } + + private bool hasA; + private global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage a_ = global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.DefaultInstance; + public bool HasA { + get { return hasA; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage A { + get { return a_; } + } + + private bool hasI; + private int i_ = 0; + public bool HasI { + get { return hasI; } + } + public int I { + get { return i_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteMessage(1, A); + } + if (HasI) { + output.WriteInt32(2, I); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeMessageSize(1, A); + } + if (HasI) { + size += pb::CodedOutputStream.ComputeInt32Size(2, I); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestRecursiveMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestRecursiveMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestRecursiveMessage result = new TestRecursiveMessage(); + + protected override TestRecursiveMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestRecursiveMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestRecursiveMessage.Descriptor; } + } + + public override TestRecursiveMessage DefaultInstanceForType { + get { return TestRecursiveMessage.DefaultInstance; } + } + + public override TestRecursiveMessage BuildPartial() { + TestRecursiveMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestRecursiveMessage) { + return MergeFrom((TestRecursiveMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestRecursiveMessage other) { + if (other == TestRecursiveMessage.DefaultInstance) return this; + if (other.HasA) { + MergeA(other.A); + } + if (other.HasI) { + I = other.I; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.CreateBuilder(); + if (HasA) { + subBuilder.MergeFrom(A); + } + input.ReadMessage(subBuilder, extensionRegistry); + A = subBuilder.BuildPartial(); + break; + } + case 16: { + I = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder SetA(global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.Builder builderForValue) { + result.hasA = true; + result.a_ = builderForValue.Build(); + return this; + } + public Builder MergeA(global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage value) { + if (result.HasA && + result.a_ != global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.DefaultInstance) { + result.a_ = global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.CreateBuilder(result.a_).MergeFrom(value).BuildPartial(); + } else { + result.a_ = value; + } + result.hasA = true; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.DefaultInstance; + return this; + } + + 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; + } + } + } + + public sealed partial class TestMutualRecursionA : pb::GeneratedMessage { + private static readonly TestMutualRecursionA defaultInstance = new Builder().BuildPartial(); + public static TestMutualRecursionA DefaultInstance { + get { return defaultInstance; } + } + + public override TestMutualRecursionA DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMutualRecursionA ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestMutualRecursionA__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestMutualRecursionA__FieldAccessorTable; } + } + + private bool hasBb; + private global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB bb_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.DefaultInstance; + public bool HasBb { + get { return hasBb; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB Bb { + get { return bb_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasBb) { + output.WriteMessage(1, Bb); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasBb) { + size += pb::CodedOutputStream.ComputeMessageSize(1, Bb); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMutualRecursionA ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMutualRecursionA prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMutualRecursionA result = new TestMutualRecursionA(); + + protected override TestMutualRecursionA MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMutualRecursionA(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMutualRecursionA.Descriptor; } + } + + public override TestMutualRecursionA DefaultInstanceForType { + get { return TestMutualRecursionA.DefaultInstance; } + } + + public override TestMutualRecursionA BuildPartial() { + TestMutualRecursionA returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMutualRecursionA) { + return MergeFrom((TestMutualRecursionA) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMutualRecursionA other) { + if (other == TestMutualRecursionA.DefaultInstance) return this; + if (other.HasBb) { + MergeBb(other.Bb); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.CreateBuilder(); + if (HasBb) { + subBuilder.MergeFrom(Bb); + } + input.ReadMessage(subBuilder, extensionRegistry); + Bb = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasBb { + get { return result.HasBb; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB Bb { + get { return result.Bb; } + set { SetBb(value); } + } + public Builder SetBb(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB value) { + result.hasBb = true; + result.bb_ = value; + return this; + } + public Builder SetBb(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.Builder builderForValue) { + result.hasBb = true; + result.bb_ = builderForValue.Build(); + return this; + } + public Builder MergeBb(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB value) { + if (result.HasBb && + result.bb_ != global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.DefaultInstance) { + result.bb_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.CreateBuilder(result.bb_).MergeFrom(value).BuildPartial(); + } else { + result.bb_ = value; + } + result.hasBb = true; + return this; + } + public Builder ClearBb() { + result.hasBb = false; + result.bb_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestMutualRecursionB : pb::GeneratedMessage { + private static readonly TestMutualRecursionB defaultInstance = new Builder().BuildPartial(); + public static TestMutualRecursionB DefaultInstance { + get { return defaultInstance; } + } + + public override TestMutualRecursionB DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMutualRecursionB ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestMutualRecursionB__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestMutualRecursionB__FieldAccessorTable; } + } + + private bool hasA; + private global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA a_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.DefaultInstance; + public bool HasA { + get { return hasA; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA A { + get { return a_; } + } + + private bool hasOptionalInt32; + private int optionalInt32_ = 0; + public bool HasOptionalInt32 { + get { return hasOptionalInt32; } + } + public int OptionalInt32 { + get { return optionalInt32_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteMessage(1, A); + } + if (HasOptionalInt32) { + output.WriteInt32(2, OptionalInt32); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeMessageSize(1, A); + } + if (HasOptionalInt32) { + size += pb::CodedOutputStream.ComputeInt32Size(2, OptionalInt32); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMutualRecursionB ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMutualRecursionB prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMutualRecursionB result = new TestMutualRecursionB(); + + protected override TestMutualRecursionB MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMutualRecursionB(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMutualRecursionB.Descriptor; } + } + + public override TestMutualRecursionB DefaultInstanceForType { + get { return TestMutualRecursionB.DefaultInstance; } + } + + public override TestMutualRecursionB BuildPartial() { + TestMutualRecursionB returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMutualRecursionB) { + return MergeFrom((TestMutualRecursionB) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMutualRecursionB other) { + if (other == TestMutualRecursionB.DefaultInstance) return this; + if (other.HasA) { + MergeA(other.A); + } + if (other.HasOptionalInt32) { + OptionalInt32 = other.OptionalInt32; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.CreateBuilder(); + if (HasA) { + subBuilder.MergeFrom(A); + } + input.ReadMessage(subBuilder, extensionRegistry); + A = subBuilder.BuildPartial(); + break; + } + case 16: { + OptionalInt32 = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder SetA(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.Builder builderForValue) { + result.hasA = true; + result.a_ = builderForValue.Build(); + return this; + } + public Builder MergeA(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA value) { + if (result.HasA && + result.a_ != global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.DefaultInstance) { + result.a_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.CreateBuilder(result.a_).MergeFrom(value).BuildPartial(); + } else { + result.a_ = value; + } + result.hasA = true; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.DefaultInstance; + return this; + } + + public bool HasOptionalInt32 { + get { return result.HasOptionalInt32; } + } + public int OptionalInt32 { + get { return result.OptionalInt32; } + set { SetOptionalInt32(value); } + } + public Builder SetOptionalInt32(int value) { + result.hasOptionalInt32 = true; + result.optionalInt32_ = value; + return this; + } + public Builder ClearOptionalInt32() { + result.hasOptionalInt32 = false; + result.optionalInt32_ = 0; + return this; + } + } + } + + public sealed partial class TestDupFieldNumber : pb::GeneratedMessage { + private static readonly TestDupFieldNumber defaultInstance = new Builder().BuildPartial(); + public static TestDupFieldNumber DefaultInstance { + get { return defaultInstance; } + } + + public override TestDupFieldNumber DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestDupFieldNumber ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class Foo : pb::GeneratedMessage { + private static readonly Foo defaultInstance = new Builder().BuildPartial(); + public static Foo DefaultInstance { + get { return defaultInstance; } + } + + public override Foo DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Foo ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber_Foo__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber_Foo__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Foo ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Foo ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Foo ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Foo ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Foo ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Foo ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Foo ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Foo ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Foo prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Foo result = new Foo(); + + protected override Foo MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Foo(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Foo.Descriptor; } + } + + public override Foo DefaultInstanceForType { + get { return Foo.DefaultInstance; } + } + + public override Foo BuildPartial() { + Foo returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Foo) { + return MergeFrom((Foo) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Foo other) { + if (other == Foo.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + public sealed partial class Bar : pb::GeneratedMessage { + private static readonly Bar defaultInstance = new Builder().BuildPartial(); + public static Bar DefaultInstance { + get { return defaultInstance; } + } + + public override Bar DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Bar ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber_Bar__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber_Bar__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Bar ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Bar ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Bar ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Bar ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Bar ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Bar ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Bar ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Bar ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Bar prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Bar result = new Bar(); + + protected override Bar MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Bar(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Bar.Descriptor; } + } + + public override Bar DefaultInstanceForType { + get { return Bar.DefaultInstance; } + } + + public override Bar BuildPartial() { + Bar returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Bar) { + return MergeFrom((Bar) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Bar other) { + if (other == Bar.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + private bool hasFoo; + private global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo foo_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.DefaultInstance; + public bool HasFoo { + get { return hasFoo; } + } + public global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo Foo { + get { return foo_; } + } + + private bool hasBar; + private global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar bar_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.DefaultInstance; + public bool HasBar { + get { return hasBar; } + } + public global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar Bar { + get { return bar_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + if (HasFoo) { + output.WriteGroup(2, Foo); + } + if (HasBar) { + output.WriteGroup(3, Bar); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + if (HasFoo) { + size += pb::CodedOutputStream.ComputeGroupSize(2, Foo); + } + if (HasBar) { + size += pb::CodedOutputStream.ComputeGroupSize(3, Bar); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestDupFieldNumber ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestDupFieldNumber prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestDupFieldNumber result = new TestDupFieldNumber(); + + protected override TestDupFieldNumber MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestDupFieldNumber(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestDupFieldNumber.Descriptor; } + } + + public override TestDupFieldNumber DefaultInstanceForType { + get { return TestDupFieldNumber.DefaultInstance; } + } + + public override TestDupFieldNumber BuildPartial() { + TestDupFieldNumber returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestDupFieldNumber) { + return MergeFrom((TestDupFieldNumber) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestDupFieldNumber other) { + if (other == TestDupFieldNumber.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + if (other.HasFoo) { + MergeFoo(other.Foo); + } + if (other.HasBar) { + MergeBar(other.Bar); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + case 19: { + global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.CreateBuilder(); + if (HasFoo) { + subBuilder.MergeFrom(Foo); + } + input.ReadGroup(2, subBuilder, extensionRegistry); + Foo = subBuilder.BuildPartial(); + break; + } + case 27: { + global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.CreateBuilder(); + if (HasBar) { + subBuilder.MergeFrom(Bar); + } + input.ReadGroup(3, subBuilder, extensionRegistry); + Bar = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + + public bool HasFoo { + get { return result.HasFoo; } + } + public global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo Foo { + get { return result.Foo; } + set { SetFoo(value); } + } + public Builder SetFoo(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo value) { + result.hasFoo = true; + result.foo_ = value; + return this; + } + public Builder SetFoo(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.Builder builderForValue) { + result.hasFoo = true; + result.foo_ = builderForValue.Build(); + return this; + } + public Builder MergeFoo(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo value) { + if (result.HasFoo && + result.foo_ != global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.DefaultInstance) { + result.foo_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.CreateBuilder(result.foo_).MergeFrom(value).BuildPartial(); + } else { + result.foo_ = value; + } + result.hasFoo = true; + return this; + } + public Builder ClearFoo() { + result.hasFoo = false; + result.foo_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.DefaultInstance; + return this; + } + + public bool HasBar { + get { return result.HasBar; } + } + public global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar Bar { + get { return result.Bar; } + set { SetBar(value); } + } + public Builder SetBar(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar value) { + result.hasBar = true; + result.bar_ = value; + return this; + } + public Builder SetBar(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.Builder builderForValue) { + result.hasBar = true; + result.bar_ = builderForValue.Build(); + return this; + } + public Builder MergeBar(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar value) { + if (result.HasBar && + result.bar_ != global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.DefaultInstance) { + result.bar_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.CreateBuilder(result.bar_).MergeFrom(value).BuildPartial(); + } else { + result.bar_ = value; + } + result.hasBar = true; + return this; + } + public Builder ClearBar() { + result.hasBar = false; + result.bar_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestNestedMessageHasBits : pb::GeneratedMessage { + private static readonly TestNestedMessageHasBits defaultInstance = new Builder().BuildPartial(); + public static TestNestedMessageHasBits DefaultInstance { + get { return defaultInstance; } + } + + public override TestNestedMessageHasBits DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestNestedMessageHasBits ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestNestedMessageHasBits__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestNestedMessageHasBits__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class NestedMessage : pb::GeneratedMessage { + private static readonly NestedMessage defaultInstance = new Builder().BuildPartial(); + public static NestedMessage DefaultInstance { + get { return defaultInstance; } + } + + public override NestedMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NestedMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__FieldAccessorTable; } + } + + private pbc::PopsicleList nestedmessageRepeatedInt32_ = new pbc::PopsicleList(); + public scg::IList NestedmessageRepeatedInt32List { + get { return pbc::Lists.AsReadOnly(nestedmessageRepeatedInt32_); } + } + public int NestedmessageRepeatedInt32Count { + get { return nestedmessageRepeatedInt32_.Count; } + } + public int GetNestedmessageRepeatedInt32(int index) { + return nestedmessageRepeatedInt32_[index]; + } + + private pbc::PopsicleList nestedmessageRepeatedForeignmessage_ = new pbc::PopsicleList(); + public scg::IList NestedmessageRepeatedForeignmessageList { + get { return nestedmessageRepeatedForeignmessage_; } + } + public int NestedmessageRepeatedForeignmessageCount { + get { return nestedmessageRepeatedForeignmessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetNestedmessageRepeatedForeignmessage(int index) { + return nestedmessageRepeatedForeignmessage_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (int element in NestedmessageRepeatedInt32List) { + output.WriteInt32(1, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in NestedmessageRepeatedForeignmessageList) { + output.WriteMessage(2, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (int element in NestedmessageRepeatedInt32List) { + size += pb::CodedOutputStream.ComputeInt32Size(1, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in NestedmessageRepeatedForeignmessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NestedMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NestedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NestedMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(NestedMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NestedMessage result = new NestedMessage(); + + protected override NestedMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NestedMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return NestedMessage.Descriptor; } + } + + public override NestedMessage DefaultInstanceForType { + get { return NestedMessage.DefaultInstance; } + } + + public override NestedMessage BuildPartial() { + result.nestedmessageRepeatedInt32_.MakeReadOnly(); + result.nestedmessageRepeatedForeignmessage_.MakeReadOnly(); + NestedMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NestedMessage) { + return MergeFrom((NestedMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NestedMessage other) { + if (other == NestedMessage.DefaultInstance) return this; + if (other.nestedmessageRepeatedInt32_.Count != 0) { + base.AddRange(other.nestedmessageRepeatedInt32_, result.nestedmessageRepeatedInt32_); + } + if (other.nestedmessageRepeatedForeignmessage_.Count != 0) { + base.AddRange(other.nestedmessageRepeatedForeignmessage_, result.nestedmessageRepeatedForeignmessage_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + AddNestedmessageRepeatedInt32(input.ReadInt32()); + break; + } + case 18: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddNestedmessageRepeatedForeignmessage(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList NestedmessageRepeatedInt32List { + get { return result.nestedmessageRepeatedInt32_; } + } + public int NestedmessageRepeatedInt32Count { + get { return result.NestedmessageRepeatedInt32Count; } + } + public int GetNestedmessageRepeatedInt32(int index) { + return result.GetNestedmessageRepeatedInt32(index); + } + public Builder SetNestedmessageRepeatedInt32(int index, int value) { + result.nestedmessageRepeatedInt32_[index] = value; + return this; + } + public Builder AddNestedmessageRepeatedInt32(int value) { + result.nestedmessageRepeatedInt32_.Add(value); + return this; + } + public Builder AddRangeNestedmessageRepeatedInt32(scg::IEnumerable values) { + base.AddRange(values, result.nestedmessageRepeatedInt32_); + return this; + } + public Builder ClearNestedmessageRepeatedInt32() { + result.nestedmessageRepeatedInt32_.Clear(); + return this; + } + + public scg::IList NestedmessageRepeatedForeignmessageList { + get { return result.nestedmessageRepeatedForeignmessage_; } + } + public int NestedmessageRepeatedForeignmessageCount { + get { return result.NestedmessageRepeatedForeignmessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetNestedmessageRepeatedForeignmessage(int index) { + return result.GetNestedmessageRepeatedForeignmessage(index); + } + public Builder SetNestedmessageRepeatedForeignmessage(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.nestedmessageRepeatedForeignmessage_[index] = value; + return this; + } + public Builder SetNestedmessageRepeatedForeignmessage(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.nestedmessageRepeatedForeignmessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddNestedmessageRepeatedForeignmessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.nestedmessageRepeatedForeignmessage_.Add(value); + return this; + } + public Builder AddNestedmessageRepeatedForeignmessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.nestedmessageRepeatedForeignmessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeNestedmessageRepeatedForeignmessage(scg::IEnumerable values) { + base.AddRange(values, result.nestedmessageRepeatedForeignmessage_); + return this; + } + public Builder ClearNestedmessageRepeatedForeignmessage() { + result.nestedmessageRepeatedForeignmessage_.Clear(); + return this; + } + } + } + + } + #endregion + + private bool hasOptionalNestedMessage; + private global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.DefaultInstance; + public bool HasOptionalNestedMessage { + get { return hasOptionalNestedMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage OptionalNestedMessage { + get { return optionalNestedMessage_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasOptionalNestedMessage) { + output.WriteMessage(1, OptionalNestedMessage); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasOptionalNestedMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(1, OptionalNestedMessage); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestNestedMessageHasBits ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestNestedMessageHasBits prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestNestedMessageHasBits result = new TestNestedMessageHasBits(); + + protected override TestNestedMessageHasBits MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestNestedMessageHasBits(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestNestedMessageHasBits.Descriptor; } + } + + public override TestNestedMessageHasBits DefaultInstanceForType { + get { return TestNestedMessageHasBits.DefaultInstance; } + } + + public override TestNestedMessageHasBits BuildPartial() { + TestNestedMessageHasBits returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestNestedMessageHasBits) { + return MergeFrom((TestNestedMessageHasBits) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestNestedMessageHasBits other) { + if (other == TestNestedMessageHasBits.DefaultInstance) return this; + if (other.HasOptionalNestedMessage) { + MergeOptionalNestedMessage(other.OptionalNestedMessage); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.CreateBuilder(); + if (HasOptionalNestedMessage) { + subBuilder.MergeFrom(OptionalNestedMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalNestedMessage = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasOptionalNestedMessage { + get { return result.HasOptionalNestedMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage OptionalNestedMessage { + get { return result.OptionalNestedMessage; } + set { SetOptionalNestedMessage(value); } + } + public Builder SetOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage value) { + result.hasOptionalNestedMessage = true; + result.optionalNestedMessage_ = value; + return this; + } + public Builder SetOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.Builder builderForValue) { + result.hasOptionalNestedMessage = true; + result.optionalNestedMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage value) { + if (result.HasOptionalNestedMessage && + result.optionalNestedMessage_ != global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.DefaultInstance) { + result.optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.CreateBuilder(result.optionalNestedMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalNestedMessage_ = value; + } + result.hasOptionalNestedMessage = true; + return this; + } + public Builder ClearOptionalNestedMessage() { + result.hasOptionalNestedMessage = false; + result.optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestCamelCaseFieldNames : pb::GeneratedMessage { + private static readonly TestCamelCaseFieldNames defaultInstance = new Builder().BuildPartial(); + public static TestCamelCaseFieldNames DefaultInstance { + get { return defaultInstance; } + } + + public override TestCamelCaseFieldNames DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestCamelCaseFieldNames ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestCamelCaseFieldNames__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestCamelCaseFieldNames__FieldAccessorTable; } + } + + private bool hasPrimitiveField; + private int primitiveField_ = 0; + public bool HasPrimitiveField { + get { return hasPrimitiveField; } + } + public int PrimitiveField { + get { return primitiveField_; } + } + + private bool hasStringField; + private string stringField_ = ""; + public bool HasStringField { + get { return hasStringField; } + } + public string StringField { + get { return stringField_; } + } + + private bool hasEnumField; + private global::Google.ProtocolBuffers.TestProtos.ForeignEnum enumField_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_FOO; + public bool HasEnumField { + get { return hasEnumField; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum EnumField { + get { return enumField_; } + } + + private bool hasMessageField; + private global::Google.ProtocolBuffers.TestProtos.ForeignMessage messageField_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + public bool HasMessageField { + get { return hasMessageField; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage MessageField { + get { return messageField_; } + } + + private bool hasStringPieceField; + private string stringPieceField_ = ""; + public bool HasStringPieceField { + get { return hasStringPieceField; } + } + public string StringPieceField { + get { return stringPieceField_; } + } + + private bool hasCordField; + private string cordField_ = ""; + public bool HasCordField { + get { return hasCordField; } + } + public string CordField { + get { return cordField_; } + } + + private pbc::PopsicleList repeatedPrimitiveField_ = new pbc::PopsicleList(); + public scg::IList RepeatedPrimitiveFieldList { + get { return pbc::Lists.AsReadOnly(repeatedPrimitiveField_); } + } + public int RepeatedPrimitiveFieldCount { + get { return repeatedPrimitiveField_.Count; } + } + public int GetRepeatedPrimitiveField(int index) { + return repeatedPrimitiveField_[index]; + } + + private pbc::PopsicleList repeatedStringField_ = new pbc::PopsicleList(); + public scg::IList RepeatedStringFieldList { + get { return pbc::Lists.AsReadOnly(repeatedStringField_); } + } + public int RepeatedStringFieldCount { + get { return repeatedStringField_.Count; } + } + public string GetRepeatedStringField(int index) { + return repeatedStringField_[index]; + } + + private pbc::PopsicleList repeatedEnumField_ = new pbc::PopsicleList(); + public scg::IList RepeatedEnumFieldList { + get { return pbc::Lists.AsReadOnly(repeatedEnumField_); } + } + public int RepeatedEnumFieldCount { + get { return repeatedEnumField_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetRepeatedEnumField(int index) { + return repeatedEnumField_[index]; + } + + private pbc::PopsicleList repeatedMessageField_ = new pbc::PopsicleList(); + public scg::IList RepeatedMessageFieldList { + get { return repeatedMessageField_; } + } + public int RepeatedMessageFieldCount { + get { return repeatedMessageField_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetRepeatedMessageField(int index) { + return repeatedMessageField_[index]; + } + + private pbc::PopsicleList repeatedStringPieceField_ = new pbc::PopsicleList(); + public scg::IList RepeatedStringPieceFieldList { + get { return pbc::Lists.AsReadOnly(repeatedStringPieceField_); } + } + public int RepeatedStringPieceFieldCount { + get { return repeatedStringPieceField_.Count; } + } + public string GetRepeatedStringPieceField(int index) { + return repeatedStringPieceField_[index]; + } + + private pbc::PopsicleList repeatedCordField_ = new pbc::PopsicleList(); + public scg::IList RepeatedCordFieldList { + get { return pbc::Lists.AsReadOnly(repeatedCordField_); } + } + public int RepeatedCordFieldCount { + get { return repeatedCordField_.Count; } + } + public string GetRepeatedCordField(int index) { + return repeatedCordField_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasPrimitiveField) { + output.WriteInt32(1, PrimitiveField); + } + if (HasStringField) { + output.WriteString(2, StringField); + } + if (HasEnumField) { + output.WriteEnum(3, (int) EnumField); + } + if (HasMessageField) { + output.WriteMessage(4, MessageField); + } + if (HasStringPieceField) { + output.WriteString(5, StringPieceField); + } + if (HasCordField) { + output.WriteString(6, CordField); + } + foreach (int element in RepeatedPrimitiveFieldList) { + output.WriteInt32(7, element); + } + foreach (string element in RepeatedStringFieldList) { + output.WriteString(8, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedEnumFieldList) { + output.WriteEnum(9, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedMessageFieldList) { + output.WriteMessage(10, element); + } + foreach (string element in RepeatedStringPieceFieldList) { + output.WriteString(11, element); + } + foreach (string element in RepeatedCordFieldList) { + output.WriteString(12, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasPrimitiveField) { + size += pb::CodedOutputStream.ComputeInt32Size(1, PrimitiveField); + } + if (HasStringField) { + size += pb::CodedOutputStream.ComputeStringSize(2, StringField); + } + if (HasEnumField) { + size += pb::CodedOutputStream.ComputeEnumSize(3, (int) EnumField); + } + if (HasMessageField) { + size += pb::CodedOutputStream.ComputeMessageSize(4, MessageField); + } + if (HasStringPieceField) { + size += pb::CodedOutputStream.ComputeStringSize(5, StringPieceField); + } + if (HasCordField) { + size += pb::CodedOutputStream.ComputeStringSize(6, CordField); + } + foreach (int element in RepeatedPrimitiveFieldList) { + size += pb::CodedOutputStream.ComputeInt32Size(7, element); + } + foreach (string element in RepeatedStringFieldList) { + size += pb::CodedOutputStream.ComputeStringSize(8, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedEnumFieldList) { + size += pb::CodedOutputStream.ComputeEnumSize(9, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedMessageFieldList) { + size += pb::CodedOutputStream.ComputeMessageSize(10, element); + } + foreach (string element in RepeatedStringPieceFieldList) { + size += pb::CodedOutputStream.ComputeStringSize(11, element); + } + foreach (string element in RepeatedCordFieldList) { + size += pb::CodedOutputStream.ComputeStringSize(12, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestCamelCaseFieldNames ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestCamelCaseFieldNames prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestCamelCaseFieldNames result = new TestCamelCaseFieldNames(); + + protected override TestCamelCaseFieldNames MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestCamelCaseFieldNames(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestCamelCaseFieldNames.Descriptor; } + } + + public override TestCamelCaseFieldNames DefaultInstanceForType { + get { return TestCamelCaseFieldNames.DefaultInstance; } + } + + public override TestCamelCaseFieldNames BuildPartial() { + result.repeatedPrimitiveField_.MakeReadOnly(); + result.repeatedStringField_.MakeReadOnly(); + result.repeatedEnumField_.MakeReadOnly(); + result.repeatedMessageField_.MakeReadOnly(); + result.repeatedStringPieceField_.MakeReadOnly(); + result.repeatedCordField_.MakeReadOnly(); + TestCamelCaseFieldNames returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestCamelCaseFieldNames) { + return MergeFrom((TestCamelCaseFieldNames) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestCamelCaseFieldNames other) { + if (other == TestCamelCaseFieldNames.DefaultInstance) return this; + if (other.HasPrimitiveField) { + PrimitiveField = other.PrimitiveField; + } + if (other.HasStringField) { + StringField = other.StringField; + } + if (other.HasEnumField) { + EnumField = other.EnumField; + } + if (other.HasMessageField) { + MergeMessageField(other.MessageField); + } + if (other.HasStringPieceField) { + StringPieceField = other.StringPieceField; + } + if (other.HasCordField) { + CordField = other.CordField; + } + if (other.repeatedPrimitiveField_.Count != 0) { + base.AddRange(other.repeatedPrimitiveField_, result.repeatedPrimitiveField_); + } + if (other.repeatedStringField_.Count != 0) { + base.AddRange(other.repeatedStringField_, result.repeatedStringField_); + } + if (other.repeatedEnumField_.Count != 0) { + base.AddRange(other.repeatedEnumField_, result.repeatedEnumField_); + } + if (other.repeatedMessageField_.Count != 0) { + base.AddRange(other.repeatedMessageField_, result.repeatedMessageField_); + } + if (other.repeatedStringPieceField_.Count != 0) { + base.AddRange(other.repeatedStringPieceField_, result.repeatedStringPieceField_); + } + if (other.repeatedCordField_.Count != 0) { + base.AddRange(other.repeatedCordField_, result.repeatedCordField_); + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + PrimitiveField = input.ReadInt32(); + break; + } + case 18: { + StringField = input.ReadString(); + break; + } + case 24: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(3, (ulong) rawValue); + } else { + EnumField = (global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue; + } + break; + } + case 34: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + if (HasMessageField) { + subBuilder.MergeFrom(MessageField); + } + input.ReadMessage(subBuilder, extensionRegistry); + MessageField = subBuilder.BuildPartial(); + break; + } + case 42: { + StringPieceField = input.ReadString(); + break; + } + case 50: { + CordField = input.ReadString(); + break; + } + case 56: { + AddRepeatedPrimitiveField(input.ReadInt32()); + break; + } + case 66: { + AddRepeatedStringField(input.ReadString()); + break; + } + case 72: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(9, (ulong) rawValue); + } else { + AddRepeatedEnumField((global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue); + } + break; + } + case 82: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedMessageField(subBuilder.BuildPartial()); + break; + } + case 90: { + AddRepeatedStringPieceField(input.ReadString()); + break; + } + case 98: { + AddRepeatedCordField(input.ReadString()); + break; + } + } + } + } + + + public bool HasPrimitiveField { + get { return result.HasPrimitiveField; } + } + public int PrimitiveField { + get { return result.PrimitiveField; } + set { SetPrimitiveField(value); } + } + public Builder SetPrimitiveField(int value) { + result.hasPrimitiveField = true; + result.primitiveField_ = value; + return this; + } + public Builder ClearPrimitiveField() { + result.hasPrimitiveField = false; + result.primitiveField_ = 0; + return this; + } + + public bool HasStringField { + get { return result.HasStringField; } + } + public string StringField { + get { return result.StringField; } + set { SetStringField(value); } + } + public Builder SetStringField(string value) { + result.hasStringField = true; + result.stringField_ = value; + return this; + } + public Builder ClearStringField() { + result.hasStringField = false; + result.stringField_ = ""; + return this; + } + + public bool HasEnumField { + get { return result.HasEnumField; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum EnumField { + get { return result.EnumField; } + set { SetEnumField(value); } + } + public Builder SetEnumField(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.hasEnumField = true; + result.enumField_ = value; + return this; + } + public Builder ClearEnumField() { + result.hasEnumField = false; + result.enumField_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_FOO; + return this; + } + + public bool HasMessageField { + get { return result.HasMessageField; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage MessageField { + get { return result.MessageField; } + set { SetMessageField(value); } + } + public Builder SetMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.hasMessageField = true; + result.messageField_ = value; + return this; + } + public Builder SetMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.hasMessageField = true; + result.messageField_ = builderForValue.Build(); + return this; + } + public Builder MergeMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + if (result.HasMessageField && + result.messageField_ != global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance) { + result.messageField_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(result.messageField_).MergeFrom(value).BuildPartial(); + } else { + result.messageField_ = value; + } + result.hasMessageField = true; + return this; + } + public Builder ClearMessageField() { + result.hasMessageField = false; + result.messageField_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + return this; + } + + public bool HasStringPieceField { + get { return result.HasStringPieceField; } + } + public string StringPieceField { + get { return result.StringPieceField; } + set { SetStringPieceField(value); } + } + public Builder SetStringPieceField(string value) { + result.hasStringPieceField = true; + result.stringPieceField_ = value; + return this; + } + public Builder ClearStringPieceField() { + result.hasStringPieceField = false; + result.stringPieceField_ = ""; + return this; + } + + public bool HasCordField { + get { return result.HasCordField; } + } + public string CordField { + get { return result.CordField; } + set { SetCordField(value); } + } + public Builder SetCordField(string value) { + result.hasCordField = true; + result.cordField_ = value; + return this; + } + public Builder ClearCordField() { + result.hasCordField = false; + result.cordField_ = ""; + return this; + } + + public scg::IList RepeatedPrimitiveFieldList { + get { return result.repeatedPrimitiveField_; } + } + public int RepeatedPrimitiveFieldCount { + get { return result.RepeatedPrimitiveFieldCount; } + } + public int GetRepeatedPrimitiveField(int index) { + return result.GetRepeatedPrimitiveField(index); + } + public Builder SetRepeatedPrimitiveField(int index, int value) { + result.repeatedPrimitiveField_[index] = value; + return this; + } + public Builder AddRepeatedPrimitiveField(int value) { + result.repeatedPrimitiveField_.Add(value); + return this; + } + public Builder AddRangeRepeatedPrimitiveField(scg::IEnumerable values) { + base.AddRange(values, result.repeatedPrimitiveField_); + return this; + } + public Builder ClearRepeatedPrimitiveField() { + result.repeatedPrimitiveField_.Clear(); + return this; + } + + public scg::IList RepeatedStringFieldList { + get { return result.repeatedStringField_; } + } + public int RepeatedStringFieldCount { + get { return result.RepeatedStringFieldCount; } + } + public string GetRepeatedStringField(int index) { + return result.GetRepeatedStringField(index); + } + public Builder SetRepeatedStringField(int index, string value) { + result.repeatedStringField_[index] = value; + return this; + } + public Builder AddRepeatedStringField(string value) { + result.repeatedStringField_.Add(value); + return this; + } + public Builder AddRangeRepeatedStringField(scg::IEnumerable values) { + base.AddRange(values, result.repeatedStringField_); + return this; + } + public Builder ClearRepeatedStringField() { + result.repeatedStringField_.Clear(); + return this; + } + + public scg::IList RepeatedEnumFieldList { + get { return result.repeatedEnumField_; } + } + public int RepeatedEnumFieldCount { + get { return result.RepeatedEnumFieldCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetRepeatedEnumField(int index) { + return result.GetRepeatedEnumField(index); + } + public Builder SetRepeatedEnumField(int index, global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.repeatedEnumField_[index] = value; + return this; + } + public Builder AddRepeatedEnumField(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.repeatedEnumField_.Add(value); + return this; + } + public Builder AddRangeRepeatedEnumField(scg::IEnumerable values) { + base.AddRange(values, result.repeatedEnumField_); + return this; + } + public Builder ClearRepeatedEnumField() { + result.repeatedEnumField_.Clear(); + return this; + } + + public scg::IList RepeatedMessageFieldList { + get { return result.repeatedMessageField_; } + } + public int RepeatedMessageFieldCount { + get { return result.RepeatedMessageFieldCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetRepeatedMessageField(int index) { + return result.GetRepeatedMessageField(index); + } + public Builder SetRepeatedMessageField(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.repeatedMessageField_[index] = value; + return this; + } + public Builder SetRepeatedMessageField(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.repeatedMessageField_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.repeatedMessageField_.Add(value); + return this; + } + public Builder AddRepeatedMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.repeatedMessageField_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedMessageField(scg::IEnumerable values) { + base.AddRange(values, result.repeatedMessageField_); + return this; + } + public Builder ClearRepeatedMessageField() { + result.repeatedMessageField_.Clear(); + return this; + } + + public scg::IList RepeatedStringPieceFieldList { + get { return result.repeatedStringPieceField_; } + } + public int RepeatedStringPieceFieldCount { + get { return result.RepeatedStringPieceFieldCount; } + } + public string GetRepeatedStringPieceField(int index) { + return result.GetRepeatedStringPieceField(index); + } + public Builder SetRepeatedStringPieceField(int index, string value) { + result.repeatedStringPieceField_[index] = value; + return this; + } + public Builder AddRepeatedStringPieceField(string value) { + result.repeatedStringPieceField_.Add(value); + return this; + } + public Builder AddRangeRepeatedStringPieceField(scg::IEnumerable values) { + base.AddRange(values, result.repeatedStringPieceField_); + return this; + } + public Builder ClearRepeatedStringPieceField() { + result.repeatedStringPieceField_.Clear(); + return this; + } + + public scg::IList RepeatedCordFieldList { + get { return result.repeatedCordField_; } + } + public int RepeatedCordFieldCount { + get { return result.RepeatedCordFieldCount; } + } + public string GetRepeatedCordField(int index) { + return result.GetRepeatedCordField(index); + } + public Builder SetRepeatedCordField(int index, string value) { + result.repeatedCordField_[index] = value; + return this; + } + public Builder AddRepeatedCordField(string value) { + result.repeatedCordField_.Add(value); + return this; + } + public Builder AddRangeRepeatedCordField(scg::IEnumerable values) { + base.AddRange(values, result.repeatedCordField_); + return this; + } + public Builder ClearRepeatedCordField() { + result.repeatedCordField_.Clear(); + return this; + } + } + } + + public sealed partial class TestFieldOrderings : pb::ExtendableMessage { + private static readonly TestFieldOrderings defaultInstance = new Builder().BuildPartial(); + public static TestFieldOrderings DefaultInstance { + get { return defaultInstance; } + } + + public override TestFieldOrderings DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestFieldOrderings ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestFieldOrderings__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestFieldOrderings__FieldAccessorTable; } + } + + private bool hasMyString; + private string myString_ = ""; + public bool HasMyString { + get { return hasMyString; } + } + public string MyString { + get { return myString_; } + } + + private bool hasMyInt; + private long myInt_ = 0L; + public bool HasMyInt { + get { return hasMyInt; } + } + public long MyInt { + get { return myInt_; } + } + + private bool hasMyFloat; + private float myFloat_ = 0F; + public bool HasMyFloat { + get { return hasMyFloat; } + } + public float MyFloat { + get { return myFloat_; } + } + + public override bool IsInitialized { + get { + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + if (HasMyInt) { + output.WriteInt64(1, MyInt); + } + extensionWriter.WriteUntil(11, output); + if (HasMyString) { + output.WriteString(11, MyString); + } + extensionWriter.WriteUntil(101, output); + if (HasMyFloat) { + output.WriteFloat(101, MyFloat); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasMyString) { + size += pb::CodedOutputStream.ComputeStringSize(11, MyString); + } + if (HasMyInt) { + size += pb::CodedOutputStream.ComputeInt64Size(1, MyInt); + } + if (HasMyFloat) { + size += pb::CodedOutputStream.ComputeFloatSize(101, MyFloat); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestFieldOrderings ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestFieldOrderings prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestFieldOrderings result = new TestFieldOrderings(); + + protected override TestFieldOrderings MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestFieldOrderings(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestFieldOrderings.Descriptor; } + } + + public override TestFieldOrderings DefaultInstanceForType { + get { return TestFieldOrderings.DefaultInstance; } + } + + public override TestFieldOrderings BuildPartial() { + TestFieldOrderings returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestFieldOrderings) { + return MergeFrom((TestFieldOrderings) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestFieldOrderings other) { + if (other == TestFieldOrderings.DefaultInstance) return this; + if (other.HasMyString) { + MyString = other.MyString; + } + if (other.HasMyInt) { + MyInt = other.MyInt; + } + if (other.HasMyFloat) { + MyFloat = other.MyFloat; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + MyInt = input.ReadInt64(); + break; + } + case 90: { + MyString = input.ReadString(); + break; + } + case 813: { + MyFloat = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasMyString { + get { return result.HasMyString; } + } + public string MyString { + get { return result.MyString; } + set { SetMyString(value); } + } + public Builder SetMyString(string value) { + result.hasMyString = true; + result.myString_ = value; + return this; + } + public Builder ClearMyString() { + result.hasMyString = false; + result.myString_ = ""; + return this; + } + + public bool HasMyInt { + get { return result.HasMyInt; } + } + public long MyInt { + get { return result.MyInt; } + set { SetMyInt(value); } + } + public Builder SetMyInt(long value) { + result.hasMyInt = true; + result.myInt_ = value; + return this; + } + public Builder ClearMyInt() { + result.hasMyInt = false; + result.myInt_ = 0L; + return this; + } + + public bool HasMyFloat { + get { return result.HasMyFloat; } + } + public float MyFloat { + get { return result.MyFloat; } + set { SetMyFloat(value); } + } + public Builder SetMyFloat(float value) { + result.hasMyFloat = true; + result.myFloat_ = value; + return this; + } + public Builder ClearMyFloat() { + result.hasMyFloat = false; + result.myFloat_ = 0F; + return this; + } + } + } + + public sealed partial class TestExtremeDefaultValues : pb::GeneratedMessage { + private static readonly TestExtremeDefaultValues defaultInstance = new Builder().BuildPartial(); + public static TestExtremeDefaultValues DefaultInstance { + get { return defaultInstance; } + } + + public override TestExtremeDefaultValues DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestExtremeDefaultValues ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestExtremeDefaultValues__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestExtremeDefaultValues__FieldAccessorTable; } + } + + private bool hasEscapedBytes; + private pb::ByteString escapedBytes_ = (pb::ByteString) global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Descriptor.Fields[0].DefaultValue; + public bool HasEscapedBytes { + get { return hasEscapedBytes; } + } + public pb::ByteString EscapedBytes { + get { return escapedBytes_; } + } + + private bool hasLargeUint32; + private uint largeUint32_ = 4294967295; + public bool HasLargeUint32 { + get { return hasLargeUint32; } + } + public uint LargeUint32 { + get { return largeUint32_; } + } + + private bool hasLargeUint64; + private ulong largeUint64_ = 18446744073709551615UL; + public bool HasLargeUint64 { + get { return hasLargeUint64; } + } + public ulong LargeUint64 { + get { return largeUint64_; } + } + + private bool hasSmallInt32; + private int smallInt32_ = -2147483647; + public bool HasSmallInt32 { + get { return hasSmallInt32; } + } + public int SmallInt32 { + get { return smallInt32_; } + } + + private bool hasSmallInt64; + private long smallInt64_ = -9223372036854775807L; + public bool HasSmallInt64 { + get { return hasSmallInt64; } + } + public long SmallInt64 { + get { return smallInt64_; } + } + + private bool hasUtf8String; + private string utf8String_ = (string) global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Descriptor.Fields[5].DefaultValue; + public bool HasUtf8String { + get { return hasUtf8String; } + } + public string Utf8String { + get { return utf8String_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasEscapedBytes) { + output.WriteBytes(1, EscapedBytes); + } + if (HasLargeUint32) { + output.WriteUInt32(2, LargeUint32); + } + if (HasLargeUint64) { + output.WriteUInt64(3, LargeUint64); + } + if (HasSmallInt32) { + output.WriteInt32(4, SmallInt32); + } + if (HasSmallInt64) { + output.WriteInt64(5, SmallInt64); + } + if (HasUtf8String) { + output.WriteString(6, Utf8String); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasEscapedBytes) { + size += pb::CodedOutputStream.ComputeBytesSize(1, EscapedBytes); + } + if (HasLargeUint32) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, LargeUint32); + } + if (HasLargeUint64) { + size += pb::CodedOutputStream.ComputeUInt64Size(3, LargeUint64); + } + if (HasSmallInt32) { + size += pb::CodedOutputStream.ComputeInt32Size(4, SmallInt32); + } + if (HasSmallInt64) { + size += pb::CodedOutputStream.ComputeInt64Size(5, SmallInt64); + } + if (HasUtf8String) { + size += pb::CodedOutputStream.ComputeStringSize(6, Utf8String); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestExtremeDefaultValues ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestExtremeDefaultValues prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestExtremeDefaultValues result = new TestExtremeDefaultValues(); + + protected override TestExtremeDefaultValues MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestExtremeDefaultValues(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestExtremeDefaultValues.Descriptor; } + } + + public override TestExtremeDefaultValues DefaultInstanceForType { + get { return TestExtremeDefaultValues.DefaultInstance; } + } + + public override TestExtremeDefaultValues BuildPartial() { + TestExtremeDefaultValues returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestExtremeDefaultValues) { + return MergeFrom((TestExtremeDefaultValues) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestExtremeDefaultValues other) { + if (other == TestExtremeDefaultValues.DefaultInstance) return this; + if (other.HasEscapedBytes) { + EscapedBytes = other.EscapedBytes; + } + if (other.HasLargeUint32) { + LargeUint32 = other.LargeUint32; + } + if (other.HasLargeUint64) { + LargeUint64 = other.LargeUint64; + } + if (other.HasSmallInt32) { + SmallInt32 = other.SmallInt32; + } + if (other.HasSmallInt64) { + SmallInt64 = other.SmallInt64; + } + if (other.HasUtf8String) { + Utf8String = other.Utf8String; + } + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + EscapedBytes = input.ReadBytes(); + break; + } + case 16: { + LargeUint32 = input.ReadUInt32(); + break; + } + case 24: { + LargeUint64 = input.ReadUInt64(); + break; + } + case 32: { + SmallInt32 = input.ReadInt32(); + break; + } + case 40: { + SmallInt64 = input.ReadInt64(); + break; + } + case 50: { + Utf8String = input.ReadString(); + break; + } + } + } + } + + + public bool HasEscapedBytes { + get { return result.HasEscapedBytes; } + } + public pb::ByteString EscapedBytes { + get { return result.EscapedBytes; } + set { SetEscapedBytes(value); } + } + public Builder SetEscapedBytes(pb::ByteString value) { + result.hasEscapedBytes = true; + result.escapedBytes_ = value; + return this; + } + public Builder ClearEscapedBytes() { + result.hasEscapedBytes = false; + result.escapedBytes_ = (pb::ByteString) global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Descriptor.Fields[0].DefaultValue; + return this; + } + + public bool HasLargeUint32 { + get { return result.HasLargeUint32; } + } + public uint LargeUint32 { + get { return result.LargeUint32; } + set { SetLargeUint32(value); } + } + public Builder SetLargeUint32(uint value) { + result.hasLargeUint32 = true; + result.largeUint32_ = value; + return this; + } + public Builder ClearLargeUint32() { + result.hasLargeUint32 = false; + result.largeUint32_ = 4294967295; + return this; + } + + public bool HasLargeUint64 { + get { return result.HasLargeUint64; } + } + public ulong LargeUint64 { + get { return result.LargeUint64; } + set { SetLargeUint64(value); } + } + public Builder SetLargeUint64(ulong value) { + result.hasLargeUint64 = true; + result.largeUint64_ = value; + return this; + } + public Builder ClearLargeUint64() { + result.hasLargeUint64 = false; + result.largeUint64_ = 18446744073709551615UL; + return this; + } + + public bool HasSmallInt32 { + get { return result.HasSmallInt32; } + } + public int SmallInt32 { + get { return result.SmallInt32; } + set { SetSmallInt32(value); } + } + public Builder SetSmallInt32(int value) { + result.hasSmallInt32 = true; + result.smallInt32_ = value; + return this; + } + public Builder ClearSmallInt32() { + result.hasSmallInt32 = false; + result.smallInt32_ = -2147483647; + return this; + } + + public bool HasSmallInt64 { + get { return result.HasSmallInt64; } + } + public long SmallInt64 { + get { return result.SmallInt64; } + set { SetSmallInt64(value); } + } + public Builder SetSmallInt64(long value) { + result.hasSmallInt64 = true; + result.smallInt64_ = value; + return this; + } + public Builder ClearSmallInt64() { + result.hasSmallInt64 = false; + result.smallInt64_ = -9223372036854775807L; + return this; + } + + public bool HasUtf8String { + get { return result.HasUtf8String; } + } + public string Utf8String { + get { return result.Utf8String; } + set { SetUtf8String(value); } + } + public Builder SetUtf8String(string value) { + result.hasUtf8String = true; + result.utf8String_ = value; + return this; + } + public Builder ClearUtf8String() { + result.hasUtf8String = false; + result.utf8String_ = (string) global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Descriptor.Fields[5].DefaultValue; + return this; + } + } + } + + public sealed partial class FooRequest : pb::GeneratedMessage { + private static readonly FooRequest defaultInstance = new Builder().BuildPartial(); + public static FooRequest DefaultInstance { + get { return defaultInstance; } + } + + public override FooRequest DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FooRequest ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_FooRequest__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_FooRequest__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FooRequest ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FooRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FooRequest ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FooRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FooRequest ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FooRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FooRequest ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FooRequest ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FooRequest prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FooRequest result = new FooRequest(); + + protected override FooRequest MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FooRequest(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FooRequest.Descriptor; } + } + + public override FooRequest DefaultInstanceForType { + get { return FooRequest.DefaultInstance; } + } + + public override FooRequest BuildPartial() { + FooRequest returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FooRequest) { + return MergeFrom((FooRequest) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FooRequest other) { + if (other == FooRequest.DefaultInstance) return this; + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class FooResponse : pb::GeneratedMessage { + private static readonly FooResponse defaultInstance = new Builder().BuildPartial(); + public static FooResponse DefaultInstance { + get { return defaultInstance; } + } + + public override FooResponse DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FooResponse ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_FooResponse__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_FooResponse__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FooResponse ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FooResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FooResponse ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FooResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FooResponse ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FooResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FooResponse ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FooResponse ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FooResponse prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FooResponse result = new FooResponse(); + + protected override FooResponse MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FooResponse(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FooResponse.Descriptor; } + } + + public override FooResponse DefaultInstanceForType { + get { return FooResponse.DefaultInstance; } + } + + public override FooResponse BuildPartial() { + FooResponse returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FooResponse) { + return MergeFrom((FooResponse) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FooResponse other) { + if (other == FooResponse.DefaultInstance) return this; + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class BarRequest : pb::GeneratedMessage { + private static readonly BarRequest defaultInstance = new Builder().BuildPartial(); + public static BarRequest DefaultInstance { + get { return defaultInstance; } + } + + public override BarRequest DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override BarRequest ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_BarRequest__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_BarRequest__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static BarRequest ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static BarRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static BarRequest ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static BarRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static BarRequest ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static BarRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static BarRequest ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static BarRequest ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(BarRequest prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + BarRequest result = new BarRequest(); + + protected override BarRequest MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new BarRequest(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return BarRequest.Descriptor; } + } + + public override BarRequest DefaultInstanceForType { + get { return BarRequest.DefaultInstance; } + } + + public override BarRequest BuildPartial() { + BarRequest returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is BarRequest) { + return MergeFrom((BarRequest) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(BarRequest other) { + if (other == BarRequest.DefaultInstance) return this; + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class BarResponse : pb::GeneratedMessage { + private static readonly BarResponse defaultInstance = new Builder().BuildPartial(); + public static BarResponse DefaultInstance { + get { return defaultInstance; } + } + + public override BarResponse DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override BarResponse ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_BarResponse__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_BarResponse__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static BarResponse ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static BarResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static BarResponse ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static BarResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static BarResponse ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static BarResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static BarResponse ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static BarResponse ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(BarResponse prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + BarResponse result = new BarResponse(); + + protected override BarResponse MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new BarResponse(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return BarResponse.Descriptor; } + } + + public override BarResponse DefaultInstanceForType { + get { return BarResponse.DefaultInstance; } + } + + public override BarResponse BuildPartial() { + BarResponse returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is BarResponse) { + return MergeFrom((BarResponse) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(BarResponse other) { + if (other == BarResponse.DefaultInstance) return this; + this.MergeUnknownFields(other.UnknownFields); + return this; + } + + public override Builder MergeFrom(pb::CodedInputStream input) { + return MergeFrom(input, pb::ExtensionRegistry.Empty); + } + + public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + #endregion + + #region Services + public abstract class TestService : pb::IService { + public abstract void Foo( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.FooRequest request, + global::System.Action done); + public abstract void Bar( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.BarRequest request, + global::System.Action done); + + public static pbd::ServiceDescriptor Descriptor { + get { return UnitTestProtoFile.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, (global::Google.ProtocolBuffers.TestProtos.FooRequest) request, + pb::RpcUtil.SpecializeCallback( + done)); + return; + case 1: + this.Bar(controller, (global::Google.ProtocolBuffers.TestProtos.BarRequest) 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 global::Google.ProtocolBuffers.TestProtos.FooRequest.DefaultInstance; + case 1: + return global::Google.ProtocolBuffers.TestProtos.BarRequest.DefaultInstance; + default: + throw new global::System.InvalidOperationException("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 global::Google.ProtocolBuffers.TestProtos.FooResponse.DefaultInstance; + case 1: + return global::Google.ProtocolBuffers.TestProtos.BarResponse.DefaultInstance; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public static Stub CreateStub(pb::IRpcChannel channel) { + return new Stub(channel); + } + + public class Stub : global::Google.ProtocolBuffers.TestProtos.TestService { + 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, + global::Google.ProtocolBuffers.TestProtos.FooRequest request, + global::System.Action done) { + channel.CallMethod(Descriptor.Methods[0], + controller, request, global::Google.ProtocolBuffers.TestProtos.FooResponse.DefaultInstance, + pb::RpcUtil.GeneralizeCallback(done, global::Google.ProtocolBuffers.TestProtos.FooResponse.DefaultInstance)); + } + + public override void Bar( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.BarRequest request, + global::System.Action done) { + channel.CallMethod(Descriptor.Methods[1], + controller, request, global::Google.ProtocolBuffers.TestProtos.BarResponse.DefaultInstance, + pb::RpcUtil.GeneralizeCallback(done, global::Google.ProtocolBuffers.TestProtos.BarResponse.DefaultInstance)); + } + } + } + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestUtil.cs b/src/ProtocolBuffers.Test/TestUtil.cs new file mode 100644 index 00000000..70dd3c88 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestUtil.cs @@ -0,0 +1,1370 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + internal static class TestUtil { + + private static string testDataDirectory; + private static ByteString goldenMessage = null; + + internal static string TestDataDirectory { + get { + if (testDataDirectory != null) { + return testDataDirectory; + } + + DirectoryInfo ancestor = new DirectoryInfo("."); + // Search each parent directory looking for "testdata". + while (ancestor != null) { + string candidate = Path.Combine(ancestor.FullName, "testdata"); + if (Directory.Exists(candidate)) { + return candidate; + } + ancestor = ancestor.Parent; + } + // TODO(jonskeet): Come up with a better exception to throw + throw new Exception("Unable to find directory containing test files"); + } + } + + internal static ByteString GoldenMessage { + get { + if (goldenMessage == null) { + goldenMessage = ReadBytesFromFile("golden_message"); + } + return goldenMessage; + } + } + + /// + /// Creates an unmodifiable ExtensionRegistry containing all the extensions + /// of TestAllExtensions. + /// + /// + internal static ExtensionRegistry CreateExtensionRegistry() { + ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); + RegisterAllExtensions(registry); + return registry.AsReadOnly(); + } + + /// + /// Registers all of the extensions in TestAllExtensions with the given + /// ExtensionRegistry. + /// + internal static void RegisterAllExtensions(ExtensionRegistry registry) { + registry.Add(UnitTestProtoFile.OptionalInt32Extension); + registry.Add(UnitTestProtoFile.OptionalInt64Extension); + registry.Add(UnitTestProtoFile.OptionalUint32Extension); + registry.Add(UnitTestProtoFile.OptionalUint64Extension); + registry.Add(UnitTestProtoFile.OptionalSint32Extension); + registry.Add(UnitTestProtoFile.OptionalSint64Extension); + registry.Add(UnitTestProtoFile.OptionalFixed32Extension); + registry.Add(UnitTestProtoFile.OptionalFixed64Extension); + registry.Add(UnitTestProtoFile.OptionalSfixed32Extension); + registry.Add(UnitTestProtoFile.OptionalSfixed64Extension); + registry.Add(UnitTestProtoFile.OptionalFloatExtension); + registry.Add(UnitTestProtoFile.OptionalDoubleExtension); + registry.Add(UnitTestProtoFile.OptionalBoolExtension); + registry.Add(UnitTestProtoFile.OptionalStringExtension); + registry.Add(UnitTestProtoFile.OptionalBytesExtension); + registry.Add(UnitTestProtoFile.OptionalGroupExtension); + registry.Add(UnitTestProtoFile.OptionalNestedMessageExtension); + registry.Add(UnitTestProtoFile.OptionalForeignMessageExtension); + registry.Add(UnitTestProtoFile.OptionalImportMessageExtension); + registry.Add(UnitTestProtoFile.OptionalNestedEnumExtension); + registry.Add(UnitTestProtoFile.OptionalForeignEnumExtension); + registry.Add(UnitTestProtoFile.OptionalImportEnumExtension); + registry.Add(UnitTestProtoFile.OptionalStringPieceExtension); + registry.Add(UnitTestProtoFile.OptionalCordExtension); + + registry.Add(UnitTestProtoFile.RepeatedInt32Extension); + registry.Add(UnitTestProtoFile.RepeatedInt64Extension); + registry.Add(UnitTestProtoFile.RepeatedUint32Extension); + registry.Add(UnitTestProtoFile.RepeatedUint64Extension); + registry.Add(UnitTestProtoFile.RepeatedSint32Extension); + registry.Add(UnitTestProtoFile.RepeatedSint64Extension); + registry.Add(UnitTestProtoFile.RepeatedFixed32Extension); + registry.Add(UnitTestProtoFile.RepeatedFixed64Extension); + registry.Add(UnitTestProtoFile.RepeatedSfixed32Extension); + registry.Add(UnitTestProtoFile.RepeatedSfixed64Extension); + registry.Add(UnitTestProtoFile.RepeatedFloatExtension); + registry.Add(UnitTestProtoFile.RepeatedDoubleExtension); + registry.Add(UnitTestProtoFile.RepeatedBoolExtension); + registry.Add(UnitTestProtoFile.RepeatedStringExtension); + registry.Add(UnitTestProtoFile.RepeatedBytesExtension); + registry.Add(UnitTestProtoFile.RepeatedGroupExtension); + registry.Add(UnitTestProtoFile.RepeatedNestedMessageExtension); + registry.Add(UnitTestProtoFile.RepeatedForeignMessageExtension); + registry.Add(UnitTestProtoFile.RepeatedImportMessageExtension); + registry.Add(UnitTestProtoFile.RepeatedNestedEnumExtension); + registry.Add(UnitTestProtoFile.RepeatedForeignEnumExtension); + registry.Add(UnitTestProtoFile.RepeatedImportEnumExtension); + registry.Add(UnitTestProtoFile.RepeatedStringPieceExtension); + registry.Add(UnitTestProtoFile.RepeatedCordExtension); + + registry.Add(UnitTestProtoFile.DefaultInt32Extension); + registry.Add(UnitTestProtoFile.DefaultInt64Extension); + registry.Add(UnitTestProtoFile.DefaultUint32Extension); + registry.Add(UnitTestProtoFile.DefaultUint64Extension); + registry.Add(UnitTestProtoFile.DefaultSint32Extension); + registry.Add(UnitTestProtoFile.DefaultSint64Extension); + registry.Add(UnitTestProtoFile.DefaultFixed32Extension); + registry.Add(UnitTestProtoFile.DefaultFixed64Extension); + registry.Add(UnitTestProtoFile.DefaultSfixed32Extension); + registry.Add(UnitTestProtoFile.DefaultSfixed64Extension); + registry.Add(UnitTestProtoFile.DefaultFloatExtension); + registry.Add(UnitTestProtoFile.DefaultDoubleExtension); + registry.Add(UnitTestProtoFile.DefaultBoolExtension); + registry.Add(UnitTestProtoFile.DefaultStringExtension); + registry.Add(UnitTestProtoFile.DefaultBytesExtension); + registry.Add(UnitTestProtoFile.DefaultNestedEnumExtension); + registry.Add(UnitTestProtoFile.DefaultForeignEnumExtension); + registry.Add(UnitTestProtoFile.DefaultImportEnumExtension); + registry.Add(UnitTestProtoFile.DefaultStringPieceExtension); + registry.Add(UnitTestProtoFile.DefaultCordExtension); + } + + internal static string ReadTextFromFile(string filePath) { + return ReadBytesFromFile(filePath).ToStringUtf8(); + } + + internal static ByteString ReadBytesFromFile(String filename) { + byte[] data = File.ReadAllBytes(Path.Combine(TestDataDirectory, filename)); + return ByteString.CopyFrom(data); + } + + /// + /// Helper to convert a String to ByteString. + /// + internal static ByteString ToBytes(String str) { + return ByteString.CopyFrom(Encoding.UTF8.GetBytes(str)); + } + + internal static TestAllTypes GetAllSet() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + SetAllFields(builder); + return builder.Build(); + } + + /// + /// Sets every field of the specified message to the values expected by + /// AssertAllFieldsSet. + /// + internal static void SetAllFields(TestAllTypes.Builder message) { + message.SetOptionalInt32(101); + message.SetOptionalInt64(102); + message.SetOptionalUint32(103); + message.SetOptionalUint64(104); + message.SetOptionalSint32(105); + message.SetOptionalSint64(106); + message.SetOptionalFixed32(107); + message.SetOptionalFixed64(108); + message.SetOptionalSfixed32(109); + message.SetOptionalSfixed64(110); + message.SetOptionalFloat(111); + message.SetOptionalDouble(112); + message.SetOptionalBool(true); + message.SetOptionalString("115"); + message.SetOptionalBytes(ToBytes("116")); + + message.SetOptionalGroup(TestAllTypes.Types.OptionalGroup.CreateBuilder().SetA(117).Build()); + message.SetOptionalNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(118).Build()); + message.SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(119).Build()); + message.SetOptionalImportMessage(ImportMessage.CreateBuilder().SetD(120).Build()); + + message.SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.BAZ); + message.SetOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ); + message.SetOptionalImportEnum(ImportEnum.IMPORT_BAZ); + + message.SetOptionalStringPiece("124"); + message.SetOptionalCord("125"); + + // ----------------------------------------------------------------- + + message.AddRepeatedInt32(201); + message.AddRepeatedInt64(202); + message.AddRepeatedUint32(203); + message.AddRepeatedUint64(204); + message.AddRepeatedSint32(205); + message.AddRepeatedSint64(206); + message.AddRepeatedFixed32(207); + message.AddRepeatedFixed64(208); + message.AddRepeatedSfixed32(209); + message.AddRepeatedSfixed64(210); + message.AddRepeatedFloat(211); + message.AddRepeatedDouble(212); + message.AddRepeatedBool(true); + message.AddRepeatedString("215"); + message.AddRepeatedBytes(ToBytes("216")); + + message.AddRepeatedGroup(TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(217).Build()); + message.AddRepeatedNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(218).Build()); + message.AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(219).Build()); + message.AddRepeatedImportMessage(ImportMessage.CreateBuilder().SetD(220).Build()); + + message.AddRepeatedNestedEnum(TestAllTypes.Types.NestedEnum.BAR); + message.AddRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR); + message.AddRepeatedImportEnum(ImportEnum.IMPORT_BAR); + + message.AddRepeatedStringPiece("224"); + message.AddRepeatedCord("225"); + + // Add a second one of each field. + message.AddRepeatedInt32(301); + message.AddRepeatedInt64(302); + message.AddRepeatedUint32(303); + message.AddRepeatedUint64(304); + message.AddRepeatedSint32(305); + message.AddRepeatedSint64(306); + message.AddRepeatedFixed32(307); + message.AddRepeatedFixed64(308); + message.AddRepeatedSfixed32(309); + message.AddRepeatedSfixed64(310); + message.AddRepeatedFloat(311); + message.AddRepeatedDouble(312); + message.AddRepeatedBool(false); + message.AddRepeatedString("315"); + message.AddRepeatedBytes(ToBytes("316")); + + message.AddRepeatedGroup(TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(317).Build()); + message.AddRepeatedNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(318).Build()); + message.AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(319).Build()); + message.AddRepeatedImportMessage(ImportMessage.CreateBuilder().SetD(320).Build()); + + message.AddRepeatedNestedEnum(TestAllTypes.Types.NestedEnum.BAZ); + message.AddRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ); + message.AddRepeatedImportEnum(ImportEnum.IMPORT_BAZ); + + message.AddRepeatedStringPiece("324"); + message.AddRepeatedCord("325"); + + // ----------------------------------------------------------------- + + message.SetDefaultInt32(401); + message.SetDefaultInt64(402); + message.SetDefaultUint32(403); + message.SetDefaultUint64(404); + message.SetDefaultSint32(405); + message.SetDefaultSint64(406); + message.SetDefaultFixed32(407); + message.SetDefaultFixed64(408); + message.SetDefaultSfixed32(409); + message.SetDefaultSfixed64(410); + message.SetDefaultFloat(411); + message.SetDefaultDouble(412); + message.SetDefaultBool(false); + message.SetDefaultString("415"); + message.SetDefaultBytes(ToBytes("416")); + + message.SetDefaultNestedEnum(TestAllTypes.Types.NestedEnum.FOO); + message.SetDefaultForeignEnum(ForeignEnum.FOREIGN_FOO); + message.SetDefaultImportEnum(ImportEnum.IMPORT_FOO); + + message.SetDefaultStringPiece("424"); + message.SetDefaultCord("425"); + } + + /// + /// Asserts that all fields of the specified message are set to the values + /// assigned by SetAllFields. + /// + internal static void AssertAllFieldsSet(TestAllTypes message) { + Assert.IsTrue(message.HasOptionalInt32); + Assert.IsTrue(message.HasOptionalInt64); + Assert.IsTrue(message.HasOptionalUint32); + Assert.IsTrue(message.HasOptionalUint64); + Assert.IsTrue(message.HasOptionalSint32); + Assert.IsTrue(message.HasOptionalSint64); + Assert.IsTrue(message.HasOptionalFixed32); + Assert.IsTrue(message.HasOptionalFixed64); + Assert.IsTrue(message.HasOptionalSfixed32); + Assert.IsTrue(message.HasOptionalSfixed64); + Assert.IsTrue(message.HasOptionalFloat); + Assert.IsTrue(message.HasOptionalDouble); + Assert.IsTrue(message.HasOptionalBool); + Assert.IsTrue(message.HasOptionalString); + Assert.IsTrue(message.HasOptionalBytes); + + Assert.IsTrue(message.HasOptionalGroup); + Assert.IsTrue(message.HasOptionalNestedMessage); + Assert.IsTrue(message.HasOptionalForeignMessage); + Assert.IsTrue(message.HasOptionalImportMessage); + + Assert.IsTrue(message.OptionalGroup.HasA); + Assert.IsTrue(message.OptionalNestedMessage.HasBb); + Assert.IsTrue(message.OptionalForeignMessage.HasC); + Assert.IsTrue(message.OptionalImportMessage.HasD); + + Assert.IsTrue(message.HasOptionalNestedEnum); + Assert.IsTrue(message.HasOptionalForeignEnum); + Assert.IsTrue(message.HasOptionalImportEnum); + + Assert.IsTrue(message.HasOptionalStringPiece); + Assert.IsTrue(message.HasOptionalCord); + + Assert.AreEqual(101, message.OptionalInt32); + Assert.AreEqual(102, message.OptionalInt64); + Assert.AreEqual(103, message.OptionalUint32); + Assert.AreEqual(104, message.OptionalUint64); + Assert.AreEqual(105, message.OptionalSint32); + Assert.AreEqual(106, message.OptionalSint64); + Assert.AreEqual(107, message.OptionalFixed32); + Assert.AreEqual(108, message.OptionalFixed64); + Assert.AreEqual(109, message.OptionalSfixed32); + Assert.AreEqual(110, message.OptionalSfixed64); + Assert.AreEqual(111, message.OptionalFloat); + Assert.AreEqual(112, message.OptionalDouble); + Assert.AreEqual(true, message.OptionalBool); + Assert.AreEqual("115", message.OptionalString); + Assert.AreEqual(ToBytes("116"), message.OptionalBytes); + + Assert.AreEqual(117, message.OptionalGroup.A); + Assert.AreEqual(118, message.OptionalNestedMessage.Bb); + Assert.AreEqual(119, message.OptionalForeignMessage.C); + Assert.AreEqual(120, message.OptionalImportMessage.D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.OptionalNestedEnum); + Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.OptionalForeignEnum); + Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.OptionalImportEnum); + + Assert.AreEqual("124", message.OptionalStringPiece); + Assert.AreEqual("125", message.OptionalCord); + + // ----------------------------------------------------------------- + + Assert.AreEqual(2, message.RepeatedInt32Count); + Assert.AreEqual(2, message.RepeatedInt64Count); + Assert.AreEqual(2, message.RepeatedUint32Count); + Assert.AreEqual(2, message.RepeatedUint64Count); + Assert.AreEqual(2, message.RepeatedSint32Count); + Assert.AreEqual(2, message.RepeatedSint64Count); + Assert.AreEqual(2, message.RepeatedFixed32Count); + Assert.AreEqual(2, message.RepeatedFixed64Count); + Assert.AreEqual(2, message.RepeatedSfixed32Count); + Assert.AreEqual(2, message.RepeatedSfixed64Count); + Assert.AreEqual(2, message.RepeatedFloatCount); + Assert.AreEqual(2, message.RepeatedDoubleCount); + Assert.AreEqual(2, message.RepeatedBoolCount); + Assert.AreEqual(2, message.RepeatedStringCount); + Assert.AreEqual(2, message.RepeatedBytesCount); + + Assert.AreEqual(2, message.RepeatedGroupCount ); + Assert.AreEqual(2, message.RepeatedNestedMessageCount ); + Assert.AreEqual(2, message.RepeatedForeignMessageCount); + Assert.AreEqual(2, message.RepeatedImportMessageCount ); + Assert.AreEqual(2, message.RepeatedNestedEnumCount ); + Assert.AreEqual(2, message.RepeatedForeignEnumCount ); + Assert.AreEqual(2, message.RepeatedImportEnumCount ); + + Assert.AreEqual(2, message.RepeatedStringPieceCount); + Assert.AreEqual(2, message.RepeatedCordCount); + + Assert.AreEqual(201, message.GetRepeatedInt32(0)); + Assert.AreEqual(202, message.GetRepeatedInt64(0)); + Assert.AreEqual(203, message.GetRepeatedUint32(0)); + Assert.AreEqual(204, message.GetRepeatedUint64(0)); + Assert.AreEqual(205, message.GetRepeatedSint32(0)); + Assert.AreEqual(206, message.GetRepeatedSint64(0)); + Assert.AreEqual(207, message.GetRepeatedFixed32(0)); + Assert.AreEqual(208, message.GetRepeatedFixed64(0)); + Assert.AreEqual(209, message.GetRepeatedSfixed32(0)); + Assert.AreEqual(210, message.GetRepeatedSfixed64(0)); + Assert.AreEqual(211, message.GetRepeatedFloat(0)); + Assert.AreEqual(212, message.GetRepeatedDouble(0)); + Assert.AreEqual(true , message.GetRepeatedBool(0)); + Assert.AreEqual("215", message.GetRepeatedString(0)); + Assert.AreEqual(ToBytes("216"), message.GetRepeatedBytes(0)); + + Assert.AreEqual(217, message.GetRepeatedGroup(0).A); + Assert.AreEqual(218, message.GetRepeatedNestedMessage (0).Bb); + Assert.AreEqual(219, message.GetRepeatedForeignMessage(0).C); + Assert.AreEqual(220, message.GetRepeatedImportMessage (0).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum (0)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); + + Assert.AreEqual("224", message.GetRepeatedStringPiece(0)); + Assert.AreEqual("225", message.GetRepeatedCord(0)); + + Assert.AreEqual(301, message.GetRepeatedInt32 (1)); + Assert.AreEqual(302, message.GetRepeatedInt64 (1)); + Assert.AreEqual(303, message.GetRepeatedUint32 (1)); + Assert.AreEqual(304, message.GetRepeatedUint64 (1)); + Assert.AreEqual(305, message.GetRepeatedSint32 (1)); + Assert.AreEqual(306, message.GetRepeatedSint64 (1)); + Assert.AreEqual(307, message.GetRepeatedFixed32 (1)); + Assert.AreEqual(308, message.GetRepeatedFixed64 (1)); + Assert.AreEqual(309, message.GetRepeatedSfixed32(1)); + Assert.AreEqual(310, message.GetRepeatedSfixed64(1)); + Assert.AreEqual(311, message.GetRepeatedFloat (1), 0.0); + Assert.AreEqual(312, message.GetRepeatedDouble (1), 0.0); + Assert.AreEqual(false, message.GetRepeatedBool (1)); + Assert.AreEqual("315", message.GetRepeatedString (1)); + Assert.AreEqual(ToBytes("316"), message.GetRepeatedBytes(1)); + + Assert.AreEqual(317, message.GetRepeatedGroup (1).A); + Assert.AreEqual(318, message.GetRepeatedNestedMessage (1).Bb); + Assert.AreEqual(319, message.GetRepeatedForeignMessage(1).C); + Assert.AreEqual(320, message.GetRepeatedImportMessage (1).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetRepeatedNestedEnum (1)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetRepeatedForeignEnum(1)); + Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetRepeatedImportEnum(1)); + + Assert.AreEqual("324", message.GetRepeatedStringPiece(1)); + Assert.AreEqual("325", message.GetRepeatedCord(1)); + + // ----------------------------------------------------------------- + + Assert.IsTrue(message.HasDefaultInt32 ); + Assert.IsTrue(message.HasDefaultInt64 ); + Assert.IsTrue(message.HasDefaultUint32 ); + Assert.IsTrue(message.HasDefaultUint64 ); + Assert.IsTrue(message.HasDefaultSint32 ); + Assert.IsTrue(message.HasDefaultSint64 ); + Assert.IsTrue(message.HasDefaultFixed32 ); + Assert.IsTrue(message.HasDefaultFixed64 ); + Assert.IsTrue(message.HasDefaultSfixed32); + Assert.IsTrue(message.HasDefaultSfixed64); + Assert.IsTrue(message.HasDefaultFloat ); + Assert.IsTrue(message.HasDefaultDouble ); + Assert.IsTrue(message.HasDefaultBool ); + Assert.IsTrue(message.HasDefaultString ); + Assert.IsTrue(message.HasDefaultBytes ); + + Assert.IsTrue(message.HasDefaultNestedEnum ); + Assert.IsTrue(message.HasDefaultForeignEnum); + Assert.IsTrue(message.HasDefaultImportEnum ); + + Assert.IsTrue(message.HasDefaultStringPiece); + Assert.IsTrue(message.HasDefaultCord); + + Assert.AreEqual(401, message.DefaultInt32); + Assert.AreEqual(402, message.DefaultInt64); + Assert.AreEqual(403, message.DefaultUint32); + Assert.AreEqual(404, message.DefaultUint64); + Assert.AreEqual(405, message.DefaultSint32); + Assert.AreEqual(406, message.DefaultSint64); + Assert.AreEqual(407, message.DefaultFixed32); + Assert.AreEqual(408, message.DefaultFixed64); + Assert.AreEqual(409, message.DefaultSfixed32); + Assert.AreEqual(410, message.DefaultSfixed64); + Assert.AreEqual(411, message.DefaultFloat); + Assert.AreEqual(412, message.DefaultDouble); + Assert.AreEqual(false, message.DefaultBool ); + Assert.AreEqual("415", message.DefaultString ); + Assert.AreEqual(ToBytes("416"), message.DefaultBytes); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.DefaultNestedEnum); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.DefaultForeignEnum); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.DefaultImportEnum); + + Assert.AreEqual("424", message.DefaultStringPiece); + Assert.AreEqual("425", message.DefaultCord); + } + + internal static void AssertClear(TestAllTypes message) { + // HasBlah() should initially be false for all optional fields. + Assert.IsFalse(message.HasOptionalInt32); + Assert.IsFalse(message.HasOptionalInt64); + Assert.IsFalse(message.HasOptionalUint32); + Assert.IsFalse(message.HasOptionalUint64); + Assert.IsFalse(message.HasOptionalSint32); + Assert.IsFalse(message.HasOptionalSint64); + Assert.IsFalse(message.HasOptionalFixed32); + Assert.IsFalse(message.HasOptionalFixed64); + Assert.IsFalse(message.HasOptionalSfixed32); + Assert.IsFalse(message.HasOptionalSfixed64); + Assert.IsFalse(message.HasOptionalFloat); + Assert.IsFalse(message.HasOptionalDouble); + Assert.IsFalse(message.HasOptionalBool); + Assert.IsFalse(message.HasOptionalString); + Assert.IsFalse(message.HasOptionalBytes); + + Assert.IsFalse(message.HasOptionalGroup); + Assert.IsFalse(message.HasOptionalNestedMessage); + Assert.IsFalse(message.HasOptionalForeignMessage); + Assert.IsFalse(message.HasOptionalImportMessage); + + Assert.IsFalse(message.HasOptionalNestedEnum); + Assert.IsFalse(message.HasOptionalForeignEnum); + Assert.IsFalse(message.HasOptionalImportEnum); + + Assert.IsFalse(message.HasOptionalStringPiece); + Assert.IsFalse(message.HasOptionalCord); + + // Optional fields without defaults are set to zero or something like it. + Assert.AreEqual(0, message.OptionalInt32); + Assert.AreEqual(0, message.OptionalInt64); + Assert.AreEqual(0, message.OptionalUint32); + Assert.AreEqual(0, message.OptionalUint64); + Assert.AreEqual(0, message.OptionalSint32); + Assert.AreEqual(0, message.OptionalSint64); + Assert.AreEqual(0, message.OptionalFixed32); + Assert.AreEqual(0, message.OptionalFixed64); + Assert.AreEqual(0, message.OptionalSfixed32); + Assert.AreEqual(0, message.OptionalSfixed64); + Assert.AreEqual(0, message.OptionalFloat); + Assert.AreEqual(0, message.OptionalDouble); + Assert.AreEqual(false, message.OptionalBool); + Assert.AreEqual("", message.OptionalString); + Assert.AreEqual(ByteString.Empty, message.OptionalBytes); + + // Embedded messages should also be clear. + Assert.IsFalse(message.OptionalGroup.HasA); + Assert.IsFalse(message.OptionalNestedMessage.HasBb); + Assert.IsFalse(message.OptionalForeignMessage.HasC); + Assert.IsFalse(message.OptionalImportMessage.HasD); + + Assert.AreEqual(0, message.OptionalGroup.A); + Assert.AreEqual(0, message.OptionalNestedMessage.Bb); + Assert.AreEqual(0, message.OptionalForeignMessage.C); + Assert.AreEqual(0, message.OptionalImportMessage.D); + + // Enums without defaults are set to the first value in the enum. + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.OptionalNestedEnum); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.OptionalForeignEnum); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.OptionalImportEnum); + + Assert.AreEqual("", message.OptionalStringPiece); + Assert.AreEqual("", message.OptionalCord); + + // Repeated fields are empty. + Assert.AreEqual(0, message.RepeatedInt32Count); + Assert.AreEqual(0, message.RepeatedInt64Count); + Assert.AreEqual(0, message.RepeatedUint32Count); + Assert.AreEqual(0, message.RepeatedUint64Count); + Assert.AreEqual(0, message.RepeatedSint32Count); + Assert.AreEqual(0, message.RepeatedSint64Count); + Assert.AreEqual(0, message.RepeatedFixed32Count); + Assert.AreEqual(0, message.RepeatedFixed64Count); + Assert.AreEqual(0, message.RepeatedSfixed32Count); + Assert.AreEqual(0, message.RepeatedSfixed64Count); + Assert.AreEqual(0, message.RepeatedFloatCount); + Assert.AreEqual(0, message.RepeatedDoubleCount); + Assert.AreEqual(0, message.RepeatedBoolCount); + Assert.AreEqual(0, message.RepeatedStringCount); + Assert.AreEqual(0, message.RepeatedBytesCount); + + Assert.AreEqual(0, message.RepeatedGroupCount); + Assert.AreEqual(0, message.RepeatedNestedMessageCount); + Assert.AreEqual(0, message.RepeatedForeignMessageCount); + Assert.AreEqual(0, message.RepeatedImportMessageCount); + Assert.AreEqual(0, message.RepeatedNestedEnumCount); + Assert.AreEqual(0, message.RepeatedForeignEnumCount); + Assert.AreEqual(0, message.RepeatedImportEnumCount); + + Assert.AreEqual(0, message.RepeatedStringPieceCount); + Assert.AreEqual(0, message.RepeatedCordCount); + + // HasBlah() should also be false for all default fields. + Assert.IsFalse(message.HasDefaultInt32); + Assert.IsFalse(message.HasDefaultInt64); + Assert.IsFalse(message.HasDefaultUint32); + Assert.IsFalse(message.HasDefaultUint64); + Assert.IsFalse(message.HasDefaultSint32); + Assert.IsFalse(message.HasDefaultSint64); + Assert.IsFalse(message.HasDefaultFixed32); + Assert.IsFalse(message.HasDefaultFixed64); + Assert.IsFalse(message.HasDefaultSfixed32); + Assert.IsFalse(message.HasDefaultSfixed64); + Assert.IsFalse(message.HasDefaultFloat); + Assert.IsFalse(message.HasDefaultDouble); + Assert.IsFalse(message.HasDefaultBool); + Assert.IsFalse(message.HasDefaultString); + Assert.IsFalse(message.HasDefaultBytes); + + Assert.IsFalse(message.HasDefaultNestedEnum); + Assert.IsFalse(message.HasDefaultForeignEnum); + Assert.IsFalse(message.HasDefaultImportEnum); + + Assert.IsFalse(message.HasDefaultStringPiece); + Assert.IsFalse(message.HasDefaultCord); + + // Fields with defaults have their default values (duh). + Assert.AreEqual(41, message.DefaultInt32); + Assert.AreEqual(42, message.DefaultInt64); + Assert.AreEqual(43, message.DefaultUint32); + Assert.AreEqual(44, message.DefaultUint64); + Assert.AreEqual(-45, message.DefaultSint32); + Assert.AreEqual(46, message.DefaultSint64); + Assert.AreEqual(47, message.DefaultFixed32); + Assert.AreEqual(48, message.DefaultFixed64); + Assert.AreEqual(49, message.DefaultSfixed32); + Assert.AreEqual(-50, message.DefaultSfixed64); + Assert.AreEqual(51.5, message.DefaultFloat, 0.0); + Assert.AreEqual(52e3, message.DefaultDouble, 0.0); + Assert.AreEqual(true, message.DefaultBool); + Assert.AreEqual("hello", message.DefaultString); + Assert.AreEqual(ToBytes("world"), message.DefaultBytes); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.DefaultNestedEnum); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.DefaultForeignEnum); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.DefaultImportEnum); + + Assert.AreEqual("abc", message.DefaultStringPiece); + Assert.AreEqual("123", message.DefaultCord); + } + + /// + /// Get a TestAllExtensions with all fields set as they would be by + /// SetAllExtensions(TestAllExtensions.Builder). + /// + internal static TestAllExtensions GetAllExtensionsSet() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + SetAllExtensions(builder); + return builder.Build(); + } + + /// + /// Sets every field of the specified builder to the values expected by + /// AssertAllExtensionsSet. + /// + internal static void SetAllExtensions(TestAllExtensions.Builder message) { + message.SetExtension(UnitTestProtoFile.OptionalInt32Extension, 101); + message.SetExtension(UnitTestProtoFile.OptionalInt64Extension, 102L); + message.SetExtension(UnitTestProtoFile.OptionalUint32Extension, 103U); + message.SetExtension(UnitTestProtoFile.OptionalUint64Extension, 104UL); + message.SetExtension(UnitTestProtoFile.OptionalSint32Extension, 105); + message.SetExtension(UnitTestProtoFile.OptionalSint64Extension, 106L); + message.SetExtension(UnitTestProtoFile.OptionalFixed32Extension, 107U); + message.SetExtension(UnitTestProtoFile.OptionalFixed64Extension, 108UL); + message.SetExtension(UnitTestProtoFile.OptionalSfixed32Extension, 109); + message.SetExtension(UnitTestProtoFile.OptionalSfixed64Extension, 110L); + message.SetExtension(UnitTestProtoFile.OptionalFloatExtension, 111F); + message.SetExtension(UnitTestProtoFile.OptionalDoubleExtension, 112D); + message.SetExtension(UnitTestProtoFile.OptionalBoolExtension, true); + message.SetExtension(UnitTestProtoFile.OptionalStringExtension, "115"); + message.SetExtension(UnitTestProtoFile.OptionalBytesExtension, ToBytes("116")); + + message.SetExtension(UnitTestProtoFile.OptionalGroupExtension, OptionalGroup_extension.CreateBuilder().SetA(117).Build()); + message.SetExtension(UnitTestProtoFile.OptionalNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(118).Build()); + message.SetExtension(UnitTestProtoFile.OptionalForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(119).Build()); + message.SetExtension(UnitTestProtoFile.OptionalImportMessageExtension, ImportMessage.CreateBuilder().SetD(120).Build()); + + message.SetExtension(UnitTestProtoFile.OptionalNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAZ); + message.SetExtension(UnitTestProtoFile.OptionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); + message.SetExtension(UnitTestProtoFile.OptionalImportEnumExtension, ImportEnum.IMPORT_BAZ); + + message.SetExtension(UnitTestProtoFile.OptionalStringPieceExtension, "124"); + message.SetExtension(UnitTestProtoFile.OptionalCordExtension, "125"); + + // ----------------------------------------------------------------- + + message.AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 201); + message.AddExtension(UnitTestProtoFile.RepeatedInt64Extension, 202L); + message.AddExtension(UnitTestProtoFile.RepeatedUint32Extension, 203U); + message.AddExtension(UnitTestProtoFile.RepeatedUint64Extension, 204UL); + message.AddExtension(UnitTestProtoFile.RepeatedSint32Extension, 205); + message.AddExtension(UnitTestProtoFile.RepeatedSint64Extension, 206L); + message.AddExtension(UnitTestProtoFile.RepeatedFixed32Extension, 207U); + message.AddExtension(UnitTestProtoFile.RepeatedFixed64Extension, 208UL); + message.AddExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 209); + message.AddExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 210L); + message.AddExtension(UnitTestProtoFile.RepeatedFloatExtension, 211F); + message.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 212D); + message.AddExtension(UnitTestProtoFile.RepeatedBoolExtension, true); + message.AddExtension(UnitTestProtoFile.RepeatedStringExtension, "215"); + message.AddExtension(UnitTestProtoFile.RepeatedBytesExtension, ToBytes("216")); + + message.AddExtension(UnitTestProtoFile.RepeatedGroupExtension, RepeatedGroup_extension.CreateBuilder().SetA(217).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(218).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(219).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedImportMessageExtension, ImportMessage.CreateBuilder().SetD(220).Build()); + + message.AddExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAR); + message.AddExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR); + message.AddExtension(UnitTestProtoFile.RepeatedImportEnumExtension, ImportEnum.IMPORT_BAR); + + message.AddExtension(UnitTestProtoFile.RepeatedStringPieceExtension, "224"); + message.AddExtension(UnitTestProtoFile.RepeatedCordExtension, "225"); + + // Add a second one of each field. + message.AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 301); + message.AddExtension(UnitTestProtoFile.RepeatedInt64Extension, 302L); + message.AddExtension(UnitTestProtoFile.RepeatedUint32Extension, 303U); + message.AddExtension(UnitTestProtoFile.RepeatedUint64Extension, 304UL); + message.AddExtension(UnitTestProtoFile.RepeatedSint32Extension, 305); + message.AddExtension(UnitTestProtoFile.RepeatedSint64Extension, 306L); + message.AddExtension(UnitTestProtoFile.RepeatedFixed32Extension, 307U); + message.AddExtension(UnitTestProtoFile.RepeatedFixed64Extension, 308UL); + message.AddExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 309); + message.AddExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 310L); + message.AddExtension(UnitTestProtoFile.RepeatedFloatExtension, 311F); + message.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 312D); + message.AddExtension(UnitTestProtoFile.RepeatedBoolExtension, false); + message.AddExtension(UnitTestProtoFile.RepeatedStringExtension, "315"); + message.AddExtension(UnitTestProtoFile.RepeatedBytesExtension, ToBytes("316")); + + message.AddExtension(UnitTestProtoFile.RepeatedGroupExtension, RepeatedGroup_extension.CreateBuilder().SetA(317).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(318).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(319).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedImportMessageExtension, ImportMessage.CreateBuilder().SetD(320).Build()); + + message.AddExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAZ); + message.AddExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); + message.AddExtension(UnitTestProtoFile.RepeatedImportEnumExtension, ImportEnum.IMPORT_BAZ); + + message.AddExtension(UnitTestProtoFile.RepeatedStringPieceExtension, "324"); + message.AddExtension(UnitTestProtoFile.RepeatedCordExtension, "325"); + + // ----------------------------------------------------------------- + + message.SetExtension(UnitTestProtoFile.DefaultInt32Extension, 401); + message.SetExtension(UnitTestProtoFile.DefaultInt64Extension, 402L); + message.SetExtension(UnitTestProtoFile.DefaultUint32Extension, 403U); + message.SetExtension(UnitTestProtoFile.DefaultUint64Extension, 404UL); + message.SetExtension(UnitTestProtoFile.DefaultSint32Extension, 405); + message.SetExtension(UnitTestProtoFile.DefaultSint64Extension, 406L); + message.SetExtension(UnitTestProtoFile.DefaultFixed32Extension, 407U); + message.SetExtension(UnitTestProtoFile.DefaultFixed64Extension, 408UL); + message.SetExtension(UnitTestProtoFile.DefaultSfixed32Extension, 409); + message.SetExtension(UnitTestProtoFile.DefaultSfixed64Extension, 410L); + message.SetExtension(UnitTestProtoFile.DefaultFloatExtension, 411F); + message.SetExtension(UnitTestProtoFile.DefaultDoubleExtension, 412D); + message.SetExtension(UnitTestProtoFile.DefaultBoolExtension, false); + message.SetExtension(UnitTestProtoFile.DefaultStringExtension, "415"); + message.SetExtension(UnitTestProtoFile.DefaultBytesExtension, ToBytes("416")); + + message.SetExtension(UnitTestProtoFile.DefaultNestedEnumExtension, TestAllTypes.Types.NestedEnum.FOO); + message.SetExtension(UnitTestProtoFile.DefaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO); + message.SetExtension(UnitTestProtoFile.DefaultImportEnumExtension, ImportEnum.IMPORT_FOO); + + message.SetExtension(UnitTestProtoFile.DefaultStringPieceExtension, "424"); + message.SetExtension(UnitTestProtoFile.DefaultCordExtension, "425"); + } + + internal static void ModifyRepeatedFields(TestAllTypes.Builder message) { + message.SetRepeatedInt32(1, 501); + message.SetRepeatedInt64(1, 502); + message.SetRepeatedUint32(1, 503); + message.SetRepeatedUint64(1, 504); + message.SetRepeatedSint32(1, 505); + message.SetRepeatedSint64(1, 506); + message.SetRepeatedFixed32(1, 507); + message.SetRepeatedFixed64(1, 508); + message.SetRepeatedSfixed32(1, 509); + message.SetRepeatedSfixed64(1, 510); + message.SetRepeatedFloat(1, 511); + message.SetRepeatedDouble(1, 512); + message.SetRepeatedBool(1, true); + message.SetRepeatedString(1, "515"); + message.SetRepeatedBytes(1, ToBytes("516")); + + message.SetRepeatedGroup(1, TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(517).Build()); + message.SetRepeatedNestedMessage(1, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(518).Build()); + message.SetRepeatedForeignMessage(1, ForeignMessage.CreateBuilder().SetC(519).Build()); + message.SetRepeatedImportMessage(1, ImportMessage.CreateBuilder().SetD(520).Build()); + + message.SetRepeatedNestedEnum(1, TestAllTypes.Types.NestedEnum.FOO); + message.SetRepeatedForeignEnum(1, ForeignEnum.FOREIGN_FOO); + message.SetRepeatedImportEnum(1, ImportEnum.IMPORT_FOO); + + message.SetRepeatedStringPiece(1, "524"); + message.SetRepeatedCord(1, "525"); + } + + internal static void AssertRepeatedFieldsModified(TestAllTypes message) { + // ModifyRepeatedFields only sets the second repeated element of each + // field. In addition to verifying this, we also verify that the first + // element and size were *not* modified. + Assert.AreEqual(2, message.RepeatedInt32Count); + Assert.AreEqual(2, message.RepeatedInt64Count); + Assert.AreEqual(2, message.RepeatedUint32Count); + Assert.AreEqual(2, message.RepeatedUint64Count); + Assert.AreEqual(2, message.RepeatedSint32Count); + Assert.AreEqual(2, message.RepeatedSint64Count); + Assert.AreEqual(2, message.RepeatedFixed32Count); + Assert.AreEqual(2, message.RepeatedFixed64Count); + Assert.AreEqual(2, message.RepeatedSfixed32Count); + Assert.AreEqual(2, message.RepeatedSfixed64Count); + Assert.AreEqual(2, message.RepeatedFloatCount); + Assert.AreEqual(2, message.RepeatedDoubleCount); + Assert.AreEqual(2, message.RepeatedBoolCount); + Assert.AreEqual(2, message.RepeatedStringCount); + Assert.AreEqual(2, message.RepeatedBytesCount); + + Assert.AreEqual(2, message.RepeatedGroupCount); + Assert.AreEqual(2, message.RepeatedNestedMessageCount); + Assert.AreEqual(2, message.RepeatedForeignMessageCount); + Assert.AreEqual(2, message.RepeatedImportMessageCount); + Assert.AreEqual(2, message.RepeatedNestedEnumCount); + Assert.AreEqual(2, message.RepeatedForeignEnumCount); + Assert.AreEqual(2, message.RepeatedImportEnumCount); + + Assert.AreEqual(2, message.RepeatedStringPieceCount); + Assert.AreEqual(2, message.RepeatedCordCount); + + Assert.AreEqual(201, message.GetRepeatedInt32(0)); + Assert.AreEqual(202L, message.GetRepeatedInt64(0)); + Assert.AreEqual(203U, message.GetRepeatedUint32(0)); + Assert.AreEqual(204UL, message.GetRepeatedUint64(0)); + Assert.AreEqual(205, message.GetRepeatedSint32(0)); + Assert.AreEqual(206L, message.GetRepeatedSint64(0)); + Assert.AreEqual(207U, message.GetRepeatedFixed32(0)); + Assert.AreEqual(208UL, message.GetRepeatedFixed64(0)); + Assert.AreEqual(209, message.GetRepeatedSfixed32(0)); + Assert.AreEqual(210L, message.GetRepeatedSfixed64(0)); + Assert.AreEqual(211F, message.GetRepeatedFloat(0)); + Assert.AreEqual(212D, message.GetRepeatedDouble(0)); + Assert.AreEqual(true, message.GetRepeatedBool(0)); + Assert.AreEqual("215", message.GetRepeatedString(0)); + Assert.AreEqual(ToBytes("216"), message.GetRepeatedBytes(0)); + + Assert.AreEqual(217, message.GetRepeatedGroup(0).A); + Assert.AreEqual(218, message.GetRepeatedNestedMessage(0).Bb); + Assert.AreEqual(219, message.GetRepeatedForeignMessage(0).C); + Assert.AreEqual(220, message.GetRepeatedImportMessage(0).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum(0)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); + + Assert.AreEqual("224", message.GetRepeatedStringPiece(0)); + Assert.AreEqual("225", message.GetRepeatedCord(0)); + + // Actually verify the second (modified) elements now. + Assert.AreEqual(501, message.GetRepeatedInt32(1)); + Assert.AreEqual(502L, message.GetRepeatedInt64(1)); + Assert.AreEqual(503U, message.GetRepeatedUint32(1)); + Assert.AreEqual(504UL, message.GetRepeatedUint64(1)); + Assert.AreEqual(505, message.GetRepeatedSint32(1)); + Assert.AreEqual(506L, message.GetRepeatedSint64(1)); + Assert.AreEqual(507U, message.GetRepeatedFixed32(1)); + Assert.AreEqual(508UL, message.GetRepeatedFixed64(1)); + Assert.AreEqual(509, message.GetRepeatedSfixed32(1)); + Assert.AreEqual(510L, message.GetRepeatedSfixed64(1)); + Assert.AreEqual(511F, message.GetRepeatedFloat(1)); + Assert.AreEqual(512D, message.GetRepeatedDouble(1)); + Assert.AreEqual(true, message.GetRepeatedBool(1)); + Assert.AreEqual("515", message.GetRepeatedString(1)); + Assert.AreEqual(ToBytes("516"), message.GetRepeatedBytes(1)); + + Assert.AreEqual(517, message.GetRepeatedGroup(1).A); + Assert.AreEqual(518, message.GetRepeatedNestedMessage(1).Bb); + Assert.AreEqual(519, message.GetRepeatedForeignMessage(1).C); + Assert.AreEqual(520, message.GetRepeatedImportMessage(1).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetRepeatedNestedEnum(1)); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetRepeatedForeignEnum(1)); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetRepeatedImportEnum(1)); + + Assert.AreEqual("524", message.GetRepeatedStringPiece(1)); + Assert.AreEqual("525", message.GetRepeatedCord(1)); + } + + /// + /// Helper to assert that sequences are equal. + /// + internal static void AssertEqual(IEnumerable first, IEnumerable second) { + using (IEnumerator firstEnumerator = first.GetEnumerator()) { + foreach (T secondElement in second) { + Assert.IsTrue(firstEnumerator.MoveNext(), "First enumerator ran out of elements too early."); + Assert.AreEqual(firstEnumerator.Current, secondElement); + } + Assert.IsFalse(firstEnumerator.MoveNext(), "Second enumerator ran out of elements too early."); + } + } + + internal static void AssertEqualBytes(byte[] expected, byte[] actual) { + Assert.AreEqual(ByteString.CopyFrom(expected), ByteString.CopyFrom(actual)); + } + + internal static void AssertAllExtensionsSet(TestAllExtensions message) { + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalInt32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalInt64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalUint32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalUint64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSint32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSint64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFixed32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFixed64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSfixed32Extension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSfixed64Extension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFloatExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalDoubleExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalBoolExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalStringExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalBytesExtension )); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalGroupExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalNestedMessageExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalForeignMessageExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalImportMessageExtension )); + + Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalGroupExtension ).HasA); + Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension ).HasBb); + Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).HasC); + Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension ).HasD); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalNestedEnumExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalImportEnumExtension )); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalStringPieceExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalCordExtension)); + + Assert.AreEqual(101 , message.GetExtension(UnitTestProtoFile.OptionalInt32Extension )); + Assert.AreEqual(102L , message.GetExtension(UnitTestProtoFile.OptionalInt64Extension )); + Assert.AreEqual(103U , message.GetExtension(UnitTestProtoFile.OptionalUint32Extension )); + Assert.AreEqual(104UL , message.GetExtension(UnitTestProtoFile.OptionalUint64Extension )); + Assert.AreEqual(105 , message.GetExtension(UnitTestProtoFile.OptionalSint32Extension )); + Assert.AreEqual(106L , message.GetExtension(UnitTestProtoFile.OptionalSint64Extension )); + Assert.AreEqual(107U , message.GetExtension(UnitTestProtoFile.OptionalFixed32Extension )); + Assert.AreEqual(108UL , message.GetExtension(UnitTestProtoFile.OptionalFixed64Extension )); + Assert.AreEqual(109 , message.GetExtension(UnitTestProtoFile.OptionalSfixed32Extension)); + Assert.AreEqual(110L , message.GetExtension(UnitTestProtoFile.OptionalSfixed64Extension)); + Assert.AreEqual(111F , message.GetExtension(UnitTestProtoFile.OptionalFloatExtension )); + Assert.AreEqual(112D , message.GetExtension(UnitTestProtoFile.OptionalDoubleExtension )); + Assert.AreEqual(true , message.GetExtension(UnitTestProtoFile.OptionalBoolExtension )); + Assert.AreEqual("115", message.GetExtension(UnitTestProtoFile.OptionalStringExtension )); + Assert.AreEqual(ToBytes("116"), message.GetExtension(UnitTestProtoFile.OptionalBytesExtension)); + + Assert.AreEqual(117, message.GetExtension(UnitTestProtoFile.OptionalGroupExtension ).A); + Assert.AreEqual(118, message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension ).Bb); + Assert.AreEqual(119, message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).C); + Assert.AreEqual(120, message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension ).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); + Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetExtension(UnitTestProtoFile.OptionalImportEnumExtension)); + + Assert.AreEqual("124", message.GetExtension(UnitTestProtoFile.OptionalStringPieceExtension)); + Assert.AreEqual("125", message.GetExtension(UnitTestProtoFile.OptionalCordExtension)); + + // ----------------------------------------------------------------- + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension )); + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension )); + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); + + Assert.AreEqual(201 , message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension , 0)); + Assert.AreEqual(202L , message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension , 0)); + Assert.AreEqual(203U , message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension , 0)); + Assert.AreEqual(204UL , message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension , 0)); + Assert.AreEqual(205 , message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension , 0)); + Assert.AreEqual(206L , message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension , 0)); + Assert.AreEqual(207U , message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension , 0)); + Assert.AreEqual(208UL , message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension , 0)); + Assert.AreEqual(209 , message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 0)); + Assert.AreEqual(210L , message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 0)); + Assert.AreEqual(211F , message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension , 0)); + Assert.AreEqual(212D , message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension , 0)); + Assert.AreEqual(true , message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension , 0)); + Assert.AreEqual("215", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension , 0)); + Assert.AreEqual(ToBytes("216"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 0)); + + Assert.AreEqual(217, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension , 0).A); + Assert.AreEqual(218, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension , 0).Bb); + Assert.AreEqual(219, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 0).C); + Assert.AreEqual(220, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension , 0).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 0)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 0)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 0)); + + Assert.AreEqual("224", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 0)); + Assert.AreEqual("225", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 0)); + + Assert.AreEqual(301 , message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension , 1)); + Assert.AreEqual(302L , message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension , 1)); + Assert.AreEqual(303U , message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension , 1)); + Assert.AreEqual(304UL , message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension , 1)); + Assert.AreEqual(305 , message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension , 1)); + Assert.AreEqual(306L , message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension , 1)); + Assert.AreEqual(307U , message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension , 1)); + Assert.AreEqual(308UL , message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension , 1)); + Assert.AreEqual(309 , message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1)); + Assert.AreEqual(310L , message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1)); + Assert.AreEqual(311F , message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension , 1)); + Assert.AreEqual(312D , message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension , 1)); + Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension , 1)); + Assert.AreEqual("315", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension , 1)); + Assert.AreEqual(ToBytes("316"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1)); + + Assert.AreEqual(317, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension , 1).A); + Assert.AreEqual(318, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension , 1).Bb); + Assert.AreEqual(319, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1).C); + Assert.AreEqual(320, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension , 1).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1)); + Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1)); + + Assert.AreEqual("324", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1)); + Assert.AreEqual("325", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 1)); + + // ----------------------------------------------------------------- + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultInt32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultInt64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultUint32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultUint64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSint32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSint64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFixed32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFixed64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSfixed32Extension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSfixed64Extension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFloatExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultDoubleExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultBoolExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultStringExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultBytesExtension )); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultNestedEnumExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultImportEnumExtension )); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultStringPieceExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultCordExtension)); + + Assert.AreEqual(401 , message.GetExtension(UnitTestProtoFile.DefaultInt32Extension )); + Assert.AreEqual(402L , message.GetExtension(UnitTestProtoFile.DefaultInt64Extension )); + Assert.AreEqual(403U , message.GetExtension(UnitTestProtoFile.DefaultUint32Extension )); + Assert.AreEqual(404UL , message.GetExtension(UnitTestProtoFile.DefaultUint64Extension )); + Assert.AreEqual(405 , message.GetExtension(UnitTestProtoFile.DefaultSint32Extension )); + Assert.AreEqual(406L , message.GetExtension(UnitTestProtoFile.DefaultSint64Extension )); + Assert.AreEqual(407U , message.GetExtension(UnitTestProtoFile.DefaultFixed32Extension )); + Assert.AreEqual(408UL , message.GetExtension(UnitTestProtoFile.DefaultFixed64Extension )); + Assert.AreEqual(409 , message.GetExtension(UnitTestProtoFile.DefaultSfixed32Extension)); + Assert.AreEqual(410L , message.GetExtension(UnitTestProtoFile.DefaultSfixed64Extension)); + Assert.AreEqual(411F , message.GetExtension(UnitTestProtoFile.DefaultFloatExtension )); + Assert.AreEqual(412D , message.GetExtension(UnitTestProtoFile.DefaultDoubleExtension )); + Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.DefaultBoolExtension )); + Assert.AreEqual("415", message.GetExtension(UnitTestProtoFile.DefaultStringExtension )); + Assert.AreEqual(ToBytes("416"), message.GetExtension(UnitTestProtoFile.DefaultBytesExtension)); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.DefaultNestedEnumExtension )); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.DefaultImportEnumExtension)); + + Assert.AreEqual("424", message.GetExtension(UnitTestProtoFile.DefaultStringPieceExtension)); + Assert.AreEqual("425", message.GetExtension(UnitTestProtoFile.DefaultCordExtension)); + } + + /// + /// Modifies the repeated extensions of the given message to contain the values + /// expected by AssertRepeatedExtensionsModified. + /// + internal static void ModifyRepeatedExtensions(TestAllExtensions.Builder message) { + message.SetExtension(UnitTestProtoFile.RepeatedInt32Extension, 1, 501); + message.SetExtension(UnitTestProtoFile.RepeatedInt64Extension, 1, 502L); + message.SetExtension(UnitTestProtoFile.RepeatedUint32Extension, 1, 503U); + message.SetExtension(UnitTestProtoFile.RepeatedUint64Extension, 1, 504UL); + message.SetExtension(UnitTestProtoFile.RepeatedSint32Extension, 1, 505); + message.SetExtension(UnitTestProtoFile.RepeatedSint64Extension, 1, 506L); + message.SetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 1, 507U); + message.SetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 1, 508UL); + message.SetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1, 509); + message.SetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1, 510L); + message.SetExtension(UnitTestProtoFile.RepeatedFloatExtension, 1, 511F); + message.SetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1, 512D); + message.SetExtension(UnitTestProtoFile.RepeatedBoolExtension, 1, true); + message.SetExtension(UnitTestProtoFile.RepeatedStringExtension, 1, "515"); + message.SetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1, ToBytes("516")); + + message.SetExtension(UnitTestProtoFile.RepeatedGroupExtension, 1, RepeatedGroup_extension.CreateBuilder().SetA(517).Build()); + message.SetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 1, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(518).Build()); + message.SetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1, ForeignMessage.CreateBuilder().SetC(519).Build()); + message.SetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 1, ImportMessage.CreateBuilder().SetD(520).Build()); + + message.SetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1, TestAllTypes.Types.NestedEnum.FOO); + message.SetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FOO); + message.SetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1, ImportEnum.IMPORT_FOO); + + message.SetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1, "524"); + message.SetExtension(UnitTestProtoFile.RepeatedCordExtension, 1, "525"); + } + + /// + /// Asserts that all repeated extensions are set to the values assigned by + /// SetAllExtensions follwed by ModifyRepeatedExtensions. + /// + internal static void AssertRepeatedExtensionsModified(TestAllExtensions message) { + // ModifyRepeatedFields only sets the second repeated element of each + // field. In addition to verifying this, we also verify that the first + // element and size were *not* modified. + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension)); + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension)); + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); + + Assert.AreEqual(201, message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension, 0)); + Assert.AreEqual(202L, message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension, 0)); + Assert.AreEqual(203U, message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension, 0)); + Assert.AreEqual(204UL, message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension, 0)); + Assert.AreEqual(205, message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension, 0)); + Assert.AreEqual(206L, message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension, 0)); + Assert.AreEqual(207U, message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 0)); + Assert.AreEqual(208UL, message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 0)); + Assert.AreEqual(209, message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 0)); + Assert.AreEqual(210L, message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 0)); + Assert.AreEqual(211F, message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension, 0)); + Assert.AreEqual(212D, message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 0)); + Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension, 0)); + Assert.AreEqual("215", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension, 0)); + Assert.AreEqual(ToBytes("216"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 0)); + + Assert.AreEqual(217, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension, 0).A); + Assert.AreEqual(218, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 0).Bb); + Assert.AreEqual(219, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 0).C); + Assert.AreEqual(220, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 0).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 0)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 0)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 0)); + + Assert.AreEqual("224", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 0)); + Assert.AreEqual("225", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 0)); + + // Actually verify the second (modified) elements now. + Assert.AreEqual(501, message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension, 1)); + Assert.AreEqual(502L, message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension, 1)); + Assert.AreEqual(503U, message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension, 1)); + Assert.AreEqual(504UL, message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension, 1)); + Assert.AreEqual(505, message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension, 1)); + Assert.AreEqual(506L, message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension, 1)); + Assert.AreEqual(507U, message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 1)); + Assert.AreEqual(508UL, message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 1)); + Assert.AreEqual(509, message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1)); + Assert.AreEqual(510L, message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1)); + Assert.AreEqual(511F, message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension, 1)); + Assert.AreEqual(512D, message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1)); + Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension, 1)); + Assert.AreEqual("515", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension, 1)); + Assert.AreEqual(ToBytes("516"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1)); + + Assert.AreEqual(517, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension, 1).A); + Assert.AreEqual(518, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 1).Bb); + Assert.AreEqual(519, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1).C); + Assert.AreEqual(520, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 1).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1)); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1)); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1)); + + Assert.AreEqual("524", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1)); + Assert.AreEqual("525", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 1)); + } + + internal static void AssertExtensionsClear(TestAllExtensions message) { + // HasBlah() should initially be false for all optional fields. + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalInt32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalInt64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalUint32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalUint64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSint32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSint64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFixed32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFixed64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSfixed32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSfixed64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFloatExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalDoubleExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalBoolExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalStringExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalBytesExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalGroupExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalNestedMessageExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalForeignMessageExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalImportMessageExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalImportEnumExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalStringPieceExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalCordExtension)); + + // Optional fields without defaults are set to zero or something like it. + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalInt32Extension)); + Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalInt64Extension)); + Assert.AreEqual(0U, message.GetExtension(UnitTestProtoFile.OptionalUint32Extension)); + Assert.AreEqual(0UL, message.GetExtension(UnitTestProtoFile.OptionalUint64Extension)); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalSint32Extension)); + Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalSint64Extension)); + Assert.AreEqual(0U, message.GetExtension(UnitTestProtoFile.OptionalFixed32Extension)); + Assert.AreEqual(0UL, message.GetExtension(UnitTestProtoFile.OptionalFixed64Extension)); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalSfixed32Extension)); + Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalSfixed64Extension)); + Assert.AreEqual(0F, message.GetExtension(UnitTestProtoFile.OptionalFloatExtension)); + Assert.AreEqual(0D, message.GetExtension(UnitTestProtoFile.OptionalDoubleExtension)); + Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.OptionalBoolExtension)); + Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalStringExtension)); + Assert.AreEqual(ByteString.Empty, message.GetExtension(UnitTestProtoFile.OptionalBytesExtension)); + + // Embedded messages should also be clear. + Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalGroupExtension).HasA); + Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension).HasBb); + Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).HasC); + Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension).HasD); + + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalGroupExtension).A); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension).Bb); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).C); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension).D); + + // Enums without defaults are set to the first value in the enum. + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.OptionalImportEnumExtension)); + + Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalStringPieceExtension)); + Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalCordExtension)); + + // Repeated fields are empty. + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension)); + + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension)); + + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); + + // HasBlah() should also be false for all default fields. + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultInt32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultInt64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultUint32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultUint64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSint32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSint64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFixed32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFixed64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSfixed32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSfixed64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFloatExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultDoubleExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultBoolExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultStringExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultBytesExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultNestedEnumExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultImportEnumExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultStringPieceExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultCordExtension)); + + // Fields with defaults have their default values (duh). + Assert.AreEqual(41, message.GetExtension(UnitTestProtoFile.DefaultInt32Extension)); + Assert.AreEqual(42L, message.GetExtension(UnitTestProtoFile.DefaultInt64Extension)); + Assert.AreEqual(43U, message.GetExtension(UnitTestProtoFile.DefaultUint32Extension)); + Assert.AreEqual(44UL, message.GetExtension(UnitTestProtoFile.DefaultUint64Extension)); + Assert.AreEqual(-45, message.GetExtension(UnitTestProtoFile.DefaultSint32Extension)); + Assert.AreEqual(46L, message.GetExtension(UnitTestProtoFile.DefaultSint64Extension)); + Assert.AreEqual(47U, message.GetExtension(UnitTestProtoFile.DefaultFixed32Extension)); + Assert.AreEqual(48UL, message.GetExtension(UnitTestProtoFile.DefaultFixed64Extension)); + Assert.AreEqual(49, message.GetExtension(UnitTestProtoFile.DefaultSfixed32Extension)); + Assert.AreEqual(-50L, message.GetExtension(UnitTestProtoFile.DefaultSfixed64Extension)); + Assert.AreEqual(51.5F, message.GetExtension(UnitTestProtoFile.DefaultFloatExtension)); + Assert.AreEqual(52e3D, message.GetExtension(UnitTestProtoFile.DefaultDoubleExtension)); + Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.DefaultBoolExtension)); + Assert.AreEqual("hello", message.GetExtension(UnitTestProtoFile.DefaultStringExtension)); + Assert.AreEqual(ToBytes("world"), message.GetExtension(UnitTestProtoFile.DefaultBytesExtension)); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.DefaultNestedEnumExtension)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.DefaultImportEnumExtension)); + + Assert.AreEqual("abc", message.GetExtension(UnitTestProtoFile.DefaultStringPieceExtension)); + Assert.AreEqual("123", message.GetExtension(UnitTestProtoFile.DefaultCordExtension)); + } + + /// + /// Helper to construct a byte array from a bunch of bytes. + /// + internal static byte[] Bytes(params byte[] bytesAsInts) { + byte[] bytes = new byte[bytesAsInts.Length]; + for (int i = 0; i < bytesAsInts.Length; i++) { + bytes[i] = (byte)bytesAsInts[i]; + } + return bytes; + } + } +} diff --git a/src/ProtocolBuffers.Test/TextFormatTest.cs b/src/ProtocolBuffers.Test/TextFormatTest.cs new file mode 100644 index 00000000..8d30b96c --- /dev/null +++ b/src/ProtocolBuffers.Test/TextFormatTest.cs @@ -0,0 +1,487 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class TextFormatTest { + + private static readonly string AllFieldsSetText = TestUtil.ReadTextFromFile("text_format_unittest_data.txt"); + private static readonly string AllExtensionsSetText = TestUtil.ReadTextFromFile("text_format_unittest_extensions_data.txt"); + + /// + /// Note that this is slightly different to the Java - 123.0 becomes 123, and 1.23E17 becomes 1.23E+17. + /// Both of these differences can be parsed by the Java and the C++, and we can parse their output too. + /// + private const string ExoticText = + "repeated_int32: -1\n" + + "repeated_int32: -2147483648\n" + + "repeated_int64: -1\n" + + "repeated_int64: -9223372036854775808\n" + + "repeated_uint32: 4294967295\n" + + "repeated_uint32: 2147483648\n" + + "repeated_uint64: 18446744073709551615\n" + + "repeated_uint64: 9223372036854775808\n" + + "repeated_double: 123\n" + + "repeated_double: 123.5\n" + + "repeated_double: 0.125\n" + + "repeated_double: 1.23E+17\n" + + "repeated_double: 1.235E+22\n" + + "repeated_double: 1.235E-18\n" + + "repeated_double: 123.456789\n" + + "repeated_double: Infinity\n" + + "repeated_double: -Infinity\n" + + "repeated_double: NaN\n" + + "repeated_string: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"" + + "\\341\\210\\264\"\n" + + "repeated_bytes: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"\\376\"\n"; + + private const string MessageSetText = + "[protobuf_unittest.TestMessageSetExtension1] {\n" + + " i: 123\n" + + "}\n" + + "[protobuf_unittest.TestMessageSetExtension2] {\n" + + " str: \"foo\"\n" + + "}\n"; + + /// + /// Print TestAllTypes and compare with golden file. + /// + [Test] + public void PrintMessage() { + string text = TextFormat.PrintToString(TestUtil.GetAllSet()); + Assert.AreEqual(AllFieldsSetText.Replace("\r\n", "\n"), text.Replace("\r\n", "\n")); + } + + /// + /// Print TestAllExtensions and compare with golden file. + /// + [Test] + public void PrintExtensions() { + string text = TextFormat.PrintToString(TestUtil.GetAllExtensionsSet()); + + Assert.AreEqual(AllExtensionsSetText.Replace("\r\n", "\n"), text.Replace("\r\n", "\n")); + } + + /// + /// Test printing of unknown fields in a message. + /// + [Test] + public void PrintUnknownFields() { + TestEmptyMessage message = + TestEmptyMessage.CreateBuilder() + .SetUnknownFields( + UnknownFieldSet.CreateBuilder() + .AddField(5, + UnknownField.CreateBuilder() + .AddVarint(1) + .AddFixed32(2) + .AddFixed64(3) + .AddLengthDelimited(ByteString.CopyFromUtf8("4")) + .AddGroup( + UnknownFieldSet.CreateBuilder() + .AddField(10, + UnknownField.CreateBuilder() + .AddVarint(5) + .Build()) + .Build()) + .Build()) + .AddField(8, + UnknownField.CreateBuilder() + .AddVarint(1) + .AddVarint(2) + .AddVarint(3) + .Build()) + .AddField(15, + UnknownField.CreateBuilder() + .AddVarint(0xABCDEF1234567890L) + .AddFixed32(0xABCD1234) + .AddFixed64(0xABCDEF1234567890L) + .Build()) + .Build()) + .Build(); + + Assert.AreEqual( + "5: 1\n" + + "5: 0x00000002\n" + + "5: 0x0000000000000003\n" + + "5: \"4\"\n" + + "5 {\n" + + " 10: 5\n" + + "}\n" + + "8: 1\n" + + "8: 2\n" + + "8: 3\n" + + "15: 12379813812177893520\n" + + "15: 0xabcd1234\n" + + "15: 0xabcdef1234567890\n", + TextFormat.PrintToString(message)); + } + + /// + /// Helper to construct a ByteString from a string containing only 8-bit + /// characters. The characters are converted directly to bytes, *not* + /// encoded using UTF-8. + /// + private static ByteString Bytes(string str) { + return ByteString.CopyFrom(Encoding.GetEncoding(28591).GetBytes(str)); + } + + [Test] + public void PrintExotic() { + IMessage message = TestAllTypes.CreateBuilder() + // Signed vs. unsigned numbers. + .AddRepeatedInt32 (-1) + .AddRepeatedUint32(uint.MaxValue) + .AddRepeatedInt64 (-1) + .AddRepeatedUint64(ulong.MaxValue) + + .AddRepeatedInt32 (1 << 31) + .AddRepeatedUint32(1U << 31) + .AddRepeatedInt64 (1L << 63) + .AddRepeatedUint64(1UL << 63) + + // Floats of various precisions and exponents. + .AddRepeatedDouble(123) + .AddRepeatedDouble(123.5) + .AddRepeatedDouble(0.125) + .AddRepeatedDouble(123e15) + .AddRepeatedDouble(123.5e20) + .AddRepeatedDouble(123.5e-20) + .AddRepeatedDouble(123.456789) + .AddRepeatedDouble(Double.PositiveInfinity) + .AddRepeatedDouble(Double.NegativeInfinity) + .AddRepeatedDouble(Double.NaN) + + // Strings and bytes that needing escaping. + .AddRepeatedString("\0\u0001\u0007\b\f\n\r\t\v\\\'\"\u1234") + .AddRepeatedBytes(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\"\u00fe")) + .Build(); + + Assert.AreEqual(ExoticText, message.ToString()); + } + + [Test] + public void PrintMessageSet() { + TestMessageSet messageSet = + TestMessageSet.CreateBuilder() + .SetExtension( + TestMessageSetExtension1.MessageSetExtension, + TestMessageSetExtension1.CreateBuilder().SetI(123).Build()) + .SetExtension( + TestMessageSetExtension2.MessageSetExtension, + TestMessageSetExtension2.CreateBuilder().SetStr("foo").Build()) + .Build(); + + Assert.AreEqual(MessageSetText, messageSet.ToString()); + } + + // ================================================================= + + [Test] + public void Parse() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge(AllFieldsSetText, builder); + TestUtil.AssertAllFieldsSet(builder.Build()); + } + + [Test] + public void ParseReader() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge(new StringReader(AllFieldsSetText), builder); + TestUtil.AssertAllFieldsSet(builder.Build()); + } + + [Test] + public void ParseExtensions() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + TextFormat.Merge(AllExtensionsSetText, + TestUtil.CreateExtensionRegistry(), + builder); + TestUtil.AssertAllExtensionsSet(builder.Build()); + } + + [Test] + public void ParseCompatibility() { + string original = "repeated_float: inf\n" + + "repeated_float: -inf\n" + + "repeated_float: nan\n" + + "repeated_float: inff\n" + + "repeated_float: -inff\n" + + "repeated_float: nanf\n" + + "repeated_float: 1.0f\n" + + "repeated_float: infinityf\n" + + "repeated_float: -Infinityf\n" + + "repeated_double: infinity\n" + + "repeated_double: -infinity\n" + + "repeated_double: nan\n"; + string canonical = "repeated_float: Infinity\n" + + "repeated_float: -Infinity\n" + + "repeated_float: NaN\n" + + "repeated_float: Infinity\n" + + "repeated_float: -Infinity\n" + + "repeated_float: NaN\n" + + "repeated_float: 1\n" + // Java has 1.0; this is fine + "repeated_float: Infinity\n" + + "repeated_float: -Infinity\n" + + "repeated_double: Infinity\n" + + "repeated_double: -Infinity\n" + + "repeated_double: NaN\n"; + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge(original, builder); + Assert.AreEqual(canonical, builder.Build().ToString()); + } + + [Test] + public void ParseExotic() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge(ExoticText, builder); + + // Too lazy to check things individually. Don't try to debug this + // if testPrintExotic() is Assert.Failing. + Assert.AreEqual(ExoticText, builder.Build().ToString()); + } + + [Test] + public void ParseMessageSet() { + ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); + extensionRegistry.Add(TestMessageSetExtension1.MessageSetExtension); + extensionRegistry.Add(TestMessageSetExtension2.MessageSetExtension); + + TestMessageSet.Builder builder = TestMessageSet.CreateBuilder(); + TextFormat.Merge(MessageSetText, extensionRegistry, builder); + TestMessageSet messageSet = builder.Build(); + + Assert.IsTrue(messageSet.HasExtension(TestMessageSetExtension1.MessageSetExtension)); + Assert.AreEqual(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I); + Assert.IsTrue(messageSet.HasExtension(TestMessageSetExtension2.MessageSetExtension)); + Assert.AreEqual("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str); + } + + [Test] + public void ParseNumericEnum() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge("optional_nested_enum: 2", builder); + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, builder.OptionalNestedEnum); + } + + [Test] + public void ParseAngleBrackets() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge("OptionalGroup: < a: 1 >", builder); + Assert.IsTrue(builder.HasOptionalGroup); + Assert.AreEqual(1, builder.OptionalGroup.A); + } + + [Test] + public void ParseComment() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge( + "# this is a comment\n" + + "optional_int32: 1 # another comment\n" + + "optional_int64: 2\n" + + "# EOF comment", builder); + Assert.AreEqual(1, builder.OptionalInt32); + Assert.AreEqual(2, builder.OptionalInt64); + } + + + private static void AssertParseError(string error, string text) { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + try { + TextFormat.Merge(text, TestUtil.CreateExtensionRegistry(), builder); + Assert.Fail("Expected parse exception."); + } catch (FormatException e) { + Assert.AreEqual(error, e.Message); + } + } + + [Test] + public void ParseErrors() { + AssertParseError( + "1:16: Expected \":\".", + "optional_int32 123"); + AssertParseError( + "1:23: Expected identifier.", + "optional_nested_enum: ?"); + AssertParseError( + "1:18: Couldn't parse integer: Number must be positive: -1", + "optional_uint32: -1"); + AssertParseError( + "1:17: Couldn't parse integer: Number out of range for 32-bit signed " + + "integer: 82301481290849012385230157", + "optional_int32: 82301481290849012385230157"); + AssertParseError( + "1:16: Expected \"true\" or \"false\".", + "optional_bool: maybe"); + AssertParseError( + "1:18: Expected string.", + "optional_string: 123"); + AssertParseError( + "1:18: String missing ending quote.", + "optional_string: \"ueoauaoe"); + AssertParseError( + "1:18: String missing ending quote.", + "optional_string: \"ueoauaoe\n" + + "optional_int32: 123"); + AssertParseError( + "1:18: Invalid escape sequence: '\\z'", + "optional_string: \"\\z\""); + AssertParseError( + "1:18: String missing ending quote.", + "optional_string: \"ueoauaoe\n" + + "optional_int32: 123"); + AssertParseError( + "1:2: Extension \"nosuchext\" not found in the ExtensionRegistry.", + "[nosuchext]: 123"); + AssertParseError( + "1:20: Extension \"protobuf_unittest.optional_int32_extension\" does " + + "not extend message type \"protobuf_unittest.TestAllTypes\".", + "[protobuf_unittest.optional_int32_extension]: 123"); + AssertParseError( + "1:1: Message type \"protobuf_unittest.TestAllTypes\" has no field " + + "named \"nosuchfield\".", + "nosuchfield: 123"); + AssertParseError( + "1:21: Expected \">\".", + "OptionalGroup < a: 1"); + AssertParseError( + "1:23: Enum type \"protobuf_unittest.TestAllTypes.NestedEnum\" has no " + + "value named \"NO_SUCH_VALUE\".", + "optional_nested_enum: NO_SUCH_VALUE"); + AssertParseError( + "1:23: Enum type \"protobuf_unittest.TestAllTypes.NestedEnum\" has no " + + "value with number 123.", + "optional_nested_enum: 123"); + + // Delimiters must match. + AssertParseError( + "1:22: Expected identifier.", + "OptionalGroup < a: 1 }"); + AssertParseError( + "1:22: Expected identifier.", + "OptionalGroup { a: 1 >"); + } + + // ================================================================= + + private static ByteString Bytes(params byte[] bytes) { + return ByteString.CopyFrom(bytes); + } + + private delegate void FormattingAction(); + + private static void AssertFormatException(FormattingAction action) { + try { + action(); + Assert.Fail("Should have thrown an exception."); + } catch (FormatException) { + // success + } + } + + [Test] + public void Escape() { + // Escape sequences. + Assert.AreEqual("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"", + TextFormat.EscapeBytes(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\""))); + Assert.AreEqual("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"", + TextFormat.EscapeText("\0\u0001\u0007\b\f\n\r\t\v\\\'\"")); + Assert.AreEqual(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\""), + TextFormat.UnescapeBytes("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"")); + Assert.AreEqual("\0\u0001\u0007\b\f\n\r\t\v\\\'\"", + TextFormat.UnescapeText("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"")); + + // Unicode handling. + Assert.AreEqual("\\341\\210\\264", TextFormat.EscapeText("\u1234")); + Assert.AreEqual("\\341\\210\\264", TextFormat.EscapeBytes(Bytes(0xe1, 0x88, 0xb4))); + Assert.AreEqual("\u1234", TextFormat.UnescapeText("\\341\\210\\264")); + Assert.AreEqual(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\341\\210\\264")); + Assert.AreEqual("\u1234", TextFormat.UnescapeText("\\xe1\\x88\\xb4")); + Assert.AreEqual(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\xe1\\x88\\xb4")); + + // Errors. + AssertFormatException(() => TextFormat.UnescapeText("\\x")); + AssertFormatException(() => TextFormat.UnescapeText("\\z")); + AssertFormatException(() => TextFormat.UnescapeText("\\")); + } + + [Test] + public void ParseInteger() { + Assert.AreEqual( 0, TextFormat.ParseInt32( "0")); + Assert.AreEqual( 1, TextFormat.ParseInt32( "1")); + Assert.AreEqual( -1, TextFormat.ParseInt32( "-1")); + Assert.AreEqual( 12345, TextFormat.ParseInt32( "12345")); + Assert.AreEqual( -12345, TextFormat.ParseInt32( "-12345")); + Assert.AreEqual( 2147483647, TextFormat.ParseInt32( "2147483647")); + Assert.AreEqual(-2147483648, TextFormat.ParseInt32("-2147483648")); + + Assert.AreEqual( 0, TextFormat.ParseUInt32( "0")); + Assert.AreEqual( 1, TextFormat.ParseUInt32( "1")); + Assert.AreEqual( 12345, TextFormat.ParseUInt32( "12345")); + Assert.AreEqual( 2147483647, TextFormat.ParseUInt32("2147483647")); + Assert.AreEqual(2147483648U, TextFormat.ParseUInt32("2147483648")); + Assert.AreEqual(4294967295U, TextFormat.ParseUInt32("4294967295")); + + Assert.AreEqual( 0L, TextFormat.ParseInt64( "0")); + Assert.AreEqual( 1L, TextFormat.ParseInt64( "1")); + Assert.AreEqual( -1L, TextFormat.ParseInt64( "-1")); + Assert.AreEqual( 12345L, TextFormat.ParseInt64( "12345")); + Assert.AreEqual( -12345L, TextFormat.ParseInt64( "-12345")); + Assert.AreEqual( 2147483647L, TextFormat.ParseInt64( "2147483647")); + Assert.AreEqual(-2147483648L, TextFormat.ParseInt64("-2147483648")); + Assert.AreEqual( 4294967295L, TextFormat.ParseInt64( "4294967295")); + Assert.AreEqual( 4294967296L, TextFormat.ParseInt64( "4294967296")); + Assert.AreEqual(9223372036854775807L, TextFormat.ParseInt64("9223372036854775807")); + Assert.AreEqual(-9223372036854775808L, TextFormat.ParseInt64("-9223372036854775808")); + + Assert.AreEqual( 0L, TextFormat.ParseUInt64( "0")); + Assert.AreEqual( 1L, TextFormat.ParseUInt64( "1")); + Assert.AreEqual( 12345L, TextFormat.ParseUInt64( "12345")); + Assert.AreEqual( 2147483647L, TextFormat.ParseUInt64( "2147483647")); + Assert.AreEqual( 4294967295L, TextFormat.ParseUInt64( "4294967295")); + Assert.AreEqual( 4294967296L, TextFormat.ParseUInt64( "4294967296")); + Assert.AreEqual(9223372036854775807UL, TextFormat.ParseUInt64("9223372036854775807")); + Assert.AreEqual(9223372036854775808UL, TextFormat.ParseUInt64("9223372036854775808")); + Assert.AreEqual(18446744073709551615UL, TextFormat.ParseUInt64("18446744073709551615")); + + // Hex + Assert.AreEqual(0x1234abcd, TextFormat.ParseInt32("0x1234abcd")); + Assert.AreEqual(-0x1234abcd, TextFormat.ParseInt32("-0x1234abcd")); + Assert.AreEqual(0xffffffffffffffffUL, TextFormat.ParseUInt64("0xffffffffffffffff")); + Assert.AreEqual(0x7fffffffffffffffL, + TextFormat.ParseInt64("0x7fffffffffffffff")); + + // Octal + Assert.AreEqual(342391, TextFormat.ParseInt32("01234567")); + + // Out-of-range + AssertFormatException(() => TextFormat.ParseInt32("2147483648")); + AssertFormatException(() => TextFormat.ParseInt32("-2147483649")); + AssertFormatException(() => TextFormat.ParseUInt32("4294967296")); + AssertFormatException(() => TextFormat.ParseUInt32("-1")); + AssertFormatException(() => TextFormat.ParseInt64("9223372036854775808")); + AssertFormatException(() => TextFormat.ParseInt64("-9223372036854775809")); + AssertFormatException(() => TextFormat.ParseUInt64("18446744073709551616")); + AssertFormatException(() => TextFormat.ParseUInt64("-1")); + AssertFormatException(() => TextFormat.ParseInt32("abcd")); + } + } +} diff --git a/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs b/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs new file mode 100644 index 00000000..12ed4120 --- /dev/null +++ b/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs @@ -0,0 +1,314 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class UnknownFieldSetTest { + + private MessageDescriptor descriptor; + private TestAllTypes allFields; + private ByteString allFieldsData; + + /// + /// An empty message that has been parsed from allFieldsData. So, it has + /// unknown fields of every type. + /// + private TestEmptyMessage emptyMessage; + private UnknownFieldSet unknownFields; + + [SetUp] + public void SetUp() { + descriptor = TestAllTypes.Descriptor; + allFields = TestUtil.GetAllSet(); + allFieldsData = allFields.ToByteString(); + emptyMessage = TestEmptyMessage.ParseFrom(allFieldsData); + unknownFields = emptyMessage.UnknownFields; + } + + private UnknownField GetField(String name) { + FieldDescriptor field = descriptor.FindDescriptor(name); + Assert.IsNotNull(field); + return unknownFields.FieldDictionary[field.FieldNumber]; + } + + /// + /// Constructs a protocol buffer which contains fields with all the same + /// numbers as allFieldsData except that each field is some other wire + /// type. + /// + private ByteString GetBizarroData() { + UnknownFieldSet.Builder bizarroFields = UnknownFieldSet.CreateBuilder(); + + UnknownField varintField = UnknownField.CreateBuilder().AddVarint(1).Build(); + UnknownField fixed32Field = UnknownField.CreateBuilder().AddFixed32(1).Build(); + + foreach (KeyValuePair entry in unknownFields.FieldDictionary) { + if (entry.Value.VarintList.Count == 0) { + // Original field is not a varint, so use a varint. + bizarroFields.AddField(entry.Key, varintField); + } else { + // Original field *is* a varint, so use something else. + bizarroFields.AddField(entry.Key, fixed32Field); + } + } + + return bizarroFields.Build().ToByteString(); + } + + // ================================================================= + + [Test] + public void Varint() { + UnknownField field = GetField("optional_int32"); + Assert.AreEqual(1, field.VarintList.Count); + Assert.AreEqual(allFields.OptionalInt32, (long) field.VarintList[0]); + } + + [Test] + public void Fixed32() { + UnknownField field = GetField("optional_fixed32"); + Assert.AreEqual(1, field.Fixed32List.Count); + Assert.AreEqual(allFields.OptionalFixed32, (int) field.Fixed32List[0]); + } + + [Test] + public void Fixed64() { + UnknownField field = GetField("optional_fixed64"); + Assert.AreEqual(1, field.Fixed64List.Count); + Assert.AreEqual(allFields.OptionalFixed64, (long) field.Fixed64List[0]); + } + + [Test] + public void LengthDelimited() { + UnknownField field = GetField("optional_bytes"); + Assert.AreEqual(1, field.LengthDelimitedList.Count); + Assert.AreEqual(allFields.OptionalBytes, field.LengthDelimitedList[0]); + } + + [Test] + public void Group() { + FieldDescriptor nestedFieldDescriptor = + TestAllTypes.Types.OptionalGroup.Descriptor.FindDescriptor("a"); + Assert.IsNotNull(nestedFieldDescriptor); + + UnknownField field = GetField("optionalgroup"); + Assert.AreEqual(1, field.GroupList.Count); + + UnknownFieldSet group = field.GroupList[0]; + Assert.AreEqual(1, group.FieldDictionary.Count); + Assert.IsTrue(group.HasField(nestedFieldDescriptor.FieldNumber)); + + UnknownField nestedField = group[nestedFieldDescriptor.FieldNumber]; + Assert.AreEqual(1, nestedField.VarintList.Count); + Assert.AreEqual(allFields.OptionalGroup.A, (long) nestedField.VarintList[0]); + } + + [Test] + public void Serialize() { + // Check that serializing the UnknownFieldSet produces the original data again. + ByteString data = emptyMessage.ToByteString(); + Assert.AreEqual(allFieldsData, data); + } + + [Test] + public void CopyFrom() { + TestEmptyMessage message = + TestEmptyMessage.CreateBuilder().MergeFrom(emptyMessage).Build(); + + Assert.AreEqual(emptyMessage.ToString(), message.ToString()); + } + + [Test] + public void MergeFrom() { + TestEmptyMessage source = + TestEmptyMessage.CreateBuilder() + .SetUnknownFields( + UnknownFieldSet.CreateBuilder() + .AddField(2, + UnknownField.CreateBuilder() + .AddVarint(2).Build()) + .AddField(3, + UnknownField.CreateBuilder() + .AddVarint(4).Build()) + .Build()) + .Build(); + TestEmptyMessage destination = + TestEmptyMessage.CreateBuilder() + .SetUnknownFields( + UnknownFieldSet.CreateBuilder() + .AddField(1, + UnknownField.CreateBuilder() + .AddVarint(1).Build()) + .AddField(3, + UnknownField.CreateBuilder() + .AddVarint(3).Build()) + .Build()) + .MergeFrom(source) + .Build(); + + Assert.AreEqual( + "1: 1\n" + + "2: 2\n" + + "3: 3\n" + + "3: 4\n", + destination.ToString()); + } + + [Test] + public void Clear() { + UnknownFieldSet fields = + UnknownFieldSet.CreateBuilder().MergeFrom(unknownFields).Clear().Build(); + Assert.AreEqual(0, fields.FieldDictionary.Count); + } + + [Test] + public void ClearMessage() { + TestEmptyMessage message = + TestEmptyMessage.CreateBuilder().MergeFrom(emptyMessage).Clear().Build(); + Assert.AreEqual(0, message.SerializedSize); + } + + [Test] + public void ParseKnownAndUnknown() { + // Test mixing known and unknown fields when parsing. + + UnknownFieldSet fields = + UnknownFieldSet.CreateBuilder(unknownFields) + .AddField(123456, + UnknownField.CreateBuilder().AddVarint(654321).Build()) + .Build(); + + ByteString data = fields.ToByteString(); + TestAllTypes destination = TestAllTypes.ParseFrom(data); + + TestUtil.AssertAllFieldsSet(destination); + Assert.AreEqual(1, destination.UnknownFields.FieldDictionary.Count); + + UnknownField field = destination.UnknownFields[123456]; + Assert.AreEqual(1, field.VarintList.Count); + Assert.AreEqual(654321, (long) field.VarintList[0]); + } + + [Test] + public void WrongTypeTreatedAsUnknown() { + // Test that fields of the wrong wire type are treated like unknown fields + // when parsing. + + ByteString bizarroData = GetBizarroData(); + TestAllTypes allTypesMessage = TestAllTypes.ParseFrom(bizarroData); + TestEmptyMessage emptyMessage = TestEmptyMessage.ParseFrom(bizarroData); + + // All fields should have been interpreted as unknown, so the debug strings + // should be the same. + Assert.AreEqual(emptyMessage.ToString(), allTypesMessage.ToString()); + } + + [Test] + public void UnknownExtensions() { + // Make sure fields are properly parsed to the UnknownFieldSet even when + // they are declared as extension numbers. + + TestEmptyMessageWithExtensions message = + TestEmptyMessageWithExtensions.ParseFrom(allFieldsData); + + Assert.AreEqual(unknownFields.FieldDictionary.Count, + message.UnknownFields.FieldDictionary.Count); + Assert.AreEqual(allFieldsData, message.ToByteString()); + } + + [Test] + public void WrongExtensionTypeTreatedAsUnknown() { + // Test that fields of the wrong wire type are treated like unknown fields + // when parsing extensions. + + ByteString bizarroData = GetBizarroData(); + TestAllExtensions allExtensionsMessage = TestAllExtensions.ParseFrom(bizarroData); + TestEmptyMessage emptyMessage = TestEmptyMessage.ParseFrom(bizarroData); + + // All fields should have been interpreted as unknown, so the debug strings + // should be the same. + Assert.AreEqual(emptyMessage.ToString(), + allExtensionsMessage.ToString()); + } + + [Test] + public void ParseUnknownEnumValue() { + FieldDescriptor singularField = TestAllTypes.Descriptor.FindDescriptor("optional_nested_enum"); + FieldDescriptor repeatedField = TestAllTypes.Descriptor.FindDescriptor("repeated_nested_enum"); + Assert.IsNotNull(singularField); + Assert.IsNotNull(repeatedField); + + ByteString data = + UnknownFieldSet.CreateBuilder() + .AddField(singularField.FieldNumber, + UnknownField.CreateBuilder() + .AddVarint((int) TestAllTypes.Types.NestedEnum.BAR) + .AddVarint(5) // not valid + .Build()) + .AddField(repeatedField.FieldNumber, + UnknownField.CreateBuilder() + .AddVarint((int) TestAllTypes.Types.NestedEnum.FOO) + .AddVarint(4) // not valid + .AddVarint((int) TestAllTypes.Types.NestedEnum.BAZ) + .AddVarint(6) // not valid + .Build()) + .Build() + .ToByteString(); + + { + TestAllTypes message = TestAllTypes.ParseFrom(data); + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + message.OptionalNestedEnum); + TestUtil.AssertEqual(new [] {TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.BAZ}, + message.RepeatedNestedEnumList); + TestUtil.AssertEqual(new[] {5UL}, message.UnknownFields[singularField.FieldNumber].VarintList); + TestUtil.AssertEqual(new[] {4UL, 6UL}, message.UnknownFields[repeatedField.FieldNumber].VarintList); + } + + { + TestAllExtensions message = + TestAllExtensions.ParseFrom(data, TestUtil.CreateExtensionRegistry()); + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); + TestUtil.AssertEqual(new[] { TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.BAZ }, + message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension)); + TestUtil.AssertEqual(new[] { 5UL }, message.UnknownFields[singularField.FieldNumber].VarintList); + TestUtil.AssertEqual(new[] { 4UL, 6UL }, message.UnknownFields[repeatedField.FieldNumber].VarintList); + } + } + + [Test] + public void LargeVarint() { + ByteString data = + UnknownFieldSet.CreateBuilder() + .AddField(1, + UnknownField.CreateBuilder() + .AddVarint(0x7FFFFFFFFFFFFFFFL) + .Build()) + .Build() + .ToByteString(); + UnknownFieldSet parsed = UnknownFieldSet.ParseFrom(data); + UnknownField field = parsed[1]; + Assert.AreEqual(1, field.VarintList.Count); + Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, field.VarintList[0]); + } + } +} diff --git a/src/ProtocolBuffers.Test/WireFormatTest.cs b/src/ProtocolBuffers.Test/WireFormatTest.cs new file mode 100644 index 00000000..c5fc3e41 --- /dev/null +++ b/src/ProtocolBuffers.Test/WireFormatTest.cs @@ -0,0 +1,228 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Reflection; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class WireFormatTest { + + /// + /// Keeps the attributes on FieldType and the switch statement in WireFormat in sync. + /// + [Test] + public void FieldTypeToWireTypeMapping() { + foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public)) { + FieldType fieldType = (FieldType)field.GetValue(null); + FieldMappingAttribute mapping = (FieldMappingAttribute)field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0]; + Assert.AreEqual(mapping.WireType, WireFormat.GetWireType(fieldType)); + } + } + + [Test] + public void Serialization() { + TestAllTypes message = TestUtil.GetAllSet(); + + ByteString rawBytes = message.ToByteString(); + Assert.AreEqual(rawBytes.Length, message.SerializedSize); + + TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); + + TestUtil.AssertAllFieldsSet(message2); + } + + [Test] + public void SerializeExtensions() { + // TestAllTypes and TestAllExtensions should have compatible wire formats, + // so if we serealize a TestAllExtensions then parse it as TestAllTypes + // it should work. + + TestAllExtensions message = TestUtil.GetAllExtensionsSet(); + ByteString rawBytes = message.ToByteString(); + Assert.AreEqual(rawBytes.Length, message.SerializedSize); + + TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); + + TestUtil.AssertAllFieldsSet(message2); + } + + [Test] + public void ParseExtensions() { + // TestAllTypes and TestAllExtensions should have compatible wire formats, + // so if we serealize a TestAllTypes then parse it as TestAllExtensions + // it should work. + + TestAllTypes message = TestUtil.GetAllSet(); + ByteString rawBytes = message.ToByteString(); + + ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); + TestUtil.RegisterAllExtensions(registry); + registry = registry.AsReadOnly(); + + TestAllExtensions message2 = + TestAllExtensions.ParseFrom(rawBytes, registry); + + TestUtil.AssertAllExtensionsSet(message2); + } + + [Test] + public void ExtensionsSerializedSize() { + Assert.AreEqual(TestUtil.GetAllSet().SerializedSize, TestUtil.GetAllExtensionsSet().SerializedSize); + } + + private void AssertFieldsInOrder(ByteString data) { + CodedInputStream input = data.CreateCodedInput(); + uint previousTag = 0; + + while (true) { + uint tag = input.ReadTag(); + if (tag == 0) { + break; + } + + Assert.IsTrue(tag > previousTag); + previousTag = tag; + input.SkipField(tag); + } + } + + [Test] + public void InterleavedFieldsAndExtensions() { + // Tests that fields are written in order even when extension ranges + // are interleaved with field numbers. + ByteString data = + TestFieldOrderings.CreateBuilder() + .SetMyInt(1) + .SetMyString("foo") + .SetMyFloat(1.0F) + .SetExtension(UnitTestProtoFile.MyExtensionInt, 23) + .SetExtension(UnitTestProtoFile.MyExtensionString, "bar") + .Build().ToByteString(); + AssertFieldsInOrder(data); + + MessageDescriptor descriptor = TestFieldOrderings.Descriptor; + ByteString dynamic_data = + DynamicMessage.CreateBuilder(TestFieldOrderings.Descriptor) + .SetField(descriptor.FindDescriptor("my_int"), 1L) + .SetField(descriptor.FindDescriptor("my_string"), "foo") + .SetField(descriptor.FindDescriptor("my_float"), 1.0F) + .SetField(UnitTestProtoFile.MyExtensionInt.Descriptor, 23) + .SetField(UnitTestProtoFile.MyExtensionString.Descriptor, "bar") + .WeakBuild().ToByteString(); + AssertFieldsInOrder(dynamic_data); + } + + private const int UnknownTypeId = 1550055; + private static readonly int TypeId1 = TestMessageSetExtension1.Descriptor.Extensions[0].FieldNumber; + private static readonly int TypeId2 = TestMessageSetExtension2.Descriptor.Extensions[0].FieldNumber; + + [Test] + public void SerializeMessageSet() { + // Set up a TestMessageSet with two known messages and an unknown one. + TestMessageSet messageSet = + TestMessageSet.CreateBuilder() + .SetExtension( + TestMessageSetExtension1.MessageSetExtension, + TestMessageSetExtension1.CreateBuilder().SetI(123).Build()) + .SetExtension( + TestMessageSetExtension2.MessageSetExtension, + TestMessageSetExtension2.CreateBuilder().SetStr("foo").Build()) + .SetUnknownFields( + UnknownFieldSet.CreateBuilder() + .AddField(UnknownTypeId, + UnknownField.CreateBuilder() + .AddLengthDelimited(ByteString.CopyFromUtf8("bar")) + .Build()) + .Build()) + .Build(); + + ByteString data = messageSet.ToByteString(); + + // Parse back using RawMessageSet and check the contents. + RawMessageSet raw = RawMessageSet.ParseFrom(data); + + Assert.AreEqual(0, raw.UnknownFields.FieldDictionary.Count); + + Assert.AreEqual(3, raw.ItemCount); + Assert.AreEqual(TypeId1, raw.ItemList[0].TypeId); + Assert.AreEqual(TypeId2, raw.ItemList[1].TypeId); + Assert.AreEqual(UnknownTypeId, raw.ItemList[2].TypeId); + + TestMessageSetExtension1 message1 = TestMessageSetExtension1.ParseFrom(raw.GetItem(0).Message.ToByteArray()); + Assert.AreEqual(123, message1.I); + + TestMessageSetExtension2 message2 = TestMessageSetExtension2.ParseFrom(raw.GetItem(1).Message.ToByteArray()); + Assert.AreEqual("foo", message2.Str); + + Assert.AreEqual("bar", raw.GetItem(2).Message.ToStringUtf8()); + } + + [Test] + public void ParseMessageSet() { + ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); + extensionRegistry.Add(TestMessageSetExtension1.MessageSetExtension); + extensionRegistry.Add(TestMessageSetExtension2.MessageSetExtension); + + // Set up a RawMessageSet with two known messages and an unknown one. + RawMessageSet raw = + RawMessageSet.CreateBuilder() + .AddItem( + RawMessageSet.Types.Item.CreateBuilder() + .SetTypeId(TypeId1) + .SetMessage( + TestMessageSetExtension1.CreateBuilder() + .SetI(123) + .Build().ToByteString()) + .Build()) + .AddItem( + RawMessageSet.Types.Item.CreateBuilder() + .SetTypeId(TypeId2) + .SetMessage( + TestMessageSetExtension2.CreateBuilder() + .SetStr("foo") + .Build().ToByteString()) + .Build()) + .AddItem( + RawMessageSet.Types.Item.CreateBuilder() + .SetTypeId(UnknownTypeId) + .SetMessage(ByteString.CopyFromUtf8("bar")) + .Build()) + .Build(); + + ByteString data = raw.ToByteString(); + + // Parse as a TestMessageSet and check the contents. + TestMessageSet messageSet = + TestMessageSet.ParseFrom(data, extensionRegistry); + + Assert.AreEqual(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I); + Assert.AreEqual("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str); + + // Check for unknown field with type LENGTH_DELIMITED, + // number UNKNOWN_TYPE_ID, and contents "bar". + UnknownFieldSet unknownFields = messageSet.UnknownFields; + Assert.AreEqual(1, unknownFields.FieldDictionary.Count); + Assert.IsTrue(unknownFields.HasField(UnknownTypeId)); + + UnknownField field = unknownFields[UnknownTypeId]; + Assert.AreEqual(1, field.LengthDelimitedList.Count); + Assert.AreEqual("bar", field.LengthDelimitedList[0].ToStringUtf8()); + } + + } +} -- cgit v1.2.3