/// <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); }
private static object MungeEnum(FieldDescriptor fieldDescriptor, EnumValueDescriptor original) { // Find all the values which get encoded to the same size as the current value, and pick one at random int originalSize = CodedOutputStream.ComputeRawVarint32Size((uint) original.Number); List<EnumValueDescriptor> sameSizeValues = new List<EnumValueDescriptor>(); foreach (EnumValueDescriptor candidate in fieldDescriptor.EnumType.Values) { if (CodedOutputStream.ComputeRawVarint32Size((uint) candidate.Number) == originalSize) { sameSizeValues.Add(candidate); } } return sameSizeValues[rng.Next(sameSizeValues.Count)]; }
private void WriteSingleValue(StringBuilder builder, FieldDescriptor descriptor, object value) { switch (descriptor.FieldType) { case FieldType.Bool: builder.Append((bool)value ? "true" : "false"); break; case FieldType.Bytes: // Nothing in Base64 needs escaping builder.Append('"'); builder.Append(((ByteString)value).ToBase64()); builder.Append('"'); break; case FieldType.String: WriteString(builder, (string)value); break; case FieldType.Fixed32: case FieldType.UInt32: case FieldType.SInt32: case FieldType.Int32: case FieldType.SFixed32: { IFormattable formattable = (IFormattable)value; builder.Append(formattable.ToString("d", CultureInfo.InvariantCulture)); break; } case FieldType.Enum: EnumValueDescriptor enumValue = descriptor.EnumType.FindValueByNumber((int)value); // We will already have validated that this is a known value. WriteString(builder, enumValue.Name); break; case FieldType.Fixed64: case FieldType.UInt64: case FieldType.SFixed64: case FieldType.Int64: case FieldType.SInt64: { builder.Append('"'); IFormattable formattable = (IFormattable)value; builder.Append(formattable.ToString("d", CultureInfo.InvariantCulture)); builder.Append('"'); break; } case FieldType.Double: case FieldType.Float: string text = ((IFormattable)value).ToString("r", CultureInfo.InvariantCulture); if (text == "NaN" || text == "Infinity" || text == "-Infinity") { builder.Append('"'); builder.Append(text); builder.Append('"'); } else { builder.Append(text); } break; case FieldType.Message: case FieldType.Group: // Never expect to get this, but... if (descriptor.MessageType.IsWellKnownType) { WriteWellKnownTypeValue(builder, descriptor.MessageType, value, true); } else { WriteMessage(builder, (IMessage)value); } break; default: throw new ArgumentException("Invalid field type: " + descriptor.FieldType); } }
static void AppendFieldValue(StringBuilder result, int level, FieldType type, object value) { switch (type) { case FieldType.Bool: result.AppendLine((bool)value ? "true" : "false"); break; case FieldType.Bytes: AppendHexdump(result, level, ((ByteString)value).ToByteArray()); break; case FieldType.Double: result.AppendLine(((double)value).ToString("G")); break; case FieldType.Float: result.AppendLine(((float)value).ToString("G")); break; case FieldType.Int32: case FieldType.SFixed32: case FieldType.SInt32: result.AppendLine(value.ToString()); break; case FieldType.Int64: case FieldType.SFixed64: case FieldType.SInt64: result.AppendLine("0x" + ((long)value).ToString("X16") + "l"); break; case FieldType.Fixed32: case FieldType.UInt32: result.AppendLine("0x" + ((uint)value).ToString("X8") + "u"); break; case FieldType.Fixed64: case FieldType.UInt64: result.AppendLine("0x" + ((ulong)value).ToString("X16") + "ul"); break; case FieldType.Message: result.AppendLine(); AppendMessage(result, level, (IMessage)value); break; case FieldType.Enum: { EnumValueDescriptor e = (EnumValueDescriptor)value; result.AppendLine(e.Name); } break; case FieldType.String: result.AppendLine(value.ToString()); break; case FieldType.Group: default: throw new Exception("Unhandled FieldType"); } }
public static string CSharpName(this EnumValueDescriptor desc) => RemoveEnumPrefix(desc.EnumDescriptor.Name, desc.Name);