internal static extern int select(
[In] int ignoredParameter,
[In, Out] ref FileDescriptorSet readfds,
[In, Out] ref FileDescriptorSet writefds,
[In, Out] ref FileDescriptorSet exceptfds,
[In] IntPtr nullTimeout
);
public void DescriptorProtoVB()
{
var schemaPath = Path.Combine(Directory.GetCurrentDirectory(), SchemaPath);
var path = "descriptor.proto";
var set = new FileDescriptorSet();
set.AddImportPath(schemaPath);
set.Add(path, includeInOutput: true);
set.Process();
#pragma warning disable CS0618
var sourceFiles = VBCodeGenerator.Default.Generate(set).Select(x => x.Text).ToArray();
#pragma warning restore CS0618
Assert.Single(sourceFiles);
_output.WriteLine(sourceFiles[0]);
var vb = new VBCodeProvider(new Dictionary <string, string>
{
{ "CompilerVersion", "v3.5" }
});
var p = new CompilerParameters
{
GenerateInMemory = true
};
p.ReferencedAssemblies.Add(typeof(ProtoContractAttribute).Assembly.Location); // add protobuf-net reference
p.ReferencedAssemblies.Add("System.dll"); // for [DefaultValue]
p.ReferencedAssemblies.Add("System.Core.dll"); // for extension methods
var results = vb.CompileAssemblyFromSource(p, sourceFiles);
Assert.Empty(results.Errors);
}
public void LargeDefaultValueIsCorrect()
{
var schemaPath = Path.Combine(Directory.GetCurrentDirectory(), SchemaPath);
const string path = "bigIntegerDefaultValue.proto";
var set = new FileDescriptorSet();
set.AddImportPath(schemaPath);
set.Add(path, includeInOutput: true);
set.Process();
var langver = set.Files[0].Options.GetOptions()?.CSharpLanguageVersion;
Assert.Equal("3", langver);
var sourceFiles = CSharpCodeGenerator.Default.Generate(set).Select(x => x.Text).ToArray();
Assert.Single(sourceFiles);
_output.WriteLine(sourceFiles[0]);
var csharp = new CSharpCodeProvider(new Dictionary <string, string>
{
{ "CompilerVersion", "v3.5" }
});
var p = new CompilerParameters
{
GenerateInMemory = true
};
p.ReferencedAssemblies.Add(typeof(ProtoContractAttribute).Assembly.Location); // add protobuf-net reference
p.ReferencedAssemblies.Add("System.dll"); // for [DefaultValue]
p.ReferencedAssemblies.Add("System.Core.dll"); // for extension methods
CompilerResults results;
try
{
results = csharp.CompileAssemblyFromSource(p, sourceFiles);
Assert.Empty(results.Errors);
}
catch (PlatformNotSupportedException)
{
return;
}
var assembly = results.CompiledAssembly;
var messageType = assembly.GetType("TestMessage");
var properties = messageType.GetProperties();
Assert.Equal(2, properties.Length);
foreach (var property in properties)
{
var defaultValueAttribute = (DefaultValueAttribute)Attribute.GetCustomAttribute(property, typeof(DefaultValueAttribute));
Assert.NotNull(defaultValueAttribute);
Assert.Equal(18446744073709551615UL, defaultValueAttribute.Value);
}
}
public static IEnumerable <ResultFile> Generate(FileDescriptorSet descriptorSet, string package, IClock clock,
string grpcServiceConfigPath, IEnumerable <string> commonResourcesConfigPaths, bool generateMetadata)
{
var descriptors = descriptorSet.File;
var filesToGenerate = descriptors.Where(x => x.Package == package).Select(x => x.Name).ToList();
return(Generate(descriptors, filesToGenerate, clock, grpcServiceConfigPath, commonResourcesConfigPaths, generateMetadata));
}
public void TestProtoInput()
{
FileDescriptorSet files = new FileDescriptorSet();
Assert.Equal(0, files.file.Count);
InputFileLoader.Merge(files, @"ProtoGen\descriptor.proto", Console.Error);
Assert.Equal(1, files.file.Count);
}
public byte[] GetFileDescriptorSet()
{
var descriptor = Descriptors.Last();
var output = new FileDescriptorSet();
output.File.AddRange(GetSelfAndDependency(descriptor.File).Select(x => x.SerializedData));
return(output.ToByteArray());
}
private void Test()
{
using (var stream = File.OpenRead(@"C:\Users\Agando\Desktop\protoc-3.9.1-win64\bin\grpcserverschema"))
{
FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(stream);
Google.Protobuf.Collections.RepeatedField <FileDescriptorProto> descriptorsProto = descriptorSet.File;
}
}
private void GenCSLuaTable()
{
FileDescriptorSet lset = m_reader.GetExcludeLuaProtoFileSet();
using (var converter = new ProtoConverter(m_strOutputPath, ""))
{
converter.Convert(lset);
}
}
/// <summary>
/// Creates a new <see cref="ReflectionService"/> instance
/// </summary>
public ReflectionService(
FileDescriptorSet fileDescriptorSet)
{
_services = fileDescriptorSet.Files
.SelectMany(x => x.Services)
.Select(x => x.FullyQualifiedName.TrimStart('.'))
.ToList();
_symbolRegistry = SymbolRegistry.FromFiles(fileDescriptorSet);
}
public override IEnumerable <CodeFile> Generate(FileDescriptorSet set, NameNormalizer normalizer = null, Dictionary <string, string> options = null)
{
if (normalizer == null)
{
normalizer = NameNormalizer.Null;
}
return(base.Generate(set, normalizer, options));
}
internal static int Main(string[] args)
{
try
{
// Hack to make sure everything's initialized
DescriptorProtoFile.Descriptor.ToString();
GeneratorOptions options = new GeneratorOptions {
Arguments = args
};
IList <string> validationFailures;
if (!options.TryValidate(out validationFailures))
{
// We've already got the message-building logic in the exception...
InvalidOptionsException exception = new InvalidOptionsException(validationFailures);
Console.WriteLine(exception.Message);
return(1);
}
var request = new CodeGeneratorRequest.Builder();
foreach (string inputFile in options.InputFiles)
{
ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
CSharpOptions.RegisterAllExtensions(extensionRegistry);
using (Stream inputStream = File.OpenRead(inputFile))
{
var fileSet = FileDescriptorSet.ParseFrom(inputStream, extensionRegistry);
foreach (var fileProto in fileSet.FileList)
{
request.AddFileToGenerate(fileProto.Name);
request.AddProtoFile(fileProto);
}
}
}
Generator generator = Generator.CreateGenerator(options);
var response = new CodeGeneratorResponse.Builder();
generator.Generate(request.Build(), response);
if (response.HasError)
{
throw new Exception(response.Error);
}
foreach (var file in response.FileList)
{
File.WriteAllText(file.Name, file.Content);
}
return(0);
}
catch (Exception e)
{
Console.Error.WriteLine("Error: {0}", e.Message);
Console.Error.WriteLine();
Console.Error.WriteLine("Detailed exception information: {0}", e);
return(1);
}
}
public static FileDescriptorSet LoadFilesAsFileDescription(params string[] files)
{
FileDescriptorSet set = new FileDescriptorSet();
foreach (string inPath in files)
{
InputFileLoader.Merge(set, inPath, Console.Error);
}
return(set);
}
private IReadOnlyCollection <FileDescriptor> ReadCompiledProtobufModel2(string pathToCompileProtobufModel)
{
using (var stream = File.OpenRead(pathToCompileProtobufModel))
{
FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(stream);
var byteStrings = descriptorSet.File.Select(f => f.ToByteString()).ToList();
var descriptors = FileDescriptor.BuildFromByteStrings(byteStrings);
return(descriptors);
}
}
/// <summary>
/// Creates a symbol registry from the specified set of file descriptors.
/// </summary>
/// <param name="fileDescriptorSet">The set of files to include in the registry. Must not contain null values.</param>
/// <returns>A symbol registry for the given files.</returns>
public static SymbolRegistry FromFiles(FileDescriptorSet fileDescriptorSet)
{
GrpcPreconditions.CheckNotNull(fileDescriptorSet);
var builder = new Builder();
foreach (var file in fileDescriptorSet.Files)
{
builder.AddFile(file);
}
return(builder.Build());
}
public GenerateResult Generate(string schema = null, string tooling = null)
{
if (string.IsNullOrWhiteSpace(schema))
{
return(null);
}
var result = new GenerateResult();
try
{
using (var reader = new StringReader(schema))
{
var set = new FileDescriptorSet
{
ImportValidator = path => ValidateImport(path),
};
set.AddImportPath(Path.Combine(_host.WebRootPath, "protoc"));
set.Add("my.proto", true, reader);
set.Process();
var errors = set.GetErrors();
if (!ProtocTooling.IsDefined(tooling))
{
if (errors.Length > 0)
{
result.ParserExceptions = errors;
}
result.Files = CSharpCodeGenerator.Default.Generate(set).ToArray();
}
else
{
// we're going to offer protoc! hold me...
if (errors.Length != 0 && schema.Contains("import"))
{
// code output disabled because of import
}
else
{
result.Files = RunProtoc(_host, schema, tooling, out errors);
if (errors.Length > 0)
{
result.ParserExceptions = errors;
}
}
}
}
}
catch (Exception ex)
{
result.Exception = ex;
}
return(result);
}
public void SelfDependency()
{
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "First" } }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first } };
try {
Generator.ConvertDescriptors(set);
Assert.Fail("Expected exception");
} catch (DependencyResolutionException) {
// Expected
}
}
private IReadOnlyCollection <FileDescriptorProto> ReadCompiledProtobufModel(string pathToCompileProtobufModel)
{
using (var stream = File.OpenRead(pathToCompileProtobufModel))
{
FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(stream);
RepeatedField <FileDescriptorProto> descriptorsProto = descriptorSet.File;
var result = new FileDescriptorProto[descriptorsProto.Capacity];
descriptorsProto.CopyTo(result, 0);
return(result);
}
}
public void Convert(FileDescriptorSet lset)
{
if (m_isworking)
{
return;
}
m_isworking = true;
FilterClass(GotIt, lset);
m_isworking = false;
}
private static FileDescriptorSet GetSet(IEnumerable <DirectoryInfo> importPaths)
{
var set = new FileDescriptorSet();
foreach (var path in importPaths)
{
set.AddImportPath(path.FullName);
}
return(set);
}
public bool Register(Stream source)
{
lastError.Clear();
FileDescriptorSet desc = new FileDescriptorSet();
Serializer.Merge <FileDescriptorSet>(source, desc);
buildFileDescriptor(desc);
return(lastError.Count == 0);
}
public void SecondDependsOnFirst() {
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First" }.Build();
FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = {"First"} }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
IList<FileDescriptor> converted = Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
Assert.AreEqual(2, converted.Count);
Assert.AreEqual("First", converted[0].Name);
Assert.AreEqual(0, converted[0].Dependencies.Count);
Assert.AreEqual("Second", converted[1].Name);
Assert.AreEqual(1, converted[1].Dependencies.Count);
Assert.AreEqual(converted[0], converted[1].Dependencies[0]);
}
private void buildFileDescriptor(FileDescriptorSet desc)
{
if (desc == null)
{
throw new ArgumentNullException("FileDescriptorSet can not be null");
}
foreach (var fd in desc.file)
{
if (descriptors.FileDescriptors.ContainsKey(fd.name))
{
continue;
}
descriptors.FileDescriptors.Add(fd.name, fd);
foreach (var enum_desc in fd.enum_type)
{
string enum_key = fd.package.Length > 0? string.Format("{0}.{1}", fd.package, enum_desc.name): enum_desc.name;
if (descriptors.EnumDescriptors.ContainsKey(enum_key))
{
lastError.AddLast(string.Format("enum discriptor {0} already existed"));
}
else
{
descriptors.EnumDescriptors.Add(enum_key, enum_desc);
foreach (var enum_val in enum_desc.value)
{
string enum_val_key = string.Format("{0}.{1}", enum_key, enum_val.name);
descriptors.EnumValueDescriptors[enum_val_key] = enum_val;
}
}
}
foreach (var msg_desc in fd.message_type)
{
string key = fd.package.Length > 0 ? string.Format("{0}.{1}", fd.package, msg_desc.name): msg_desc.name;
if (descriptors.MsgDescriptors.ContainsKey(key))
{
lastError.AddLast(string.Format("message discriptor {0} already existed"));
}
else
{
DynamicMessage.MsgDiscriptor res = new DynamicMessage.MsgDiscriptor();
res.Package = fd.package;
res.Protocol = msg_desc;
res.FieldIdIndex = new Dictionary <int, FieldDescriptorProto>();
res.FieldNameIndex = new Dictionary <string, FieldDescriptorProto>();
descriptors.MsgDescriptors.Add(key, res);
}
}
}
}
public void TestBinaryInput()
{
// compile .proto to .bin
Process.Start("protoc", @"--descriptor_set_out=ProtoGen\descriptor.bin --include_imports ProtoGen\descriptor.proto").WaitForExit();
// process .bin
FileDescriptorSet files = new FileDescriptorSet();
Assert.Equal(0, files.file.Count);
InputFileLoader.Merge(files, @"ProtoGen\descriptor.bin", Console.Error);
Assert.Equal(1, files.file.Count);
}
public static void ParsePB(string FilePath, string outputFilePath)
{
var pbFile = FileDescriptorSet.ParseFrom(File.ReadAllBytes(FilePath));
var protoList = pbFile.FileList;
//指代特定proto
foreach (var proto in protoList)
{
ParseProto(proto, outputFilePath);
}
}
public void FirstDependsOnSecond()
{
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = {"Second"} }.Build();
FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second" }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
Assert.AreEqual(2, converted.Count);
Assert.AreEqual("First", converted[0].Name);
Assert.AreEqual(1, converted[0].Dependencies.Count);
Assert.AreEqual(converted[1], converted[0].Dependencies[0]);
Assert.AreEqual("Second", converted[1].Name);
Assert.AreEqual(0, converted[1].Dependencies.Count);
}
public void EmbeddedImportsWork()
{
var set = new FileDescriptorSet();
using (var file = File.OpenText("basic.proto"))
{
Assert.True(set.Add("basic.proto", true, file));
}
set.Process();
var err = set.GetErrors();
Assert.Empty(err);
}
public void Parsed_ShouldReturnParsedSchemaContents()
{
string contents = SchemaFixtureUtils.GetProtoBuf("ValidSchema");
var schema = new ProtoBufSchema(
Guid.NewGuid(),
new SchemaGroupAggregate.Schemas.Version(1),
contents);
FileDescriptorSet descriptor = schema.Parsed;
Assert.NotNull(descriptor);
Assert.Empty(descriptor.GetErrors());
}
internal static FileDescriptorSet Create(IEnumerable <Type> serviceTypes, BinderConfiguration?binderConfiguration = null)
{
var fileDescriptorSet = new FileDescriptorSet();
binderConfiguration ??= BinderConfiguration.Default;
foreach (var serviceType in serviceTypes)
{
Populate(fileDescriptorSet, serviceType, binderConfiguration);
}
fileDescriptorSet.Process();
return(fileDescriptorSet);
}
public IActionResult Generate([FromBody] GeneratorViewModel generatorViewModel)
{
using (var reader = new StringReader(generatorViewModel.ProtoContent))
{
var set = new FileDescriptorSet
{
ImportValidator = path => ValidateImport(path),
};
set.AddImportPath(Path.Combine(_host.WebRootPath, "protoc"));
set.Add("my.proto", true, reader);
set.Process();
var errors = set.GetErrors();
if (errors.Length != 0)
{
//code parsing is supposed to happening client side, so we don't send error here
return(BadRequest());
}
if (generatorViewModel.IsProtobugGen())
{
return(Ok(
generatorViewModel
.GetCodeGenerator()
.Generate(set, generatorViewModel.GetNameNormalizerForConvention(),
generatorViewModel.GetOptions())
.ToList()));
}
// we're going to offer protoc! hold me...
if (generatorViewModel.ProtoContent.Contains("import"))
{
// code output disabled because of import
return(BadRequest());
}
else
{
var files = RunProtoc(_host,
generatorViewModel.ProtoContent,
generatorViewModel.GetProtocTooling(),
out var stdout,
out var stderr,
out var exitCode);
if (exitCode != 0)
{
return(base.StatusCode(500, new { stderr, stdout, exitCode }));
}
return(Ok(files));
}
}
}
private IEnumerable <ResultFile> Run(IEnumerable <string> protoFilenames, string package,
string grpcServiceConfigPath, IEnumerable <string> commonResourcesConfigPaths, bool generateMetadata)
{
var clock = new FakeClock(new DateTime(2019, 1, 1));
var protoPaths = protoFilenames.Select(x => Path.Combine(Invoker.GeneratorTestsDir, x));
using (var desc = Invoker.TempFile())
{
Invoker.Protoc($"-o {desc} --experimental_allow_proto3_optional --include_imports --include_source_info " +
$"-I{Invoker.CommonProtosDir} -I{Invoker.ProtobufDir} -I{Invoker.GeneratorTestsDir} {string.Join(" ", protoPaths)}");
var descriptorBytes = File.ReadAllBytes(desc.Path);
FileDescriptorSet descriptorSet = FileDescriptorSet.Parser.ParseFrom(descriptorBytes);
return(CodeGenerator.Generate(descriptorSet, package, clock, grpcServiceConfigPath, commonResourcesConfigPaths, generateMetadata));
}
}
static bool IsValidBinary(string path)
{
try
{
using (FileStream stream = File.OpenRead(path))
{
FileDescriptorSet file = Serializer.Deserialize <FileDescriptorSet>(stream);
return(file != null);
}
}
catch
{
return(false);
}
}
public void BuildTypeHierarchyForServices()
{
var set = new FileDescriptorSet();
using (var file = File.OpenText("basic_service.proto"))
{
Assert.True(set.Add("basic_service.proto", true, file));
}
set.Process();
var err = set.GetErrors();
Assert.Empty(err);
Assert.Equal(".HelloWorld.HelloService", set.Files[0].Services[0].FullyQualifiedName);
Assert.Equal(".HelloWorld.HelloService.SayHello", set.Files[0].Services[0].Methods[0].FullyQualifiedName);
}
public void SelfDependency()
{
FileDescriptorProto first = new FileDescriptorProto.Builder {
Name = "First", DependencyList = { "First" }
}.Build();
FileDescriptorSet set = new FileDescriptorSet {
FileList = { first }
};
try {
Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
Assert.Fail("Expected exception");
} catch (DependencyResolutionException) {
// Expected
}
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FileDescriptorSet Deserialize(Stream stream)
{
FileDescriptorSet instance = new FileDescriptorSet();
Deserialize(stream, instance);
return instance;
}
/// <summary>Helper: Serialize into a MemoryStream and return its byte array</summary>
public static byte[] SerializeToBytes(FileDescriptorSet instance)
{
using (var ms = new MemoryStream())
{
Serialize(ms, instance);
return ms.ToArray();
}
}
/// <summary>Helper: Serialize with a varint length prefix</summary>
public static void SerializeLengthDelimited(Stream stream, FileDescriptorSet instance)
{
var data = SerializeToBytes(instance);
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, (uint)data.Length);
stream.Write(data, 0, data.Length);
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, FileDescriptorSet instance)
{
if (instance.File != null)
{
foreach (var i1 in instance.File)
{
// Key for field: 1, LengthDelimited
stream.WriteByte(10);
using (var ms1 = new MemoryStream())
{
Google.protobuf.FileDescriptorProto.Serialize(ms1, i1);
// Length delimited byte array
uint ms1Length = (uint)ms1.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, ms1Length);
stream.Write(ms1.GetBuffer(), 0, (int)ms1Length);
}
}
}
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FileDescriptorSet DeserializeLengthDelimited(Stream stream)
{
FileDescriptorSet instance = new FileDescriptorSet();
DeserializeLengthDelimited(stream, instance);
return instance;
}
/// <summary>Helper: create a new instance to deserializing into</summary>
public static FileDescriptorSet DeserializeLength(Stream stream, int length)
{
FileDescriptorSet instance = new FileDescriptorSet();
DeserializeLength(stream, length, instance);
return instance;
}
/// <summary>Helper: put the buffer into a MemoryStream and create a new instance to deserializing into</summary>
public static FileDescriptorSet Deserialize(byte[] buffer)
{
FileDescriptorSet instance = new FileDescriptorSet();
using (var ms = new MemoryStream(buffer))
Deserialize(ms, instance);
return instance;
}
/// <summary>
/// Resolves any dependencies and converts FileDescriptorProtos into FileDescriptors.
/// The list returned is in the same order as the protos are listed in the descriptor set.
/// Note: this method is internal rather than private to allow testing.
/// </summary>
/// <exception cref="DependencyResolutionException">Not all dependencies could be resolved.</exception>
internal static IList<FileDescriptor> ConvertDescriptors(FileDescriptorSet descriptorProtos)
{
// Simple strategy: Keep going through the list of protos to convert, only doing ones where
// we've already converted all the dependencies, until we get to a stalemate
IList<FileDescriptorProto> fileList = descriptorProtos.FileList;
FileDescriptor[] converted = new FileDescriptor[fileList.Count];
Dictionary<string, FileDescriptor> convertedMap = new Dictionary<string, FileDescriptor>();
int totalConverted = 0;
bool madeProgress = true;
while (madeProgress && totalConverted < converted.Length) {
madeProgress = false;
for (int i = 0; i < converted.Length; i++) {
if (converted[i] != null) {
// Already done this one
continue;
}
FileDescriptorProto candidate = fileList[i];
FileDescriptor[] dependencies = new FileDescriptor[candidate.DependencyList.Count];
bool foundAllDependencies = true;
for (int j = 0; j < dependencies.Length; j++) {
if (!convertedMap.TryGetValue(candidate.DependencyList[j], out dependencies[j])) {
foundAllDependencies = false;
break;
}
}
if (!foundAllDependencies) {
continue;
}
madeProgress = true;
totalConverted++;
converted[i] = FileDescriptor.BuildFrom(candidate, dependencies);
convertedMap[candidate.Name] = converted[i];
}
}
if (!madeProgress) {
StringBuilder remaining = new StringBuilder();
for (int i = 0; i < converted.Length; i++) {
if (converted[i] == null) {
if (remaining.Length != 0) {
remaining.Append(", ");
}
FileDescriptorProto failure = fileList[i];
remaining.Append(failure.Name);
remaining.Append(":");
foreach (string dependency in failure.DependencyList) {
if (!convertedMap.ContainsKey(dependency)) {
remaining.Append(" ");
remaining.Append(dependency);
}
}
remaining.Append(";");
}
}
throw new DependencyResolutionException("Unable to resolve all dependencies: " + remaining);
}
return Lists.AsReadOnly(converted);
}
/// <summary>Serialize the instance into the stream</summary>
public static void Serialize(Stream stream, FileDescriptorSet instance)
{
var msField = global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Pop();
if (instance.File != null)
{
foreach (var i1 in instance.File)
{
// Key for field: 1, LengthDelimited
stream.WriteByte(10);
msField.SetLength(0);
Google.Protobuf.FileDescriptorProto.Serialize(msField, i1);
// Length delimited byte array
uint length1 = (uint)msField.Length;
global::SilentOrbit.ProtocolBuffers.ProtocolParser.WriteUInt32(stream, length1);
msField.WriteTo(stream);
}
}
global::SilentOrbit.ProtocolBuffers.ProtocolParser.Stack.Push(msField);
}
public void CircularDependency() {
FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build();
FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = { "First" } }.Build();
FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
try {
Generator.ConvertDescriptors(CSharpFileOptions.DefaultInstance, set);
Assert.Fail("Expected exception");
} catch (DependencyResolutionException) {
// Expected
}
}
