public void AddPrimitiveFailsAfterBuild()
{
TestAllTypes.Builder builder = new TestAllTypes.Builder();
IList<int> list = builder.RepeatedInt32List;
list.Add(1); // Fine
builder.Build();
Assert.Throws<NotSupportedException>(() => list.Add(2));
}
public void TestToXmlParseFromXml()
{
TestAllTypes msg = new TestAllTypes.Builder().SetDefaultBool(true).Build();
string xml = Extensions.ToXml(msg);
Assert.AreEqual("<root><default_bool>true</default_bool></root>", xml);
TestAllTypes copy = Extensions.MergeFromXml(new TestAllTypes.Builder(), XmlReader.Create(new StringReader(xml))).Build();
Assert.IsTrue(copy.HasDefaultBool && copy.DefaultBool);
Assert.AreEqual(msg, copy);
}
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);
}
public void TestToJsonParseFromJsonReader()
{
TestAllTypes msg = new TestAllTypes.Builder().SetDefaultBool(true).Build();
string json = Extensions.ToJson(msg);
Assert.AreEqual("{\"default_bool\":true}", json);
TestAllTypes copy = Extensions.MergeFromJson(new TestAllTypes.Builder(), new StringReader(json)).Build();
Assert.IsTrue(copy.HasDefaultBool && copy.DefaultBool);
Assert.AreEqual(msg, copy);
}
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);
}
public void TestToXmlParseFromXmlWithRootName()
{
TestAllTypes msg = new TestAllTypes.Builder().SetDefaultBool(true).Build();
string xml = Extensions.ToXml(msg, "message");
Assert.AreEqual("<message><default_bool>true</default_bool></message>", xml);
TestAllTypes copy = Extensions.MergeFromXml(new TestAllTypes.Builder(), "message", XmlReader.Create(new StringReader(xml))).Build();
Assert.IsTrue(copy.HasDefaultBool && copy.DefaultBool);
Assert.AreEqual(msg, copy);
}
public void AddMessageFailsAfterBuild()
{
TestAllTypes.Builder builder = new TestAllTypes.Builder();
IList <TestAllTypes.Types.NestedMessage> list = builder.RepeatedNestedMessageList;
builder.Build();
Assert.Throws <NotSupportedException>(() => list.Add(new TestAllTypes.Types.NestedMessage.Builder {
Bb = 10
}.Build()));
}
public void TestMessageField()
{
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
Assert.IsFalse(builder.HasOptionalNestedMessage);
Assert.IsFalse(builder.Build().HasOptionalNestedMessage);
// Unlike non-message fields, if we set default value to message field, the field
// shoule be seem as present.
builder.SetOptionalNestedMessage(TestAllTypes.Types.NestedMessage.DefaultInstance);
Assert.IsTrue(builder.HasOptionalNestedMessage);
Assert.IsTrue(builder.Build().HasOptionalNestedMessage);
}
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);
}
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));
}
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 }));
}
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
}
}
public void BuildMultipleWithoutChange()
{
//Calling Build() or BuildPartial() does not require a copy of the message
TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
builder.SetDefaultBool(true);
TestAllTypes first = builder.BuildPartial();
//Still the same instance?
Assert.IsTrue(ReferenceEquals(first, builder.Build()));
//Still the same instance?
Assert.IsTrue(ReferenceEquals(first, builder.BuildPartial().ToBuilder().Build()));
}
public void ReflectionClearOneof()
{
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
reflectionTester.SetAllFieldsViaReflection(builder);
OneofDescriptor oneof = TestAllTypes.Descriptor.Oneofs[0];
FieldDescriptor field = TestAllTypes.Descriptor.FindFieldByName("oneof_bytes");
Assert.IsTrue(builder.HasOneof(oneof));
Assert.IsTrue(builder.HasField(field));
builder.ClearOneof(oneof);
Assert.IsFalse(builder.HasOneof(oneof));
Assert.IsFalse(builder.HasField(field));
}
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);
}
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
}
}
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);
}
}
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
}
}
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
}
}
public void TestSerializeAndParse()
{
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
builder.SetOptionalInt32(1234);
builder.SetOptionalString("hello");
builder.SetOptionalNestedMessage(TestAllTypes.Types.NestedMessage.DefaultInstance);
ByteString data = builder.Build().ToByteString();
TestAllTypes message = TestAllTypes.ParseFrom(data);
Assert.AreEqual(1234, message.OptionalInt32);
Assert.AreEqual("hello", message.OptionalString);
Assert.AreEqual(ByteString.Empty, message.OptionalBytes);
Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.OptionalNestedEnum);
Assert.IsTrue(message.HasOptionalNestedMessage);
Assert.AreEqual(0, message.OptionalNestedMessage.Bb);
}
public void BuildModifyAndRebuild()
{
TestAllTypes.Builder b1 = new TestAllTypes.Builder();
b1.SetDefaultInt32(1);
b1.AddRepeatedInt32(2);
b1.SetOptionalForeignMessage(ForeignMessage.DefaultInstance);
TestAllTypes m1 = b1.Build();
b1.SetDefaultInt32(5);
b1.AddRepeatedInt32(6);
b1.SetOptionalForeignMessage(b1.OptionalForeignMessage.ToBuilder().SetC(7));
TestAllTypes m2 = b1.Build();
Assert.AreEqual("{\"optional_foreign_message\":{},\"repeated_int32\":[2],\"default_int32\":1}", Extensions.ToJson(m1));
Assert.AreEqual("{\"optional_foreign_message\":{\"c\":7},\"repeated_int32\":[2,6],\"default_int32\":5}", Extensions.ToJson(m2));
}
public void BuildModifyAndRebuild()
{
TestAllTypes.Builder b1 = new TestAllTypes.Builder();
b1.SetDefaultInt32(1);
b1.AddRepeatedInt32(2);
b1.SetOptionalForeignMessage(ForeignMessage.DefaultInstance);
TestAllTypes m1 = b1.Build();
b1.SetDefaultInt32(5);
b1.AddRepeatedInt32(6);
b1.SetOptionalForeignMessage(b1.OptionalForeignMessage.ToBuilder().SetC(7));
TestAllTypes m2 = b1.Build();
Assert.AreEqual("{\"optional_foreign_message\":{},\"repeated_int32\":[2],\"default_int32\":1}", Extensions.ToJson(m1));
Assert.AreEqual("{\"optional_foreign_message\":{\"c\":7},\"repeated_int32\":[2,6],\"default_int32\":5}", Extensions.ToJson(m2));
}
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);
}
protected static TestAllTypes.Builder AddAllTypes(TestAllTypes.Builder builder)
{
return(builder.SetOptionalInt32(1001)
.SetOptionalInt64(1001)
.SetOptionalUint32(1001)
.SetOptionalUint64(1001)
.SetOptionalSint32(-1001)
.SetOptionalSint64(-1001)
.SetOptionalFixed32(1001)
.SetOptionalFixed64(1001)
.SetOptionalSfixed32(-1001)
.SetOptionalSfixed64(-1001)
.SetOptionalFloat(1001.1001f)
.SetOptionalDouble(1001.1001)
.SetOptionalBool(true)
.SetOptionalString("this is a string value")
.SetOptionalBytes(ByteString.CopyFromUtf8("this is an array of bytes"))
.SetOptionalGroup(new TestAllTypes.Types.OptionalGroup.Builder().SetA(1001))
.SetOptionalNestedMessage(new TestAllTypes.Types.NestedMessage.Builder().SetBb(1001))
.SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.FOO)
);
}
public void ParseLongString()
{
string longText =
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890" +
"123456789012345678901234567890123456789012345678901234567890";
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge("optional_string: \"" + longText + "\"", builder);
Assert.AreEqual(longText, builder.OptionalString);
}
public void TestFieldPresence()
{
// Optional non-message fields set to their default value are treated the same
// way as not set.
// Serialization will ignore such fields.
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
builder.SetOptionalInt32(0);
builder.SetOptionalString("");
builder.SetOptionalBytes(ByteString.Empty);
builder.SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.FOO);
TestAllTypes message = builder.Build();
Assert.AreEqual(0, message.SerializedSize);
// Test merge
TestAllTypes.Builder a = TestAllTypes.CreateBuilder();
a.SetOptionalInt32(1);
a.SetOptionalString("x");
a.SetOptionalBytes(ByteString.CopyFromUtf8("y"));
a.SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.BAR);
a.MergeFrom(message);
TestAllTypes messageA = a.Build();
Assert.AreEqual(1, messageA.OptionalInt32);
Assert.AreEqual("x", messageA.OptionalString);
Assert.AreEqual(ByteString.CopyFromUtf8("y"), messageA.OptionalBytes);
Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, messageA.OptionalNestedEnum);
// equals/hashCode should produce the same results
TestAllTypes empty = TestAllTypes.CreateBuilder().Build();
Assert.IsTrue(empty.Equals(message));
Assert.IsTrue(message.Equals(empty));
Assert.AreEqual(empty.GetHashCode(), message.GetHashCode());
}
public void SettingRepeatedValuesUsingIndividualValuesInCollectionInitializer()
{
TestAllTypes message = new TestAllTypes.Builder
{
RepeatedSint32List = {6, 7}
}.Build();
Assert.IsTrue(Lists.Equals(new int[] {6, 7}, message.RepeatedSint32List));
}
public void SettingRepeatedValuesUsingRangeInCollectionInitializer()
{
int[] values = {1, 2, 3};
TestAllTypes message = new TestAllTypes.Builder
{
RepeatedSint32List = {values}
}.Build();
Assert.IsTrue(Lists.Equals(values, message.RepeatedSint32List));
}
public void DoubleBuildError() {
TestAllTypes.Builder builder = new TestAllTypes.Builder();
builder.Build();
try {
builder.Build();
Assert.Fail("Should have thrown exception.");
} catch (InvalidOperationException) {
// Success.
}
}
public void DoesNotEnumerateTwiceForPrimitiveList()
{
TestAllTypes.Builder b = new TestAllTypes.Builder();
b.AddRangeRepeatedInt32(new OneTimeEnumerator <int>(1));
}
public void TestReflectionRepeatedSettersRejectNull()
{
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
reflectionTester.AssertReflectionRepeatedSettersRejectNull(builder);
}
public void TestUnmodifiedDefaultInstance()
{
//Simply calling ToBuilder().Build() no longer creates a copy of the message
TestAllTypes.Builder builder = TestAllTypes.DefaultInstance.ToBuilder();
Assert.IsTrue(ReferenceEquals(TestAllTypes.DefaultInstance, builder.Build()));
}
public void DoesNotAddNullToStringListByAddRange()
{
TestAllTypes.Builder b = new TestAllTypes.Builder();
Assert.Throws <ArgumentNullException>(() => b.AddRangeRepeatedString(new String[] { null }));
}
public void DoesNotEnumerateTwiceForEnumList()
{
TestAllTypes.Builder b = new TestAllTypes.Builder();
b.AddRangeRepeatedForeignEnum(new OneTimeEnumerator <ForeignEnum>(ForeignEnum.FOREIGN_BAR));
}
public void ParseNumericEnum()
{
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge("optional_nested_enum: 2", builder);
Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, builder.OptionalNestedEnum);
}
public void ParseReader()
{
TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
TextFormat.Merge(new StringReader(AllFieldsSetText), builder);
TestUtil.AssertAllFieldsSet(builder.Build());
}
public void RepeatedAddPrimitiveBeforeBuild()
{
TestAllTypes message = new TestAllTypes.Builder {RepeatedInt32List = {1, 2, 3}}.Build();
TestUtil.AssertEqual(new int[] {1, 2, 3}, message.RepeatedInt32List);
}
public void DoesNotAddNullToStringListBySet()
{
TestAllTypes.Builder b = new TestAllTypes.Builder();
b.AddRepeatedString("one");
Assert.Throws <ArgumentNullException>(() => b.SetRepeatedString(0, null));
}
public void DoesNotEnumerateTwiceForStringList()
{
TestAllTypes.Builder b = new TestAllTypes.Builder();
b.AddRangeRepeatedString(new OneTimeEnumerator <string>("test"));
}
public void AddMessageFailsAfterBuild()
{
TestAllTypes.Builder builder = new TestAllTypes.Builder();
IList<TestAllTypes.Types.NestedMessage> list = builder.RepeatedNestedMessageList;
builder.Build();
Assert.Throws<NotSupportedException>(() => list.Add(new TestAllTypes.Types.NestedMessage.Builder { Bb = 10 }.Build()));
}
public void DoesNotAddNullToMessageListBySet()
{
TestAllTypes.Builder b = new TestAllTypes.Builder();
b.AddRepeatedForeignMessage(ForeignMessage.DefaultInstance);
Assert.Throws <ArgumentNullException>(() => b.SetRepeatedForeignMessage(0, (ForeignMessage)null));
}
