/// <summary>
/// Constructs an instance that will expect messages using the given
/// descriptor. Normally <paramref name="baseDescriptor"/> 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.
/// </summary>
private ReflectionTester(MessageDescriptor baseDescriptor,
ExtensionRegistry extensionRegistry)
{
this.baseDescriptor = baseDescriptor;
this.extensionRegistry = extensionRegistry;
this.file = baseDescriptor.File;
Assert.AreEqual(1, file.Dependencies.Count);
this.importFile = file.Dependencies[0];
MessageDescriptor testAllTypes;
if (baseDescriptor.Name == "TestAllTypes")
{
testAllTypes = baseDescriptor;
}
else
{
testAllTypes = file.FindTypeByName<MessageDescriptor>("TestAllTypes");
Assert.NotNull(testAllTypes);
}
if (extensionRegistry == null)
{
// Use testAllTypes, rather than baseDescriptor, to allow
// initialization using TestPackedTypes descriptors. These objects
// won't be used by the methods for packed fields.
this.optionalGroup =
testAllTypes.FindDescriptor<MessageDescriptor>("OptionalGroup");
this.repeatedGroup =
testAllTypes.FindDescriptor<MessageDescriptor>("RepeatedGroup");
}
else
{
this.optionalGroup =
file.FindTypeByName<MessageDescriptor>("OptionalGroup_extension");
this.repeatedGroup =
file.FindTypeByName<MessageDescriptor>("RepeatedGroup_extension");
}
this.nestedMessage = testAllTypes.FindDescriptor<MessageDescriptor>("NestedMessage");
this.foreignMessage = file.FindTypeByName<MessageDescriptor>("ForeignMessage");
this.importMessage = importFile.FindTypeByName<MessageDescriptor>("ImportMessage");
this.nestedEnum = testAllTypes.FindDescriptor<EnumDescriptor>("NestedEnum");
this.foreignEnum = file.FindTypeByName<EnumDescriptor>("ForeignEnum");
this.importEnum = importFile.FindTypeByName<EnumDescriptor>("ImportEnum");
Assert.NotNull(optionalGroup);
Assert.NotNull(repeatedGroup);
Assert.NotNull(nestedMessage);
Assert.NotNull(foreignMessage);
Assert.NotNull(importMessage);
Assert.NotNull(nestedEnum);
Assert.NotNull(foreignEnum);
Assert.NotNull(importEnum);
this.nestedB = nestedMessage.FindDescriptor<FieldDescriptor>("bb");
this.foreignC = foreignMessage.FindDescriptor<FieldDescriptor>("c");
this.importD = importMessage.FindDescriptor<FieldDescriptor>("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<FieldDescriptor>("a");
this.repeatedGroupA = repeatedGroup.FindDescriptor<FieldDescriptor>("a");
Assert.NotNull(groupA);
Assert.NotNull(repeatedGroupA);
Assert.NotNull(nestedB);
Assert.NotNull(foreignC);
Assert.NotNull(importD);
Assert.NotNull(nestedFoo);
Assert.NotNull(nestedBar);
Assert.NotNull(nestedBaz);
Assert.NotNull(foreignFoo);
Assert.NotNull(foreignBar);
Assert.NotNull(foreignBaz);
Assert.NotNull(importFoo);
Assert.NotNull(importBar);
Assert.NotNull(importBaz);
}
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(Unittest.MyExtensionInt, 23)
.SetExtension(Unittest.MyExtensionString, "bar")
.Build().ToByteString();
AssertFieldsInOrder(data);
MessageDescriptor descriptor = TestFieldOrderings.Descriptor;
ByteString dynamic_data =
DynamicMessage.CreateBuilder(TestFieldOrderings.Descriptor)
.SetField(descriptor.FindDescriptor <FieldDescriptor>("my_int"), 1L)
.SetField(descriptor.FindDescriptor <FieldDescriptor>("my_string"), "foo")
.SetField(descriptor.FindDescriptor <FieldDescriptor>("my_float"), 1.0F)
.SetField(Unittest.MyExtensionInt.Descriptor, 23)
.SetField(Unittest.MyExtensionString.Descriptor, "bar")
.WeakBuild().ToByteString();
AssertFieldsInOrder(dynamic_data);
}
public void FieldDescriptor()
{
MessageDescriptor messageType = TestAllTypes.Descriptor;
FieldDescriptor primitiveField = messageType.FindDescriptor <FieldDescriptor>("optional_int32");
FieldDescriptor enumField = messageType.FindDescriptor <FieldDescriptor>("optional_nested_enum");
FieldDescriptor messageField = messageType.FindDescriptor <FieldDescriptor>("optional_foreign_message");
FieldDescriptor cordField = messageType.FindDescriptor <FieldDescriptor>("optional_cord");
FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor;
FieldDescriptor nestedExtension = TestRequired.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);
}
public void RequiredDynamic()
{
MessageDescriptor descriptor = TestRequired.Descriptor;
DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor);
Assert.IsFalse(builder.IsInitialized);
builder[descriptor.FindDescriptor <FieldDescriptor>("a")] = 1;
Assert.IsFalse(builder.IsInitialized);
builder[descriptor.FindDescriptor <FieldDescriptor>("b")] = 1;
Assert.IsFalse(builder.IsInitialized);
builder[descriptor.FindDescriptor <FieldDescriptor>("c")] = 1;
Assert.IsTrue(builder.IsInitialized);
}
private UnknownField GetField(String name)
{
FieldDescriptor field = descriptor.FindDescriptor <FieldDescriptor>(name);
Assert.IsNotNull(field);
return(unknownFields.FieldDictionary[field.FieldNumber]);
}
public void RequiredDynamicForeign()
{
MessageDescriptor descriptor = TestRequiredForeign.Descriptor;
DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor);
Assert.IsTrue(builder.IsInitialized);
builder[descriptor.FindDescriptor <FieldDescriptor>("optional_message")] = TestRequiredUninitialized;
Assert.IsFalse(builder.IsInitialized);
builder[descriptor.FindDescriptor <FieldDescriptor>("optional_message")] = TestRequiredInitialized;
Assert.IsTrue(builder.IsInitialized);
builder.AddRepeatedField(descriptor.FindDescriptor <FieldDescriptor>("repeated_message"), TestRequiredUninitialized);
Assert.IsFalse(builder.IsInitialized);
builder.SetRepeatedField(descriptor.FindDescriptor <FieldDescriptor>("repeated_message"), 0, TestRequiredInitialized);
Assert.IsTrue(builder.IsInitialized);
}
public void FieldDescriptorDefault()
{
MessageDescriptor d = TestAllTypes.Descriptor;
Assert.IsFalse(d.FindDescriptor <FieldDescriptor>("optional_int32").HasDefaultValue);
Assert.AreEqual(0, d.FindDescriptor <FieldDescriptor>("optional_int32").DefaultValue);
Assert.IsTrue(d.FindDescriptor <FieldDescriptor>("default_int32").HasDefaultValue);
Assert.AreEqual(41, d.FindDescriptor <FieldDescriptor>("default_int32").DefaultValue);
d = TestExtremeDefaultValues.Descriptor;
Assert.AreEqual(ByteString.CopyFrom("\u0000\u0001\u0007\b\f\n\r\t\u000b\\\'\"\u00fe", Encoding.GetEncoding(28591)),
d.FindDescriptor <FieldDescriptor>("escaped_bytes").DefaultValue);
Assert.AreEqual(uint.MaxValue, d.FindDescriptor <FieldDescriptor>("large_uint32").DefaultValue);
Assert.AreEqual(ulong.MaxValue, d.FindDescriptor <FieldDescriptor>("large_uint64").DefaultValue);
}
public void FieldDescriptorDefault()
{
MessageDescriptor d = TestAllTypes.Descriptor;
Assert.IsFalse(d.FindDescriptor <FieldDescriptor>("optional_int32").HasDefaultValue);
Assert.AreEqual <object>(0, d.FindDescriptor <FieldDescriptor>("optional_int32").DefaultValue);
Assert.IsTrue(d.FindDescriptor <FieldDescriptor>("default_int32").HasDefaultValue);
Assert.AreEqual <object>(41, d.FindDescriptor <FieldDescriptor>("default_int32").DefaultValue);
d = TestExtremeDefaultValues.Descriptor;
Assert.AreEqual <object>(TestExtremeDefaultValues.DefaultInstance.EscapedBytes,
d.FindDescriptor <FieldDescriptor>("escaped_bytes").DefaultValue);
Assert.AreEqual <object>(uint.MaxValue, d.FindDescriptor <FieldDescriptor>("large_uint32").DefaultValue);
Assert.AreEqual <object>(ulong.MaxValue, d.FindDescriptor <FieldDescriptor>("large_uint64").DefaultValue);
}
public void MessageDescriptor()
{
MessageDescriptor messageType = TestAllTypes.Descriptor;
MessageDescriptor nestedType = TestAllTypes.Types.NestedMessage.Descriptor;
Assert.AreEqual("TestAllTypes", messageType.Name);
Assert.AreEqual("protobuf_unittest.TestAllTypes", messageType.FullName);
Assert.AreEqual(UnitTestProtoFile.Descriptor, messageType.File);
Assert.IsNull(messageType.ContainingType);
Assert.AreEqual(DescriptorProtos.MessageOptions.DefaultInstance, messageType.Options);
Assert.AreEqual("TestAllTypes", messageType.Proto.Name);
Assert.AreEqual("NestedMessage", nestedType.Name);
Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedMessage", nestedType.FullName);
Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File);
Assert.AreEqual(messageType, nestedType.ContainingType);
FieldDescriptor field = messageType.Fields[0];
Assert.AreEqual("optional_int32", field.Name);
Assert.AreEqual(field, messageType.FindDescriptor <FieldDescriptor>("optional_int32"));
Assert.IsNull(messageType.FindDescriptor <FieldDescriptor>("no_such_field"));
Assert.AreEqual(field, messageType.FindFieldByNumber(1));
Assert.IsNull(messageType.FindFieldByNumber(571283));
for (int i = 0; i < messageType.Fields.Count; i++)
{
Assert.AreEqual(i, messageType.Fields[i].Index);
}
Assert.AreEqual(nestedType, messageType.NestedTypes[0]);
Assert.AreEqual(nestedType, messageType.FindDescriptor <MessageDescriptor>("NestedMessage"));
Assert.IsNull(messageType.FindDescriptor <MessageDescriptor>("NoSuchType"));
for (int i = 0; i < messageType.NestedTypes.Count; i++)
{
Assert.AreEqual(i, messageType.NestedTypes[i].Index);
}
Assert.AreEqual(messageType.EnumTypes[0], messageType.FindDescriptor <EnumDescriptor>("NestedEnum"));
Assert.IsNull(messageType.FindDescriptor <EnumDescriptor>("NoSuchType"));
for (int i = 0; i < messageType.EnumTypes.Count; i++)
{
Assert.AreEqual(i, messageType.EnumTypes[i].Index);
}
}
/// <summary>
/// Parses a single field from the specified tokenizer and merges it into
/// the builder.
/// </summary>
private static void MergeField(TextTokenizer tokenizer, ExtensionRegistry extensionRegistry,
IBuilder builder)
{
FieldDescriptor field;
MessageDescriptor type = builder.DescriptorForType;
ExtensionInfo extension = null;
if (tokenizer.TryConsume("["))
{
// An extension.
StringBuilder name = new StringBuilder(tokenizer.ConsumeIdentifier());
while (tokenizer.TryConsume("."))
{
name.Append(".");
name.Append(tokenizer.ConsumeIdentifier());
}
extension = extensionRegistry.FindByName(type, name.ToString());
if (extension == null)
{
throw tokenizer.CreateFormatExceptionPreviousToken("Extension \"" + name +
"\" not found in the ExtensionRegistry.");
}
else if (extension.Descriptor.ContainingType != type)
{
throw tokenizer.CreateFormatExceptionPreviousToken("Extension \"" + name +
"\" does not extend message type \"" +
type.FullName + "\".");
}
tokenizer.Consume("]");
field = extension.Descriptor;
}
else
{
String name = tokenizer.ConsumeIdentifier();
field = type.FindDescriptor <FieldDescriptor>(name);
// Group names are expected to be capitalized as they appear in the
// .proto file, which actually matches their type names, not their field
// names.
if (field == null)
{
// Explicitly specify the invariant culture so that this code does not break when
// executing in Turkey.
#if PORTABLE_LIBRARY
String lowerName = name.ToLowerInvariant();
#else
String lowerName = name.ToLower(FrameworkPortability.InvariantCulture);
#endif
field = type.FindDescriptor <FieldDescriptor>(lowerName);
// If the case-insensitive match worked but the field is NOT a group,
// TODO(jonskeet): What? Java comment ends here!
if (field != null && field.FieldType != FieldType.Group)
{
field = null;
}
}
// Again, special-case group names as described above.
if (field != null && field.FieldType == FieldType.Group && field.MessageType.Name != name)
{
field = null;
}
if (field == null)
{
throw tokenizer.CreateFormatExceptionPreviousToken(
"Message type \"" + type.FullName + "\" has no field named \"" + name + "\".");
}
}
object value = null;
if (field.MappedType == MappedType.Message)
{
tokenizer.TryConsume(":"); // optional
String endToken;
if (tokenizer.TryConsume("<"))
{
endToken = ">";
}
else
{
tokenizer.Consume("{");
endToken = "}";
}
IBuilder subBuilder;
if (extension == null)
{
subBuilder = builder.CreateBuilderForField(field);
}
else
{
subBuilder = extension.DefaultInstance.WeakCreateBuilderForType() as IBuilder;
if (subBuilder == null)
{
throw new NotSupportedException("Lite messages are not supported.");
}
}
while (!tokenizer.TryConsume(endToken))
{
if (tokenizer.AtEnd)
{
throw tokenizer.CreateFormatException("Expected \"" + endToken + "\".");
}
MergeField(tokenizer, extensionRegistry, subBuilder);
}
value = subBuilder.WeakBuild();
}
else
{
tokenizer.Consume(":");
switch (field.FieldType)
{
case FieldType.Int32:
case FieldType.SInt32:
case FieldType.SFixed32:
value = tokenizer.ConsumeInt32();
break;
case FieldType.Int64:
case FieldType.SInt64:
case FieldType.SFixed64:
value = tokenizer.ConsumeInt64();
break;
case FieldType.UInt32:
case FieldType.Fixed32:
value = tokenizer.ConsumeUInt32();
break;
case FieldType.UInt64:
case FieldType.Fixed64:
value = tokenizer.ConsumeUInt64();
break;
case FieldType.Float:
value = tokenizer.ConsumeFloat();
break;
case FieldType.Double:
value = tokenizer.ConsumeDouble();
break;
case FieldType.Bool:
value = tokenizer.ConsumeBoolean();
break;
case FieldType.String:
value = tokenizer.ConsumeString();
break;
case FieldType.Bytes:
value = tokenizer.ConsumeByteString();
break;
case FieldType.Enum:
{
EnumDescriptor enumType = field.EnumType;
if (tokenizer.LookingAtInteger())
{
int number = tokenizer.ConsumeInt32();
value = enumType.FindValueByNumber(number);
if (value == null)
{
throw tokenizer.CreateFormatExceptionPreviousToken(
"Enum type \"" + enumType.FullName +
"\" has no value with number " + number + ".");
}
}
else
{
String id = tokenizer.ConsumeIdentifier();
value = enumType.FindValueByName(id);
if (value == null)
{
throw tokenizer.CreateFormatExceptionPreviousToken(
"Enum type \"" + enumType.FullName +
"\" has no value named \"" + id + "\".");
}
}
break;
}
case FieldType.Message:
case FieldType.Group:
throw new InvalidOperationException("Can't get here.");
}
}
if (field.IsRepeated)
{
builder.WeakAddRepeatedField(field, value);
}
else
{
builder.SetField(field, value);
}
}
