public void TestProtoFileWithConflictingType() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using ( ProtoFile proto = new ProtoFile(test + ".proto", @" package nunit.simple; // Test a very simple message. message " + test + @" { optional string name = 1; } ")) { RunProtoc(0, proto.TempPath); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple." + test, true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple.Proto." + test, true, true); } }
public void TestMultipleProtoFiles() { Setup(); using (TempFile source1 = TempFile.Attach("MyMessage.cs")) using (ProtoFile proto1 = new ProtoFile("MyMessage.proto", @" package nunit.simple; // Test a very simple message. message MyMessage { optional string name = 1; }")) using (TempFile source2 = TempFile.Attach("MyMessageList.cs")) using (ProtoFile proto2 = new ProtoFile("MyMessageList.proto", @" package nunit.simple; import ""MyMessage.proto""; // Test a very simple message. message MyMessageList { repeated MyMessage messages = 1; }")) { RunProtoGen(0, proto1.TempPath, proto2.TempPath); Assembly a = RunCsc(0, source1.TempPath, source2.TempPath); //assert that the message type is in the expected namespace Type t1 = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage"); //assert that the message type is in the expected namespace Type t2 = a.GetType("nunit.simple.MyMessageList", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple.Proto.MyMessage", true, true); a.GetType("nunit.simple.Proto.MyMessageList", true, true); } }
public void TestProtoFileKeepingTheProtoBuffer() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile protobuf = TempFile.Attach(test + ".pb")) using (TempFile source = TempFile.Attach(test + ".cs")) using ( ProtoFile proto = new ProtoFile(test + ".proto", @" package nunit.simple; // Test a very simple message. message MyMessage { optional string name = 1; } ") ) { RunProtoGen(0, proto.TempPath, "--descriptor_set_out=" + protobuf.TempPath); Assert.IsTrue(File.Exists(protobuf.TempPath), "Missing: " + protobuf.TempPath); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileWithoutIgnoreGoogleProtobuf() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using ( ProtoFile proto = new ProtoFile(test + ".proto", @" import ""google/protobuf/csharp_options.proto""; option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace""; " + DefaultProto)) { string google = Path.Combine(TempPath, "google\\protobuf"); Directory.CreateDirectory(google); foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf"))) { File.Copy(file, Path.Combine(google, Path.GetFileName(file))); } Assert.AreEqual(0, Directory.GetFiles(TempPath, "*.cs").Length); //Without the option this fails due to being unable to resolve google/protobuf descriptors RunProtoc(0, proto.TempPath); } }
public void TestProtoFileDisablingClsComplianceFlags() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", @" package nunit.simple; // Test a very simple message. message MyMessage { optional uint32 name = 1; } ")) { //CS3021: Warning as Error: xx does not need a CLSCompliant attribute because the assembly does not have a CLSCompliant attribute RunProtoGen(0, proto.TempPath); RunCsc(1, source.TempPath, "/warnaserror+"); //Now we know it fails, make it pass by turning off cls_compliance generation RunProtoGen(0, proto.TempPath, "-cls_compliance:false"); Assembly a = RunCsc(0, source.TempPath, "/warnaserror+"); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileAndIgnoreGoogleProtobuf() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", @" import ""google/protobuf/csharp_options.proto""; option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace""; " + DefaultProto)) { string google = Path.Combine(TempPath, "google\\protobuf"); Directory.CreateDirectory(google); foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf"))) { File.Copy(file, Path.Combine(google, Path.GetFileName(file))); } Assert.AreEqual(0, Directory.GetFiles(TempPath, "*.cs").Length); RunProtoGen(0, proto.TempPath, "-ignore_google_protobuf:true"); Assert.AreEqual(1, Directory.GetFiles(TempPath, "*.cs").Length); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("MyNewNamespace.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("MyNewNamespace." + test, true, true); } }
public void TestProtoFileWithNewExtension() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".Generated.cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto)) { RunProtoGen(0, proto.TempPath, "-file_extension:.Generated.cs"); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileWithIgnoredUmbrellaNamespaceDueToNesting() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto)) { RunProtoGen(0, proto.TempPath, "-nest_classes:true", "-umbrella_namespace:MyUmbrella.Namespace"); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple." + test + "+MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileInDifferentDirectory() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto)) { Environment.CurrentDirectory = OriginalWorkingDirectory; RunProtoGen(0, proto.TempPath, "--proto_path=" + TempPath); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileWithNewOutputFolder() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(@"generated-code\" + test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto)) { RunProtoc(1, proto.TempPath, "-output_directory=generated-code"); Directory.CreateDirectory("generated-code"); RunProtoc(0, proto.TempPath, "-output_directory=generated-code"); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileWithExplicitEmptyUmbrellaNamespace() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", @" package nunit.simple; // Test a very simple message. message " + test + @" { optional string name = 1; } ")) { //Forces the umbrella class to not use a namespace even if a collision with a type is detected. RunProtoGen(0, proto.TempPath, "-umbrella_namespace:"); //error CS0441: 'nunit.simple.TestProtoFileWithExplicitEmptyUmbrellaNamespace': a class cannot be both static and sealed RunCsc(1, source.TempPath); } }
public void TestOneProtoFileWithBufferFile() { Setup(); using (TempFile source1 = TempFile.Attach("MyMessage.cs")) using (TempFile protobuf = TempFile.Attach("MyMessage.pb")) using ( ProtoFile proto1 = new ProtoFile("MyMessage.proto", @" package nunit.simple; // Test a very simple message. message MyMessage { optional string name = 1; }") ) using (TempFile source2 = TempFile.Attach("MyMessageList.cs")) using ( ProtoFile proto2 = new ProtoFile("MyMessageList.proto", @" package nunit.simple; import ""MyMessage.proto""; // Test a very simple message. message MyMessageList { repeated MyMessage messages = 1; }") ) { //build the proto buffer for MyMessage RunProtoGen(0, proto1.TempPath, "--descriptor_set_out=" + protobuf.TempPath); //build the MyMessageList proto-buffer and generate code by including MyMessage.pb RunProtoGen(0, proto2.TempPath, protobuf.TempPath); Assembly a = RunCsc(0, source1.TempPath, source2.TempPath); //assert that the message type is in the expected namespace Type t1 = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage"); //assert that the message type is in the expected namespace Type t2 = a.GetType("nunit.simple.MyMessageList", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple.Proto.MyMessage", true, true); a.GetType("nunit.simple.Proto.MyMessageList", true, true); } }
public void TestProtoFileWithIncludeImports() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using ( ProtoFile proto = new ProtoFile(test + ".proto", @" import ""google/protobuf/csharp_options.proto""; option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace""; package nunit.simple; // Test a very simple message. message MyMessage { optional string name = 1; } ") ) { string google = Path.Combine(TempPath, "google\\protobuf"); Directory.CreateDirectory(google); foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf"))) { File.Copy(file, Path.Combine(google, Path.GetFileName(file))); } Assert.AreEqual(0, Directory.GetFiles(TempPath, "*.cs").Length); //if you specify the protoc option --include_imports this should build three source files RunProtoc(0, proto.TempPath); Assert.AreEqual(1, Directory.GetFiles(TempPath, "*.cs").Length); //you can (and should) simply omit the inclusion of the extra source files in your project Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("MyNewNamespace.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("MyNewNamespace." + test, true, true); } }
public void TestProtoFileWithServiceInternal() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", @" import ""google/protobuf/csharp_options.proto""; option (google.protobuf.csharp_file_options).service_generator_type = GENERIC; package nunit.simple; // Test a very simple message. message MyMessage { optional string name = 1; } // test a very simple service. service TestService { rpc Execute (MyMessage) returns (MyMessage); }")) { CopyInGoogleProtoFiles(); RunProtoc(0, proto.TempPath, "-nest_classes=false", "-public_classes=false"); Assert.AreEqual(1, Directory.GetFiles(TempPath, "*.cs").Length); Assembly a = RunCsc(0, source.TempPath); //assert that the service type is in the expected namespace Type t1 = a.GetType("nunit.simple.TestService", true, true); Assert.IsTrue(typeof(IService).IsAssignableFrom(t1), "Expect an IService"); Assert.IsTrue(t1.IsAbstract, "Expect abstract class"); //assert that the Stub subclass type is in the expected namespace Type t2 = a.GetType("nunit.simple.TestService+Stub", true, true); Assert.IsTrue(t1.IsAssignableFrom(t2), "Expect a sub of TestService"); Assert.IsFalse(t2.IsAbstract, "Expect concrete class"); } }
public void TestOneProtoFileWithBufferFile() { Setup(); using (TempFile source1 = TempFile.Attach("MyMessage.cs")) using ( ProtoFile proto1 = new ProtoFile("MyMessage.proto", @" package nunit.simple; // Test a very simple message. message MyMessage { optional string name = 1; }") ) using (TempFile source2 = TempFile.Attach("MyMessageList.cs")) using ( ProtoFile proto2 = new ProtoFile("MyMessageList.proto", @" package nunit.simple; import ""MyMessage.proto""; // Test a very simple message. message MyMessageList { repeated MyMessage messages = 1; }") ) { //build the proto buffer for MyMessage RunProtoc(0, proto1.TempPath); //build the MyMessageList proto-buffer and generate code by including MyMessage.pb RunProtoc(0, proto2.TempPath); Assembly a = RunCsc(0, source1.TempPath, source2.TempPath); //assert that the message type is in the expected namespace Type t1 = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t1), "Expect an IMessage"); //assert that the message type is in the expected namespace Type t2 = a.GetType("nunit.simple.MyMessageList", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t2), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple.Proto.MyMessage", true, true); a.GetType("nunit.simple.Proto.MyMessageList", true, true); } }
public void TestProtoFileInDifferentDirectory() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto)) { Environment.CurrentDirectory = OriginalWorkingDirectory; RunProtoc(0, proto.TempPath); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileWithExpandedNsDirectories() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(@"nunit\simple\" + test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto)) { RunProtoc(0, proto.TempPath, "-expand_namespace_directories=true"); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileWithExplicitEmptyUmbrellaNamespace() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using ( ProtoFile proto = new ProtoFile(test + ".proto", @" package nunit.simple; // Test a very simple message. message " + test + @" { optional string name = 1; } ")) { //Forces the umbrella class to not use a namespace even if a collision with a type is detected. RunProtoc(0, proto.TempPath, "-umbrella_namespace="); //error CS0441: 'nunit.simple.TestProtoFileWithExplicitEmptyUmbrellaNamespace': a class cannot be both static and sealed RunCsc(1, source.TempPath); } }
public void TestProtoFileWithIgnoredUmbrellaNamespaceDueToNesting() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using (ProtoFile proto = new ProtoFile(test + ".proto", DefaultProto)) { RunProtoc(0, proto.TempPath, "-nest_classes=true", "-umbrella_namespace=MyUmbrella.Namespace"); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("nunit.simple." + test + "+MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("nunit.simple." + test, true, true); } }
public void TestProtoFileAndIgnoreGoogleProtobuf() { string test = new StackFrame(false).GetMethod().Name; Setup(); using (TempFile source = TempFile.Attach(test + ".cs")) using ( ProtoFile proto = new ProtoFile(test + ".proto", @" import ""google/protobuf/csharp_options.proto""; option (google.protobuf.csharp_file_options).namespace = ""MyNewNamespace""; " + DefaultProto)) { string google = Path.Combine(TempPath, "google\\protobuf"); Directory.CreateDirectory(google); foreach (string file in Directory.GetFiles(Path.Combine(OriginalWorkingDirectory, "google\\protobuf"))) { File.Copy(file, Path.Combine(google, Path.GetFileName(file))); } Assert.AreEqual(0, Directory.GetFiles(TempPath, "*.cs").Length); RunProtoc(0, proto.TempPath); Assert.AreEqual(1, Directory.GetFiles(TempPath, "*.cs").Length); Assembly a = RunCsc(0, source.TempPath); //assert that the message type is in the expected namespace Type t = a.GetType("MyNewNamespace.MyMessage", true, true); Assert.IsTrue(typeof(IMessage).IsAssignableFrom(t), "Expect an IMessage"); //assert that we can find the static descriptor type a.GetType("MyNewNamespace." + test, true, true); } }