diff options
Diffstat (limited to 'csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs')
| -rw-r--r-- | csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs | 532 |
1 files changed, 532 insertions, 0 deletions
diff --git a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs new file mode 100644 index 00000000..b04fb399 --- /dev/null +++ b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs @@ -0,0 +1,532 @@ +#region Copyright notice and license
+
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// http://github.com/jskeet/dotnet-protobufs/
+// Original C++/Java/Python code:
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using Google.ProtocolBuffers.Collections;
+using Google.ProtocolBuffers.TestProtos;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Google.ProtocolBuffers
+{
+ [TestClass]
+ public class GeneratedMessageTest
+ {
+ private ReflectionTester reflectionTester;
+ private ReflectionTester extensionsReflectionTester;
+
+ [TestInitialize]
+ public void SetUp()
+ {
+ reflectionTester = ReflectionTester.CreateTestAllTypesInstance();
+ extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance();
+ }
+
+ [TestMethod]
+ public void RepeatedAddPrimitiveBeforeBuild()
+ {
+ TestAllTypes message = new TestAllTypes.Builder {RepeatedInt32List = {1, 2, 3}}.Build();
+ TestUtil.AssertEqual(new int[] {1, 2, 3}, message.RepeatedInt32List);
+ }
+
+ [TestMethod]
+ public void AddPrimitiveFailsAfterBuild()
+ {
+ TestAllTypes.Builder builder = new TestAllTypes.Builder();
+ IList<int> list = builder.RepeatedInt32List;
+ list.Add(1); // Fine
+ builder.Build();
+
+ try
+ {
+ list.Add(2);
+ Assert.Fail("List should be frozen");
+ }
+ catch (NotSupportedException)
+ {
+ // Expected
+ }
+ }
+
+ [TestMethod]
+ 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);
+ }
+
+ [TestMethod]
+ public void AddMessageFailsAfterBuild()
+ {
+ TestAllTypes.Builder builder = new TestAllTypes.Builder();
+ IList<TestAllTypes.Types.NestedMessage> 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
+ }
+ }
+
+ [TestMethod]
+ public void DefaultInstance()
+ {
+ Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.DefaultInstance.DefaultInstanceForType);
+ Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().DefaultInstanceForType);
+ }
+
+ [TestMethod]
+ public void Accessors()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ TestUtil.SetAllFields(builder);
+ TestAllTypes message = builder.Build();
+ TestUtil.AssertAllFieldsSet(message);
+ }
+
+ [TestMethod]
+ public void SettersRejectNull()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ TestUtil.AssertArgumentNullException(() => builder.SetOptionalString(null));
+ TestUtil.AssertArgumentNullException(() => builder.SetOptionalBytes(null));
+ TestUtil.AssertArgumentNullException(
+ () => builder.SetOptionalNestedMessage((TestAllTypes.Types.NestedMessage) null));
+ TestUtil.AssertArgumentNullException(
+ () => builder.SetOptionalNestedMessage((TestAllTypes.Types.NestedMessage.Builder) null));
+ TestUtil.AssertArgumentNullException(() => builder.AddRepeatedString(null));
+ TestUtil.AssertArgumentNullException(() => builder.AddRepeatedBytes(null));
+ TestUtil.AssertArgumentNullException(
+ () => builder.AddRepeatedNestedMessage((TestAllTypes.Types.NestedMessage) null));
+ TestUtil.AssertArgumentNullException(
+ () => builder.AddRepeatedNestedMessage((TestAllTypes.Types.NestedMessage.Builder) null));
+ }
+
+ [TestMethod]
+ public void RepeatedSetters()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ TestUtil.SetAllFields(builder);
+ TestUtil.ModifyRepeatedFields(builder);
+ TestAllTypes message = builder.Build();
+ TestUtil.AssertRepeatedFieldsModified(message);
+ }
+
+ [TestMethod]
+ 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);
+ }
+
+ [TestMethod]
+ public void RepeatedAppendRejectsNull()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+
+ ForeignMessage foreignMessage = ForeignMessage.CreateBuilder().SetC(12).Build();
+ TestUtil.AssertArgumentNullException(
+ () => builder.AddRangeRepeatedForeignMessage(new[] {foreignMessage, null}));
+ TestUtil.AssertArgumentNullException(() => builder.AddRangeRepeatedForeignMessage(null));
+ TestUtil.AssertArgumentNullException(() => builder.AddRangeRepeatedForeignEnum(null));
+ TestUtil.AssertArgumentNullException(() => builder.AddRangeRepeatedString(new[] {"one", null}));
+ TestUtil.AssertArgumentNullException(
+ () => builder.AddRangeRepeatedBytes(new[] {TestUtil.ToBytes("one"), null}));
+ }
+
+ [TestMethod]
+ 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);
+ }
+
+ [TestMethod]
+ 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);
+ }
+
+ [TestMethod]
+ public void SettingRepeatedValuesUsingRangeInCollectionInitializer()
+ {
+ int[] values = {1, 2, 3};
+ TestAllTypes message = new TestAllTypes.Builder
+ {
+ RepeatedSint32List = {values}
+ }.Build();
+ Assert.IsTrue(Lists.Equals(values, message.RepeatedSint32List));
+ }
+
+ [TestMethod]
+ public void SettingRepeatedValuesUsingIndividualValuesInCollectionInitializer()
+ {
+ TestAllTypes message = new TestAllTypes.Builder
+ {
+ RepeatedSint32List = {6, 7}
+ }.Build();
+ Assert.IsTrue(Lists.Equals(new int[] {6, 7}, message.RepeatedSint32List));
+ }
+
+ [TestMethod]
+ public void Defaults()
+ {
+ TestUtil.AssertClear(TestAllTypes.DefaultInstance);
+ TestUtil.AssertClear(TestAllTypes.CreateBuilder().Build());
+
+ Assert.AreEqual("\u1234", TestExtremeDefaultValues.DefaultInstance.Utf8String);
+ }
+
+ [TestMethod]
+ public void ReflectionGetters()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ TestUtil.SetAllFields(builder);
+ TestAllTypes message = builder.Build();
+ reflectionTester.AssertAllFieldsSetViaReflection(message);
+ }
+
+ [TestMethod]
+ public void ReflectionSetters()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ reflectionTester.SetAllFieldsViaReflection(builder);
+ TestAllTypes message = builder.Build();
+ TestUtil.AssertAllFieldsSet(message);
+ }
+
+ [TestMethod]
+ public void ReflectionClear()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ reflectionTester.SetAllFieldsViaReflection(builder);
+ reflectionTester.ClearAllFieldsViaReflection(builder);
+ TestAllTypes message = builder.Build();
+ TestUtil.AssertClear(message);
+ }
+
+ [TestMethod]
+ public void ReflectionSettersRejectNull()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ reflectionTester.AssertReflectionSettersRejectNull(builder);
+ }
+
+ [TestMethod]
+ public void ReflectionRepeatedSetters()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ reflectionTester.SetAllFieldsViaReflection(builder);
+ reflectionTester.ModifyRepeatedFieldsViaReflection(builder);
+ TestAllTypes message = builder.Build();
+ TestUtil.AssertRepeatedFieldsModified(message);
+ }
+
+ [TestMethod]
+ public void TestReflectionRepeatedSettersRejectNull()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ reflectionTester.AssertReflectionRepeatedSettersRejectNull(builder);
+ }
+
+ [TestMethod]
+ public void ReflectionDefaults()
+ {
+ TestUtil.TestInMultipleCultures(() =>
+ {
+ reflectionTester.AssertClearViaReflection(
+ TestAllTypes.DefaultInstance);
+ reflectionTester.AssertClearViaReflection(
+ TestAllTypes.CreateBuilder().Build());
+ });
+ }
+
+ // =================================================================
+ // Extensions.
+
+ [TestMethod]
+ public void ExtensionAccessors()
+ {
+ TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
+ TestUtil.SetAllExtensions(builder);
+ TestAllExtensions message = builder.Build();
+ TestUtil.AssertAllExtensionsSet(message);
+ }
+
+ [TestMethod]
+ public void ExtensionRepeatedSetters()
+ {
+ TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
+ TestUtil.SetAllExtensions(builder);
+ TestUtil.ModifyRepeatedExtensions(builder);
+ TestAllExtensions message = builder.Build();
+ TestUtil.AssertRepeatedExtensionsModified(message);
+ }
+
+ [TestMethod]
+ public void ExtensionDefaults()
+ {
+ TestUtil.AssertExtensionsClear(TestAllExtensions.DefaultInstance);
+ TestUtil.AssertExtensionsClear(TestAllExtensions.CreateBuilder().Build());
+ }
+
+ [TestMethod]
+ public void ExtensionReflectionGetters()
+ {
+ TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
+ TestUtil.SetAllExtensions(builder);
+ TestAllExtensions message = builder.Build();
+ extensionsReflectionTester.AssertAllFieldsSetViaReflection(message);
+ }
+
+ [TestMethod]
+ public void ExtensionReflectionSetters()
+ {
+ TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
+ extensionsReflectionTester.SetAllFieldsViaReflection(builder);
+ TestAllExtensions message = builder.Build();
+ TestUtil.AssertAllExtensionsSet(message);
+ }
+
+ [TestMethod]
+ public void ExtensionReflectionSettersRejectNull()
+ {
+ TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
+ extensionsReflectionTester.AssertReflectionSettersRejectNull(builder);
+ }
+
+ [TestMethod]
+ public void ExtensionReflectionRepeatedSetters()
+ {
+ TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
+ extensionsReflectionTester.SetAllFieldsViaReflection(builder);
+ extensionsReflectionTester.ModifyRepeatedFieldsViaReflection(builder);
+ TestAllExtensions message = builder.Build();
+ TestUtil.AssertRepeatedExtensionsModified(message);
+ }
+
+ [TestMethod]
+ public void ExtensionReflectionRepeatedSettersRejectNull()
+ {
+ TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder();
+ extensionsReflectionTester.AssertReflectionRepeatedSettersRejectNull(builder);
+ }
+
+ [TestMethod]
+ public void ExtensionReflectionDefaults()
+ {
+ TestUtil.TestInMultipleCultures(() =>
+ {
+ extensionsReflectionTester.AssertClearViaReflection(
+ TestAllExtensions.DefaultInstance);
+ extensionsReflectionTester.AssertClearViaReflection(
+ TestAllExtensions.CreateBuilder().Build());
+ });
+ }
+
+ [TestMethod]
+ 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));
+ }
+
+ [TestMethod]
+ public void ExtensionMergeFrom()
+ {
+ TestAllExtensions original = TestAllExtensions.CreateBuilder()
+ .SetExtension(UnitTestProtoFile.OptionalInt32Extension, 1).Build();
+ TestAllExtensions merged =
+ TestAllExtensions.CreateBuilder().MergeFrom(original).Build();
+ Assert.IsTrue((merged.HasExtension(UnitTestProtoFile.OptionalInt32Extension)));
+ Assert.AreEqual(1, (int) merged.GetExtension(UnitTestProtoFile.OptionalInt32Extension));
+ }
+
+ /* Removed multiple files option for the moment
+ [TestMethod]
+ 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<FieldDescriptor>("foreign_enum");
+ Assert.AreEqual(MultiFileProto.Descriptor.FindTypeByName<EnumDescriptor>("EnumWithNoOuter")
+ .FindValueByNumber((int)EnumWithNoOuter.BAR), message[field]);
+
+ Assert.AreEqual(MultiFileProto.Descriptor, ServiceWithNoOuter.Descriptor.File);
+
+ Assert.IsFalse(TestAllExtensions.DefaultInstance.HasExtension(MultiFileProto.ExtensionWithOuter));
+ }*/
+
+ [TestMethod]
+ 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);
+ }
+
+ [TestMethod]
+ public void OptimizedForSizeMergeUsesAllFieldsFromTarget()
+ {
+ TestOptimizedForSize withFieldSet = new TestOptimizedForSize.Builder {I = 10}.Build();
+ TestOptimizedForSize.Builder builder = new TestOptimizedForSize.Builder();
+ builder.MergeFrom(withFieldSet);
+ TestOptimizedForSize built = builder.Build();
+ Assert.AreEqual(10, built.I);
+ }
+
+ [TestMethod]
+ public void UninitializedExtensionInOptimizedForSizeMakesMessageUninitialized()
+ {
+ TestOptimizedForSize.Builder builder = new TestOptimizedForSize.Builder();
+ builder.SetExtension(TestOptimizedForSize.TestExtension2,
+ new TestRequiredOptimizedForSize.Builder().BuildPartial());
+ Assert.IsFalse(builder.IsInitialized);
+ Assert.IsFalse(builder.BuildPartial().IsInitialized);
+
+ builder = new TestOptimizedForSize.Builder();
+ builder.SetExtension(TestOptimizedForSize.TestExtension2,
+ new TestRequiredOptimizedForSize.Builder {X = 10}.BuildPartial());
+ Assert.IsTrue(builder.IsInitialized);
+ Assert.IsTrue(builder.BuildPartial().IsInitialized);
+ }
+
+ [TestMethod]
+ public void ToBuilder()
+ {
+ TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
+ TestUtil.SetAllFields(builder);
+ TestAllTypes message = builder.Build();
+ TestUtil.AssertAllFieldsSet(message.ToBuilder().Build());
+ }
+
+ [TestMethod]
+ public void FieldConstantValues()
+ {
+ Assert.AreEqual(TestAllTypes.Types.NestedMessage.BbFieldNumber, 1);
+ Assert.AreEqual(TestAllTypes.OptionalInt32FieldNumber, 1);
+ Assert.AreEqual(TestAllTypes.OptionalGroupFieldNumber, 16);
+ Assert.AreEqual(TestAllTypes.OptionalNestedMessageFieldNumber, 18);
+ Assert.AreEqual(TestAllTypes.OptionalNestedEnumFieldNumber, 21);
+ Assert.AreEqual(TestAllTypes.RepeatedInt32FieldNumber, 31);
+ Assert.AreEqual(TestAllTypes.RepeatedGroupFieldNumber, 46);
+ Assert.AreEqual(TestAllTypes.RepeatedNestedMessageFieldNumber, 48);
+ Assert.AreEqual(TestAllTypes.RepeatedNestedEnumFieldNumber, 51);
+ }
+
+ [TestMethod]
+ public void ExtensionConstantValues()
+ {
+ Assert.AreEqual(TestRequired.SingleFieldNumber, 1000);
+ Assert.AreEqual(TestRequired.MultiFieldNumber, 1001);
+ Assert.AreEqual(UnitTestProtoFile.OptionalInt32ExtensionFieldNumber, 1);
+ Assert.AreEqual(UnitTestProtoFile.OptionalGroupExtensionFieldNumber, 16);
+ Assert.AreEqual(UnitTestProtoFile.OptionalNestedMessageExtensionFieldNumber, 18);
+ Assert.AreEqual(UnitTestProtoFile.OptionalNestedEnumExtensionFieldNumber, 21);
+ Assert.AreEqual(UnitTestProtoFile.RepeatedInt32ExtensionFieldNumber, 31);
+ Assert.AreEqual(UnitTestProtoFile.RepeatedGroupExtensionFieldNumber, 46);
+ Assert.AreEqual(UnitTestProtoFile.RepeatedNestedMessageExtensionFieldNumber, 48);
+ Assert.AreEqual(UnitTestProtoFile.RepeatedNestedEnumExtensionFieldNumber, 51);
+ }
+
+ [TestMethod]
+ public void EmptyPackedValue()
+ {
+ TestPackedTypes empty = new TestPackedTypes.Builder().Build();
+ Assert.AreEqual(0, empty.SerializedSize);
+ }
+ }
+}
\ No newline at end of file |