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 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 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 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 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 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 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 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 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.
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);
}
}
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);
}
}