示例#1
0
        public void Test_ManifestResourceName_CompiledResource_DynamicPrefix()
        {
            VbcTask vbcTask = new VbcTask();

            vbcTask.Project       = CreateEmptyProject();
            vbcTask.CallStack     = vbcTask.Project.RootTargetCallStack;
            vbcTask.RootNamespace = "TestRootNamespace";

            ResourceFileSet resources = new ResourceFileSet();

            resources.BaseDirectory = TempDirectory;
            resources.DynamicPrefix = true;

            // holds the path to the resource file
            string resourceFile = null;

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName,
                                        "ResourceFile.resources");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual("ResourceFile.resources",
                            vbcTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName,
                                        "ResourceFile.en-US.resources");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual("ResourceFile.en-US.resources",
                            vbcTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.resources");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual("SubDir" + "." + "ResourceFile.resources",
                            vbcTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.en-US.resources");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual("SubDir" + "." + "ResourceFile.en-US.resources",
                            vbcTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.en-US.dunno.en-US.resources");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual("SubDir" + "." + "ResourceFile.en-US.dunno.en-US.resources",
                            vbcTask.GetManifestResourceName(resources, resourceFile));
        }
示例#2
0
        public void Test_ManifestResourceName_PrefixWithSpecialCharacters()
        {
            ResourceFileSet fileset = new ResourceFileSet();

            fileset.BaseDirectory = TempDirectory;
            fileset.DynamicPrefix = true;

            string actualName;

            // if part of the prefix starts with a number, it should be
            // prefixed with an underscore
            fileset.Prefix = @"Root.1MyProj.Howdy";
            actualName     = fileset.GetManifestResourceName(Path.Combine(
                                                                 fileset.BaseDirectory.FullName, "mydir" + Path.DirectorySeparatorChar
                                                                 + "file.txt"));
            Assert.AreEqual("Root._1MyProj.Howdy" + ".mydir.file.txt", actualName,
                            "Incorrect manifest resource name.");

            // any character in the prefix that is neither letter nor digit should
            // be replaced with an underscore
            fileset.Prefix = @"Root.-MyProj.H0w!dy";
            actualName     = fileset.GetManifestResourceName(Path.Combine(
                                                                 fileset.BaseDirectory.FullName, "mydir" + Path.DirectorySeparatorChar
                                                                 + "file.txt"));
            Assert.AreEqual("Root._MyProj.H0w_dy" + ".mydir.file.txt", actualName,
                            "Incorrect manifest resource name.");

            // the file name part of a manifest resource name can start with a
            // digit
            fileset.Prefix = @"Root.MyProj.Howdy";
            actualName     = fileset.GetManifestResourceName(Path.Combine(
                                                                 fileset.BaseDirectory.FullName, "mydir" + Path.DirectorySeparatorChar
                                                                 + "1file.txt"));
            Assert.AreEqual("Root.MyProj.Howdy" + ".mydir.1file.txt", actualName,
                            "Incorrect manifest resource name.");

            // the extension part of a manifest resource name can start with a
            // digit
            fileset.Prefix = @"Root.MyProj.Howdy";
            actualName     = fileset.GetManifestResourceName(Path.Combine(
                                                                 fileset.BaseDirectory.FullName, "mydir" + Path.DirectorySeparatorChar
                                                                 + "file.1txt"));
            Assert.AreEqual("Root.MyProj.Howdy" + ".mydir.file.1txt", actualName,
                            "Incorrect manifest resource name.");

            // the file name part of a manifest resource name can contain
            // characters that are neither letter nor digit
            fileset.Prefix = @"Root.MyProj.Howdy";
            actualName     = fileset.GetManifestResourceName(Path.Combine(
                                                                 fileset.BaseDirectory.FullName, "mydir" + Path.DirectorySeparatorChar
                                                                 + "f-ile.txt"));
            Assert.AreEqual("Root.MyProj.Howdy" + ".mydir.f-ile.txt", actualName,
                            "Incorrect manifest resource name.");

            // the extension part of a manifest resource name can contain
            // characters that are neither letter nor digit
            fileset.Prefix = @"Root.MyProj.Howdy";
            actualName     = fileset.GetManifestResourceName(Path.Combine(
                                                                 fileset.BaseDirectory.FullName, "mydir" + Path.DirectorySeparatorChar
                                                                 + "file.t!xt"));
            Assert.AreEqual("Root.MyProj.Howdy" + ".mydir.file.t!xt", actualName,
                            "Incorrect manifest resource name.");
        }
示例#3
0
        private void PerformDependentResxTests(CscTask cscTask, ResourceFileSet resources)
        {
            // holds the path to the resource file
            string resourceFile = null;

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName,
                                        "ResourceFile.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCodeWithNamespace, Path.Combine(
                                            resources.BaseDirectory.FullName, "ResourceFile." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("ResourceTest.HelloWorld.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName,
                                        "ResourceFile.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCode, Path.Combine(
                                            resources.BaseDirectory.FullName, "ResourceFile." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("HelloWorld.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName,
                                        "ResourceFile.en-US.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCodeWithNamespace, Path.Combine(
                                            resources.BaseDirectory.FullName, "ResourceFile." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("ResourceTest.HelloWorld.en-US.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName,
                                        "ResourceFile.en-US.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCode, Path.Combine(
                                            resources.BaseDirectory.FullName, "ResourceFile." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("HelloWorld.en-US.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCodeWithNamespace, Path.Combine(
                                            resources.BaseDirectory.FullName, "SubDir" + Path.DirectorySeparatorChar
                                            + "ResourceFile." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("ResourceTest.HelloWorld.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCode, Path.Combine(
                                            resources.BaseDirectory.FullName, "SubDir" + Path.DirectorySeparatorChar
                                            + "ResourceFile." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("HelloWorld.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.en-US.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCodeWithNamespace, Path.Combine(
                                            resources.BaseDirectory.FullName, "SubDir" + Path.DirectorySeparatorChar
                                            + "ResourceFile." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("ResourceTest.HelloWorld.en-US.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.en-US.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCode, Path.Combine(
                                            resources.BaseDirectory.FullName, "SubDir" + Path.DirectorySeparatorChar
                                            + "ResourceFile." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("HelloWorld.en-US.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.en-US.dunno.en-US.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCodeWithNamespace, Path.Combine(
                                            resources.BaseDirectory.FullName, "SubDir" + Path.DirectorySeparatorChar
                                            + "ResourceFile.en-US.dunno." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("ResourceTest.HelloWorld.en-US.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.en-US.dunno.en-US.resx");
            // create resource file
            CreateTempFile(resourceFile);
            // create dependent file
            TempFile.CreateWithContents(_sourceCode, Path.Combine(
                                            resources.BaseDirectory.FullName, "SubDir" + Path.DirectorySeparatorChar
                                            + "ResourceFile.en-US.dunno." + cscTask.Extension));
            // assert manifest resource name
            Assert.AreEqual("HelloWorld.en-US.resources",
                            cscTask.GetManifestResourceName(resources, resourceFile));
        }
示例#4
0
        protected void RunCscTask()
        {
            CscTask csc = new CscTask();

            this.CopyTo(csc);

            if (this.Project.PlatformName == "unix")
            {
                // on Windows this is csc, but on Mono on Linux or Mac we need mcs
                csc.ExeName = "mcs";
            }

            XmlDocument doc = new XmlDocument();

            doc.Load(FCSProjFile);

            XmlNode propertyGroup = doc.DocumentElement.FirstChild;
            Dictionary <string, string> mainProperties = new Dictionary <string, string>();

            foreach (XmlNode propNode in propertyGroup.ChildNodes)
            {
                mainProperties.Add(propNode.Name, propNode.InnerText);
            }

            string OutputFile = Path.GetFullPath(Path.GetDirectoryName(FCSProjFile) + "/" + mainProperties["OutputPath"].Replace("\\", "/"));

            OutputFile += "/" + mainProperties["AssemblyName"];

            if (mainProperties["OutputType"].ToLower() == "library")
            {
                OutputFile += ".dll";
            }
            else
            {
                OutputFile += ".exe";
            }

            csc.OutputFile   = new FileInfo(OutputFile);
            csc.DocFile      = new FileInfo(mainProperties["DocumentationFile"]);
            csc.OutputTarget = mainProperties["OutputType"];

            // needed because of sqlite3.dll, when compiling on Linux for Windows
            if (this.Project.PlatformName == "unix")
            {
                csc.Platform = "x86";
            }

            csc.Define = "DEBUGMODE";

            String FrameworkDLLPath = Path.GetDirectoryName(System.Reflection.Assembly.GetAssembly(typeof(System.Type)).Location);

            foreach (XmlNode ProjectNodeChild in doc.DocumentElement)
            {
                if (ProjectNodeChild.Name == "ItemGroup")
                {
                    foreach (XmlNode ItemNode in ProjectNodeChild)
                    {
                        if (ItemNode.Name == "Reference")
                        {
                            if (ItemNode.HasChildNodes && (ItemNode.ChildNodes[0].Name == "HintPath"))
                            {
                                csc.References.AsIs.Add(ItemNode.ChildNodes[0].InnerText);
                            }
                            else
                            {
                                // .net dlls
                                csc.References.AsIs.Add(
                                    FrameworkDLLPath + Path.DirectorySeparatorChar +
                                    ItemNode.Attributes["Include"].Value + ".dll");
                            }
                        }
                        else if (ItemNode.Name == "ProjectReference")
                        {
                            string ReferencedProjectName = ItemNode.ChildNodes[1].InnerText;
                            csc.References.AsIs.Add(
                                Path.GetDirectoryName(OutputFile) + Path.DirectorySeparatorChar +
                                ReferencedProjectName + ".dll");
                        }
                        else if (ItemNode.Name == "Compile")
                        {
                            csc.Sources.AsIs.Add(ItemNode.Attributes["Include"].Value);
                        }
                        else if (ItemNode.Name == "EmbeddedResource")
                        {
                            ResourceFileSet fs = new ResourceFileSet();
                            fs.AsIs.Add(ItemNode.Attributes["Include"].Value);
                            csc.ResourcesList.Add(fs);
                        }
                    }
                }
            }

            csc.Execute();
        }
示例#5
0
        public void Test_ManifestResourceName_NonResx_Prefix_With_DynamicPrefix()
        {
            CscTask cscTask = new CscTask();

            cscTask.Project   = CreateEmptyProject();
            cscTask.CallStack = cscTask.Project.RootTargetCallStack;

            ResourceFileSet resources = new ResourceFileSet();

            resources.BaseDirectory = TempDirectory;
            resources.Prefix        = "TestNamespace";
            resources.DynamicPrefix = true;

            // holds the path to the resource file
            string resourceFile = null;

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName,
                                        "ResourceFile.txt");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual(resources.Prefix + "." + "ResourceFile.txt",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName,
                                        "ResourceFile.en-US.txt");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual(resources.Prefix + "." + "ResourceFile.txt",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.txt");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual(resources.Prefix + "." + "SubDir" + "." + "ResourceFile.txt",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.en-US.txt");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual(resources.Prefix + "." + "SubDir" + "." + "ResourceFile.txt",
                            cscTask.GetManifestResourceName(resources, resourceFile));

            // initialize resource file
            resourceFile = Path.Combine(resources.BaseDirectory.FullName, "SubDir"
                                        + Path.DirectorySeparatorChar + "ResourceFile.en-US.dunno.en-US.txt");
            // create resource file
            CreateTempFile(resourceFile);
            // assert manifest resource name
            Assert.AreEqual(resources.Prefix + "." + "SubDir" + "."
                            + "ResourceFile.en-US.dunno.txt", cscTask.GetManifestResourceName(
                                resources, resourceFile));
        }