diff options
author | csharptest <roger@csharptest.net> | 2010-09-03 16:36:50 -0500 |
---|---|---|
committer | csharptest <roger@csharptest.net> | 2010-09-03 16:36:50 -0500 |
commit | e8e1dab03f8cdd473a3504c4efbe6920eb2c2612 (patch) | |
tree | 7c03f66af7cb01ed678a82f2832cf90c00a34eca /src/ProtoGen.Test | |
parent | 5c69749b0b4b4aaa808c208d33b9192e4328e7b4 (diff) | |
download | protobuf-e8e1dab03f8cdd473a3504c4efbe6920eb2c2612.tar.gz protobuf-e8e1dab03f8cdd473a3504c4efbe6920eb2c2612.tar.bz2 protobuf-e8e1dab03f8cdd473a3504c4efbe6920eb2c2612.zip |
Completed the following changes & testing, see todo.txt for more information
1 - Add a way to specify the output directory
2 - Added an option "file_extension" to control the suffix for cs files generated, defaults to ".cs"
3 - Added the option for "umbrella_namespace" used when nest_classes=false and having name conflicts
4 - Optionally remove dependencies to csharp options
5 - Investigate command line parsing library
6 - Investigate calling protoc directly
7 - Unable to resolve dependencies correctly
8 - Added several (20) nunits to automate the command-line invocation of each option
Diffstat (limited to 'src/ProtoGen.Test')
-rw-r--r-- | src/ProtoGen.Test/ProtoGen.Test.csproj | 18 | ||||
-rw-r--r-- | src/ProtoGen.Test/TempFile.cs | 48 | ||||
-rw-r--r-- | src/ProtoGen.Test/TestPreprocessing.cs | 600 |
3 files changed, 666 insertions, 0 deletions
diff --git a/src/ProtoGen.Test/ProtoGen.Test.csproj b/src/ProtoGen.Test/ProtoGen.Test.csproj index f08495e5..2ac2cb11 100644 --- a/src/ProtoGen.Test/ProtoGen.Test.csproj +++ b/src/ProtoGen.Test/ProtoGen.Test.csproj @@ -50,10 +50,14 @@ <HintPath>..\..\lib\Rhino.Mocks.dll</HintPath> </Reference> <Reference Include="System" /> + <Reference Include="System.Data" /> + <Reference Include="System.Xml" /> </ItemGroup> <ItemGroup> <Compile Include="DependencyResolutionTest.cs" /> <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="TempFile.cs" /> + <Compile Include="TestPreprocessing.cs" /> </ItemGroup> <ItemGroup> <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj"> @@ -68,6 +72,20 @@ <ItemGroup> <None Include="Properties\Google.ProtocolBuffers.ProtoGen.Test.snk" /> </ItemGroup> + <ItemGroup> + <None Include="..\..\lib\protoc.exe"> + <Link>protoc.exe</Link> + <CopyToOutputDirectory>Always</CopyToOutputDirectory> + </None> + <None Include="..\..\protos\google\protobuf\csharp_options.proto"> + <Link>google\protobuf\csharp_options.proto</Link> + <CopyToOutputDirectory>Always</CopyToOutputDirectory> + </None> + <None Include="..\..\protos\google\protobuf\descriptor.proto"> + <Link>google\protobuf\descriptor.proto</Link> + <CopyToOutputDirectory>Always</CopyToOutputDirectory> + </None> + </ItemGroup> <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> <!-- To modify your build process, add your task inside one of the targets below and uncomment it. Other similar extension points exist, see Microsoft.Common.targets. diff --git a/src/ProtoGen.Test/TempFile.cs b/src/ProtoGen.Test/TempFile.cs new file mode 100644 index 00000000..fdc637a8 --- /dev/null +++ b/src/ProtoGen.Test/TempFile.cs @@ -0,0 +1,48 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace Google.ProtocolBuffers.ProtoGen +{ + class ProtoFile : TempFile + { + public ProtoFile (string filename, string contents) + { + _tempFile = filename; + File.WriteAllText(_tempFile, contents); + } + } + class TempFile : IDisposable + { + protected string _tempFile; + + public static TempFile Attach(string path) + { + TempFile f = new TempFile(); + f._tempFile = path; + return f; + } + + protected TempFile() { } + public TempFile(string contents) + { + File.WriteAllText(_tempFile = Path.GetTempFileName(), contents, Encoding.ASCII); + } + + public string TempPath { get { return _tempFile; } } + + public void ChangeExtension(string ext) + { + string newFile = Path.ChangeExtension(_tempFile, ext); + File.Move(_tempFile, newFile); + _tempFile = newFile; + } + + public void Dispose() + { + if(File.Exists(_tempFile)) + File.Delete(_tempFile); + } + } +} diff --git a/src/ProtoGen.Test/TestPreprocessing.cs b/src/ProtoGen.Test/TestPreprocessing.cs new file mode 100644 index 00000000..7a2ea621 --- /dev/null +++ b/src/ProtoGen.Test/TestPreprocessing.cs @@ -0,0 +1,600 @@ +#region Copyright notice and license +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// http://github.com/jskeet/dotnet-protobufs/ +// Original C++/Java/Python code: +// http://code.google.com/p/protobuf/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#endregion +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Reflection; +using NUnit.Framework; + +namespace Google.ProtocolBuffers.ProtoGen +{ + [TestFixture] + [Category("Preprocessor")] + public partial class TestPreprocessing + { + private static readonly string TEMP = Path.Combine(Path.GetTempPath(), "proto-gen-test"); + private const string DEFAULT_PROTO = @" +package nunit.simple; +// Test a very simple message. +message MyMessage { + optional string name = 1; +}"; + + #region TestFixture SetUp/TearDown + private string OriginalWorkingDirectory = Environment.CurrentDirectory; + [TestFixtureSetUp] + public virtual void Setup() + { + Teardown(); + Directory.CreateDirectory(TEMP); + Environment.CurrentDirectory = TEMP; + } + + [TestFixtureTearDown] + public virtual void Teardown() + { + Environment.CurrentDirectory = OriginalWorkingDirectory; + if (Directory.Exists(TEMP)) + Directory.Delete(TEMP, true); + } + #endregion + #region Helper Methods RunProtoGen / RunCsc + void RunProtoGen(int expect, params string[] args) + { + TextWriter tout = Console.Out, terr = Console.Error; + StringWriter temp = new StringWriter(); + Console.SetOut(temp); + Console.SetError(temp); + try + { + Assert.AreEqual(expect, ProgramPreprocess.Run(args), "ProtoGen Failed: {0}", temp); + } + finally + { + Console.SetOut(tout); + Console.SetError(terr); + } + } + + private Assembly RunCsc(int expect, params string[] sources) + { + using (TempFile tempDll = new TempFile(String.Empty)) + { + tempDll.ChangeExtension(".dll"); + List<string> args = new List<string>(); + args.Add("/nologo"); + args.Add("/target:library"); + args.Add("/debug-"); + args.Add(String.Format(@"""/out:{0}""", tempDll.TempPath)); + args.Add("/r:System.dll"); + args.Add(String.Format(@"""/r:{0}""", typeof (Google.ProtocolBuffers.DescriptorProtos.DescriptorProto).Assembly.Location)); + args.AddRange(sources); + + string exe = Path.Combine(System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(), "csc.exe"); + ProcessStartInfo psi = new ProcessStartInfo(exe); + psi.CreateNoWindow = true; + psi.UseShellExecute = false; + psi.RedirectStandardOutput = true; + psi.RedirectStandardError = true; + psi.Arguments = string.Join(" ", args.ToArray()); + Process p = Process.Start(psi); + p.WaitForExit(); + string errorText = p.StandardOutput.ReadToEnd() + p.StandardError.ReadToEnd(); + Assert.AreEqual(expect, p.ExitCode, "CSC.exe Failed: {0}", errorText); + + Assembly asm = null; + if (p.ExitCode == 0) + { + byte[] allbytes = File.ReadAllBytes(tempDll.TempPath); + asm = Assembly.Load(allbytes); + + foreach (Type t in asm.GetTypes()) + Debug.WriteLine(t.FullName, asm.FullName); + } + return asm; + } + } + #endregion + + // ******************************************************************* + // The following tests excercise options for protogen.exe + // ******************************************************************* + + [Test] + public void TestProtoFile() + { + string test = new StackFrame(false).GetMethod().Name; + Setup(); + using (TempFile source = TempFile.Attach(test + ".cs")) + using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO)) + { + RunProtoGen(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); + } + } + [Test] + 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; +} ")) + { + RunProtoGen(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); + } + } + [Test] + public void TestProtoFileWithNamespace() + { + string test = new StackFrame(false).GetMethod().Name; + Setup(); + using (TempFile source = TempFile.Attach(test + ".cs")) + using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO)) + { + RunProtoGen(0, proto.TempPath, "-namespace:MyNewNamespace"); + 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); + } + } + [Test] + public void TestProtoFileWithUmbrellaClassName() + { + string test = new StackFrame(false).GetMethod().Name; + Setup(); + using (TempFile source = TempFile.Attach("MyUmbrellaClassname.cs")) + using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO)) + { + RunProtoGen(0, proto.TempPath, "/umbrella_classname=MyUmbrellaClassname"); + 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.MyUmbrellaClassname", true, true); + } + } + [Test] + public void TestProtoFileWithNestedClass() + { + string test = new StackFrame(false).GetMethod().Name; + Setup(); + using (TempFile source = TempFile.Attach(test + ".cs")) + using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO)) + { + RunProtoGen(0, proto.TempPath, "-nest_classes:true"); + 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); + } + } + [Test] + 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", DEFAULT_PROTO)) + { + RunProtoGen(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); + } + } + [Test] + 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); + } + } + [Test] + 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", DEFAULT_PROTO)) + { + 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); + } + } + [Test] + public void TestProtoFileWithUmbrellaNamespace() + { + string test = new StackFrame(false).GetMethod().Name; + Setup(); + using (TempFile source = TempFile.Attach(test + ".cs")) + using (ProtoFile proto = new ProtoFile(test + ".proto", DEFAULT_PROTO)) + { + RunProtoGen(0, proto.TempPath, "-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.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.MyUmbrella.Namespace." + test, true, true); + } + } + [Test] + 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", DEFAULT_PROTO)) + { + 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); + } + } + [Test] + 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); + } + } + [Test] + 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", DEFAULT_PROTO)) + { + RunProtoGen(1, proto.TempPath, "-output_directory:generated-code"); + Directory.CreateDirectory("generated-code"); + RunProtoGen(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); + } + } + [Test] + 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""; +" + DEFAULT_PROTO)) + { + string google = Path.Combine(TEMP, "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(TEMP, "*.cs").Length); + RunProtoGen(0, proto.TempPath, "-ignore_google_protobuf:true"); + Assert.AreEqual(1, Directory.GetFiles(TEMP, "*.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); + } + } + [Test] + 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""; +" + DEFAULT_PROTO)) + { + string google = Path.Combine(TEMP, "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(TEMP, "*.cs").Length); + //Without the option this fails due to being unable to resolve google/protobuf descriptors + RunProtoGen(1, proto.TempPath, "-ignore_google_protobuf:false"); + } + } + + // ******************************************************************* + // The following tests excercise options for protoc.exe + // ******************************************************************* + + [Test] + 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(TEMP, "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(TEMP, "*.cs").Length); + //if you specify the protoc option --include_imports this should build three source files + RunProtoGen(0, proto.TempPath, "--include_imports"); + Assert.AreEqual(3, Directory.GetFiles(TEMP, "*.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); + } + } + [Test] + public void TestProtoFileWithIncludeImportsAndIgnoreGoogleProtobuf() + { + 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(TEMP, "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(TEMP, "*.cs").Length); + //Even with --include_imports, if you provide -ignore_google_protobuf:true you only get the one source file + RunProtoGen(0, proto.TempPath, "-ignore_google_protobuf:true", "--include_imports"); + Assert.AreEqual(1, Directory.GetFiles(TEMP, "*.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); + } + } + [Test] + 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); + } + } + //Seems the --proto_path or -I option is non-functional for me. Maybe others have luck? + [Test, Ignore("http://code.google.com/p/protobuf/issues/detail?id=40")] + 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", DEFAULT_PROTO)) + { + Environment.CurrentDirectory = OriginalWorkingDirectory; + RunProtoGen(0, proto.TempPath, "--proto_path=" + TEMP); + 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); + } + } + + // ******************************************************************* + // Handling of mutliple input files + // ******************************************************************* + + [Test] + 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); + } + } + [Test] + 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); + } + } + } +} |