public void TestConfigurationPlatformDefaults2() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Release|Any CPU = Release|Any CPU Release|Win32 = Release|Win32 Other|Any CPU = Other|Any CPU Other|Win32 = Other|Win32 EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Project msbuildProject = new Project(); SolutionWrapperProject.Generate(solution, msbuildProject, null, null); // If "Debug" is not present, just pick the first configuration name Assertion.AssertEquals("Release", msbuildProject.GetEvaluatedProperty("Configuration")); // if "Mixed Platforms" is not present, just pick the first platform name Assertion.AssertEquals("Any CPU", msbuildProject.GetEvaluatedProperty("Platform")); }
public void TestDisambiguateProjectTargetName() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project('{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}') = 'Build', 'Build\Build.csproj', '{21397922-C38F-4A0E-B950-77B3FBD51881}' EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {21397922-C38F-4A0E-B950-77B3FBD51881}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {21397922-C38F-4A0E-B950-77B3FBD51881}.Debug|Any CPU.Build.0 = Debug|Any CPU {21397922-C38F-4A0E-B950-77B3FBD51881}.Release|Any CPU.ActiveCfg = Release|Any CPU {21397922-C38F-4A0E-B950-77B3FBD51881}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Project msbuildProject = new Project(); SolutionWrapperProject.Generate(solution, msbuildProject, null, null); Assertion.AssertNotNull(msbuildProject.Targets["Build"]); Assertion.AssertNotNull(msbuildProject.Targets["Solution:Build"]); Assertion.AssertNotNull(msbuildProject.Targets["Solution:Build:Clean"]); Assertion.AssertNotNull(msbuildProject.Targets["Solution:Build:Rebuild"]); Assertion.AssertNotNull(msbuildProject.Targets["Solution:Build:Publish"]); Assertion.AssertEquals(null, msbuildProject.Targets["Build"].TargetElement.ChildNodes[0].Attributes["Targets"]); Assertion.AssertEquals("Clean", msbuildProject.Targets["Clean"].TargetElement.ChildNodes[0].Attributes["Targets"].Value); Assertion.AssertEquals("Rebuild", msbuildProject.Targets["Rebuild"].TargetElement.ChildNodes[0].Attributes["Targets"].Value); Assertion.AssertEquals("Publish", msbuildProject.Targets["Publish"].TargetElement.ChildNodes[0].Attributes["Targets"].Value); Assertion.AssertEquals("@(BuildLevel0)", msbuildProject.Targets["Build"].TargetElement.ChildNodes[0].Attributes["Projects"].Value); Assertion.AssertEquals("@(BuildLevel0)", msbuildProject.Targets["Clean"].TargetElement.ChildNodes[0].Attributes["Projects"].Value); Assertion.AssertEquals("@(BuildLevel0)", msbuildProject.Targets["Rebuild"].TargetElement.ChildNodes[0].Attributes["Projects"].Value); Assertion.AssertEquals("@(BuildLevel0)", msbuildProject.Targets["Publish"].TargetElement.ChildNodes[0].Attributes["Projects"].Value); // Here we check that the set of standard entry point targets in the solution project // matches those defined in ProjectInSolution.projectNamesToDisambiguate = { "Build", "Rebuild", "Clean", "Publish" }; int countOfStandardTargets = 0; foreach (Target t in msbuildProject.Targets) { if (!t.Name.Contains(":")) { countOfStandardTargets += 1; } } // NOTE: ValidateSolutionConfiguration and ValidateToolsVersions are always added, so we need to add two extras Assertion.AssertEquals(ProjectInSolution.projectNamesToDisambiguate.Length + 2, countOfStandardTargets); }
public void EmitToolsVersionAttributeToInMemoryProject9() { if (FrameworkLocationHelper.PathToDotNetFrameworkV35 != null) { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Release|Any CPU = Release|Any CPU Release|Win32 = Release|Win32 Other|Any CPU = Other|Any CPU Other|Win32 = Other|Win32 EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Project msbuildProject = new Project(); SolutionWrapperProject.Generate(solution, msbuildProject, "3.5", new BuildEventContext(0, 0, 0, 0)); Assertion.AssertEquals("3.5", msbuildProject.DefaultToolsVersion); } else { Assert.Ignore(".NET Framework 3.5 is required for this test, but is not installed."); } }
public void TestPredictSolutionConfigurationName() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Release|Mixed Platforms = Release|Mixed Platforms Release|Win32 = Release|Win32 Debug|Mixed Platforms = Debug|Mixed Platforms Debug|Win32 = Debug|Win32 EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Engine engine = new Engine(); Assertion.AssertEquals("Debug|Mixed Platforms", SolutionWrapperProject.PredictActiveSolutionConfigurationName(solution, engine)); engine.GlobalProperties.SetProperty("Configuration", "Release"); Assertion.AssertEquals("Release|Mixed Platforms", SolutionWrapperProject.PredictActiveSolutionConfigurationName(solution, engine)); engine.GlobalProperties.SetProperty("Platform", "Win32"); Assertion.AssertEquals("Release|Win32", SolutionWrapperProject.PredictActiveSolutionConfigurationName(solution, engine)); engine.GlobalProperties.SetProperty("Configuration", "Nonexistent"); Assertion.AssertEquals(null, SolutionWrapperProject.PredictActiveSolutionConfigurationName(solution, engine)); }
/// <summary> /// Add a target for a VC project file into the XML doc that's being generated. /// This is used only when building standalone VC projects /// </summary> /// <param name="msbuildProject"></param> /// <param name="projectPath"></param> /// <param name="targetName"></param> /// <param name="subTargetName"></param> /// <owner>RGoel</owner> static private void AddVCBuildTarget ( Project msbuildProject, string projectPath, string targetName, string subTargetName ) { Target newTarget = msbuildProject.Targets.AddNewTarget(targetName); if (subTargetName == "Publish") { // Well, hmmm. The VCBuild doesn't support any kind of // a "Publish" operation. The best we can really do is offer up a // message saying so. SolutionWrapperProject.AddErrorWarningMessageElement(newTarget, XMakeElements.error, true, "SolutionVCProjectNoPublish"); } else { SolutionWrapperProject.AddErrorWarningMessageElement(newTarget, XMakeElements.warning, true, "StandaloneVCProjectP2PRefsBroken"); string projectFullPath = Path.GetFullPath(projectPath); AddVCBuildTaskElement(msbuildProject, newTarget, "$(VCBuildSolutionFile)", projectFullPath, subTargetName, "$(PlatformName)", "$(ConfigurationName)"); } }
public void TestConfigurationPlatformDefaults1() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Debug|Mixed Platforms = Debug|Mixed Platforms Debug|Win32 = Debug|Win32 Release|Any CPU = Release|Any CPU Release|Mixed Platforms = Release|Mixed Platforms Release|Win32 = Release|Win32 EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Project msbuildProject = new Project(); SolutionWrapperProject.Generate(solution, msbuildProject, null, null); // Default for Configuration is "Debug", if present Assertion.AssertEquals("Debug", msbuildProject.GetEvaluatedProperty("Configuration")); // Default for Platform is "Mixed Platforms", if present Assertion.AssertEquals("Mixed Platforms", msbuildProject.GetEvaluatedProperty("Platform")); }
/// <summary> /// Convert passed in solution file to an MSBuild project. This method is used by Sln2Proj /// </summary> /// <owner>vladf</owner> public bool ConvertSLN2Proj(string nameSolutionFile) { // Set the environment variable to cause the SolutionWrapperProject to emit the project to disk string oldValueForMSBuildEmitSolution = Environment.GetEnvironmentVariable("MSBuildEmitSolution"); Environment.SetEnvironmentVariable("MSBuildEmitSolution", "1"); if (nameSolutionFile == null || !File.Exists(nameSolutionFile)) { return(false); } // Parse the solution SolutionParser solution = new SolutionParser(); solution.SolutionFile = nameSolutionFile; solution.ParseSolutionFile(); // Generate the in-memory MSBuild project and output it to disk Project project = new Project(); SolutionWrapperProject.Generate(solution, project, "4.0", null); //Reset the environment variable Environment.SetEnvironmentVariable("MSBuildEmitSolution", oldValueForMSBuildEmitSolution); return(true); }
public void TestAddPropertyGroupForSolutionConfiguration() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project('{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}') = 'ClassLibrary1', 'ClassLibrary1\ClassLibrary1.csproj', '{6185CC21-BE89-448A-B3C0-D1C27112E595}' EndProject Project('{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}') = 'MainApp', 'MainApp\MainApp.vcxproj', '{A6F99D27-47B9-4EA4-BFC9-25157CBDC281}' EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Mixed Platforms = Debug|Mixed Platforms Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {6185CC21-BE89-448A-B3C0-D1C27112E595}.Debug|Mixed Platforms.ActiveCfg = CSConfig1|Any CPU {6185CC21-BE89-448A-B3C0-D1C27112E595}.Debug|Mixed Platforms.Build.0 = CSConfig1|Any CPU {6185CC21-BE89-448A-B3C0-D1C27112E595}.Release|Any CPU.ActiveCfg = CSConfig2|Any CPU {A6F99D27-47B9-4EA4-BFC9-25157CBDC281}.Debug|Mixed Platforms.ActiveCfg = VCConfig1|Win32 {A6F99D27-47B9-4EA4-BFC9-25157CBDC281}.Debug|Mixed Platforms.Build.0 = VCConfig1|Win32 EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Engine engine = new Engine(); Project msbuildProject = new Project(engine); foreach (ConfigurationInSolution solutionConfiguration in solution.SolutionConfigurations) { SolutionWrapperProject.AddPropertyGroupForSolutionConfiguration(msbuildProject, solution, solutionConfiguration); } // Both projects configurations should be present for solution configuration "Debug|Mixed Platforms" msbuildProject.GlobalProperties.SetProperty("Configuration", "Debug"); msbuildProject.GlobalProperties.SetProperty("Platform", "Mixed Platforms"); string solutionConfigurationContents = msbuildProject.GetEvaluatedProperty("CurrentSolutionConfigurationContents"); Assertion.Assert(solutionConfigurationContents.Contains("{6185CC21-BE89-448A-B3C0-D1C27112E595}")); Assertion.Assert(solutionConfigurationContents.Contains("CSConfig1|AnyCPU")); Assertion.Assert(solutionConfigurationContents.Contains("{A6F99D27-47B9-4EA4-BFC9-25157CBDC281}")); Assertion.Assert(solutionConfigurationContents.Contains("VCConfig1|Win32")); // Only the C# project should be present for solution configuration "Release|Any CPU", since the VC project // is missing msbuildProject.GlobalProperties.SetProperty("Configuration", "Release"); msbuildProject.GlobalProperties.SetProperty("Platform", "Any CPU"); solutionConfigurationContents = msbuildProject.GetEvaluatedProperty("CurrentSolutionConfigurationContents"); Assertion.Assert(solutionConfigurationContents.Contains("{6185CC21-BE89-448A-B3C0-D1C27112E595}")); Assertion.Assert(solutionConfigurationContents.Contains("CSConfig2|AnyCPU")); Assertion.Assert(!solutionConfigurationContents.Contains("{A6F99D27-47B9-4EA4-BFC9-25157CBDC281}")); }
public void SolutionParserShouldNotIncreaseNumberOfProjectsLoadedByHost() { string oldValueForMSBuildEmitSolution = Environment.GetEnvironmentVariable("MSBuildEmitSolution"); Environment.SetEnvironmentVariable("MSBuildEmitSolution", "1"); string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project('{F184B08F-C81C-45F6-A57F-5ABD9991F28F}') = 'ConsoleApplication1', 'ConsoleApplication1\ConsoleApplication1.vbproj', '{AB3413A6-D689-486D-B7F0-A095371B3F13}' EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|AnyCPU = Debug|AnyCPU Release|AnyCPU = Release|AnyCPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {AB3413A6-D689-486D-B7F0-A095371B3F13}.Debug|AnyCPU.ActiveCfg = Debug|AnyCPU {AB3413A6-D689-486D-B7F0-A095371B3F13}.Debug|AnyCPU.Build.0 = Debug|AnyCPU {AB3413A6-D689-486D-B7F0-A095371B3F13}.Release|AnyCPU.ActiveCfg = Release|AnyCPU {AB3413A6-D689-486D-B7F0-A095371B3F13}.Release|AnyCPU.Build.0 = Release|AnyCPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Engine engine = new Engine(); Project project = new Project(engine, null); // This project considers itself loaded-by-host. Setting a file name on it, causes it to // ensure the engine believes it is loaded-by-host... project.FullFileName = "my project"; Assertion.AssertEquals(1, engine.ProjectsLoadedByHost.Count); // Create a bogus cache file in the same place -- just to exercise the solution wrapper code that creates a new project string solutionCacheFile = solution.SolutionFile + ".cache"; using (StreamWriter writer = new StreamWriter(solutionCacheFile)) { writer.WriteLine("xxx"); } SolutionWrapperProject.Generate(solution, project, null, null); Assertion.AssertEquals(1, engine.ProjectsLoadedByHost.Count); // Clean up. Delete temp files and reset environment variables. Assertion.Assert("Solution parser should have written in-memory project to disk", File.Exists(solution.SolutionFile + ".proj")); File.Delete(solution.SolutionFile + ".proj"); File.Delete(solutionCacheFile); Environment.SetEnvironmentVariable("MSBuildEmitSolution", oldValueForMSBuildEmitSolution); }
/// <summary> /// This method generates an XmlDocument representing an MSBuild project wrapper for a VC project /// </summary> /// <owner>LukaszG</owner> static internal XmlDocument GenerateVCWrapperProject(Engine parentEngine, string vcProjectFilename, string toolsVersion) { string projectPath = Path.GetFullPath(vcProjectFilename); Project msbuildProject = null; try { msbuildProject = new Project(parentEngine, toolsVersion); } catch (InvalidOperationException) { BuildEventFileInfo fileInfo = new BuildEventFileInfo(projectPath); string errorCode; string helpKeyword; string message = ResourceUtilities.FormatResourceString(out errorCode, out helpKeyword, "UnrecognizedToolsVersion", toolsVersion); throw new InvalidProjectFileException(projectPath, fileInfo.Line, fileInfo.Column, fileInfo.EndLine, fileInfo.EndColumn, message, null, errorCode, helpKeyword); } msbuildProject.IsLoadedByHost = false; msbuildProject.DefaultTargets = "Build"; string wrapperProjectToolsVersion = SolutionWrapperProject.DetermineWrapperProjectToolsVersion(toolsVersion); msbuildProject.DefaultToolsVersion = wrapperProjectToolsVersion; BuildPropertyGroup propertyGroup = msbuildProject.AddNewPropertyGroup(true /* insertAtEndOfProject = true */); propertyGroup.Condition = " ('$(Configuration)' != '') and ('$(Platform)' == '') "; propertyGroup.AddNewProperty("ConfigurationName", "$(Configuration)"); propertyGroup = msbuildProject.AddNewPropertyGroup(true /* insertAtEndOfProject = true */); propertyGroup.Condition = " ('$(Configuration)' != '') and ('$(Platform)' != '') "; propertyGroup.AddNewProperty("ConfigurationName", "$(Configuration)|$(Platform)"); // only use PlatformName if we only have the platform part propertyGroup = msbuildProject.AddNewPropertyGroup(true /* insertAtEndOfProject = true */); propertyGroup.Condition = " ('$(Configuration)' == '') and ('$(Platform)' != '') "; propertyGroup.AddNewProperty("PlatformName", "$(Platform)"); AddVCBuildTarget(msbuildProject, projectPath, "Build", null); AddVCBuildTarget(msbuildProject, projectPath, "Clean", "Clean"); AddVCBuildTarget(msbuildProject, projectPath, "Rebuild", "Rebuild"); AddVCBuildTarget(msbuildProject, projectPath, "Publish", "Publish"); // Special environment variable to allow people to see the in-memory MSBuild project generated // to represent the VC project. if (Environment.GetEnvironmentVariable("MSBuildEmitSolution") != null) { msbuildProject.Save(vcProjectFilename + ".proj"); } return(msbuildProject.XmlDocument); }
public void ToolsVersionOverrideShouldBeSpecifiedOnMSBuildTaskInvocations() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project('{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}') = 'ClassLibrary1', 'ClassLibrary1\ClassLibrary1.csproj', '{6185CC21-BE89-448A-B3C0-D1C27112E595}' EndProject Project('{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}') = 'MainApp', 'MainApp\MainApp.vcxproj', '{A6F99D27-47B9-4EA4-BFC9-25157CBDC281}' EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Mixed Platforms = Debug|Mixed Platforms Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {6185CC21-BE89-448A-B3C0-D1C27112E595}.Debug|Mixed Platforms.ActiveCfg = CSConfig1|Any CPU {6185CC21-BE89-448A-B3C0-D1C27112E595}.Debug|Mixed Platforms.Build.0 = CSConfig1|Any CPU {6185CC21-BE89-448A-B3C0-D1C27112E595}.Release|Any CPU.ActiveCfg = CSConfig2|Any CPU {A6F99D27-47B9-4EA4-BFC9-25157CBDC281}.Debug|Mixed Platforms.ActiveCfg = VCConfig1|Win32 {A6F99D27-47B9-4EA4-BFC9-25157CBDC281}.Debug|Mixed Platforms.Build.0 = VCConfig1|Win32 EndGlobalSection EndGlobal "; // We're not passing in a /tv:xx switch, so the solution project will have tools version 3.5 Project project = new Project(); SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); BuildEventContext buildEventContext = new BuildEventContext(0, 0, 0, 0); SolutionWrapperProject.Generate(solution, project, "3.5", buildEventContext); foreach (Target target in project.Targets) { foreach (XmlNode childNode in target.TargetElement) { if (0 == String.Compare(childNode.Name, "MSBuild", StringComparison.OrdinalIgnoreCase)) { // we found an MSBuild task invocation, now let's verify that it has the correct // ToolsVersion parameter set XmlAttribute toolsVersionAttribute = childNode.Attributes["ToolsVersion"]; Assertion.Assert(0 == String.Compare( toolsVersionAttribute.Value, "$(ProjectToolsVersion)", StringComparison.OrdinalIgnoreCase) ); } } } }
public void AddNewErrorWarningMessageElement() { MockLogger logger = new MockLogger(); Project project = ObjectModelHelpers.CreateInMemoryProject( "<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>" + "<Target Name=`Build`>" + "</Target>" + "</Project>", logger); Target target = project.Targets["Build"]; SolutionWrapperProject.AddErrorWarningMessageElement(target, XMakeElements.message, true, "SolutionVenusProjectNoClean"); SolutionWrapperProject.AddErrorWarningMessageElement(target, XMakeElements.warning, true, "SolutionParseUnknownProjectType", "proj1.csproj"); SolutionWrapperProject.AddErrorWarningMessageElement(target, XMakeElements.error, true, "SolutionVCProjectNoPublish"); project.Build(null, null); string code = null; string keyword = null; string text = ResourceUtilities.FormatResourceString(out code, out keyword, "SolutionParseUnknownProjectType", "proj1.csproj"); // check the error event Assertion.AssertEquals(1, logger.Warnings.Count); BuildWarningEventArgs warning = logger.Warnings[0]; Assertion.AssertEquals(text, warning.Message); Assertion.AssertEquals(code, warning.Code); Assertion.AssertEquals(keyword, warning.HelpKeyword); code = null; keyword = null; text = ResourceUtilities.FormatResourceString(out code, out keyword, "SolutionVCProjectNoPublish"); // check the warning event Assertion.AssertEquals(1, logger.Errors.Count); BuildErrorEventArgs error = logger.Errors[0]; Assertion.AssertEquals(text, error.Message); Assertion.AssertEquals(code, error.Code); Assertion.AssertEquals(keyword, error.HelpKeyword); code = null; keyword = null; text = ResourceUtilities.FormatResourceString(out code, out keyword, "SolutionVenusProjectNoClean"); // check the message event Assertion.Assert("Log should contain the regular message", logger.FullLog.Contains(text)); }
public void ToolsVersionOverrideThrowsOnInvalidToolsVersion() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project('{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}') = 'ClassLibrary1', 'ClassLibrary1\ClassLibrary1.csproj', '{6185CC21-BE89-448A-B3C0-D1C27112E595}' EndProject Project('{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}') = 'MainApp', 'MainApp\MainApp.vcxproj', '{A6F99D27-47B9-4EA4-BFC9-25157CBDC281}' EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Mixed Platforms = Debug|Mixed Platforms Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {6185CC21-BE89-448A-B3C0-D1C27112E595}.Debug|Mixed Platforms.ActiveCfg = CSConfig1|Any CPU {6185CC21-BE89-448A-B3C0-D1C27112E595}.Debug|Mixed Platforms.Build.0 = CSConfig1|Any CPU {6185CC21-BE89-448A-B3C0-D1C27112E595}.Release|Any CPU.ActiveCfg = CSConfig2|Any CPU {A6F99D27-47B9-4EA4-BFC9-25157CBDC281}.Debug|Mixed Platforms.ActiveCfg = VCConfig1|Win32 {A6F99D27-47B9-4EA4-BFC9-25157CBDC281}.Debug|Mixed Platforms.Build.0 = VCConfig1|Win32 EndGlobalSection EndGlobal "; string oldUseNoCacheValue = Environment.GetEnvironmentVariable("MSBuildUseNoSolutionCache"); try { // We want to avoid using the solution cache -- it could lead to circumstances where detritus left // on the disk leads us down paths we didn't mean to go. Environment.SetEnvironmentVariable("MSBuildUseNoSolutionCache", "1"); // We're not passing in a /tv:xx switch, so the solution project will have tools version 3.5 Project project = new Project(); SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); BuildEventContext buildEventContext = new BuildEventContext(0, 0, 0, 0); SolutionWrapperProject.Generate(solution, project, "invalid", buildEventContext); Assertion.AssertEquals("4.0", project.DefaultToolsVersion); } finally { Environment.SetEnvironmentVariable("MSBuildUseNoSolutionCache", oldUseNoCacheValue); } }
private static Project CreateVenusSolutionProject(BuildPropertyGroup globalProperties, string toolsVersion) { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project('{E24C65DC-7377-472B-9ABA-BC803B73C61A}') = 'C:\solutions\WebSite2\', '..\..\solutions\WebSite2\', '{F90528C4-6989-4D33-AFE8-F53173597CC2}' ProjectSection(WebsiteProperties) = preProject Debug.AspNetCompiler.VirtualPath = '/WebSite2' Debug.AspNetCompiler.PhysicalPath = '..\..\solutions\WebSite2\' Debug.AspNetCompiler.TargetPath = 'PrecompiledWeb\WebSite2\' Debug.AspNetCompiler.Updateable = 'true' Debug.AspNetCompiler.ForceOverwrite = 'true' Debug.AspNetCompiler.FixedNames = 'true' Debug.AspNetCompiler.Debug = 'True' Release.AspNetCompiler.VirtualPath = '/WebSite2' Release.AspNetCompiler.PhysicalPath = '..\..\solutions\WebSite2\' Release.AspNetCompiler.TargetPath = 'PrecompiledWeb\WebSite2\' Release.AspNetCompiler.Updateable = 'true' Release.AspNetCompiler.ForceOverwrite = 'true' Release.AspNetCompiler.FixedNames = 'true' Release.AspNetCompiler.Debug = 'False' VWDPort = '2776' DefaultWebSiteLanguage = 'Visual C#' EndProjectSection EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {F90528C4-6989-4D33-AFE8-F53173597CC2}.Debug|Any CPU.ActiveCfg = Debug|.NET {F90528C4-6989-4D33-AFE8-F53173597CC2}.Debug|Any CPU.Build.0 = Debug|.NET EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Engine engine = new Engine(globalProperties); Project msbuildProject = new Project(engine); SolutionWrapperProject.Generate(solution, msbuildProject, toolsVersion, null); return(msbuildProject); }
static void Main(string[] args) { string nameOfSolutionForThisProject = @"MySolutionFile.sln"; string wrapperContent = SolutionWrapperProject.Generate(nameOfSolutionForThisProject, toolsVersionOverride: null, projectBuildEventContext: null); byte[] rawWrapperContent = Encoding.Unicode.GetBytes(wrapperContent.ToCharArray()); using (MemoryStream memStream = new MemoryStream(rawWrapperContent)) using (XmlTextReader xmlReader = new XmlTextReader(memStream)) { Project proj = ProjectCollection.GlobalProjectCollection.LoadProject(xmlReader); foreach (var p in proj.ConditionedProperties) { Console.WriteLine(p.Key); Console.WriteLine(string.Join(", ", p.Value)); } } Console.ReadLine(); }
private string FindProject(string file, string name) { // Load the solution file using msbuild and get the csproj file in it. StringReader reader = new StringReader(SolutionWrapperProject.Generate(file, null, null)); XmlReader xml = XmlReader.Create(reader); _BE.Project prj = new _BE.Project(xml); string csprjName = string.Empty; foreach (_BE.ProjectItem bi in prj.Items) { if (string.Equals("_SolutionProjectProjects", bi.ItemType, StringComparison.InvariantCultureIgnoreCase)) { csprjName = bi.EvaluatedInclude; } } file = file.Replace(name, csprjName); return(file); }
public void EmitToolsVersionAttributeToInMemoryProject10() { string solutionFileContents = @" Microsoft Visual Studio Solution File, Format Version 10.00 Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Release|Any CPU = Release|Any CPU Release|Win32 = Release|Win32 Other|Any CPU = Other|Any CPU Other|Win32 = Other|Win32 EndGlobalSection EndGlobal "; SolutionParser solution = SolutionParser_Tests.ParseSolutionHelper(solutionFileContents); Project msbuildProject = new Project(); SolutionWrapperProject.Generate(solution, msbuildProject, "4.0", new BuildEventContext(0, 0, 0, 0)); Assertion.AssertEquals("4.0", msbuildProject.DefaultToolsVersion); }
/// <summary> /// Compiles the specified solution path. /// </summary> /// <param name="solutionPath">The solution path.</param> /// <param name="outputDir">The output dir.</param> /// <param name="configuration">The configuration.</param> /// <param name="platform">The platform.</param> /// <param name="emit">if set to <c>true</c> [emit].</param> /// <returns></returns> public static bool Compile(string solutionPath, string outputDir, string configuration = "Debug", string platform = "Any CPU", bool emit = false) { ProjectCollection pc = new ProjectCollection(); if (emit) { SetEnv(EmitSolution, "1"); SetEnv("MSBUILD_EXE_PATH", @"C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\MSBuild\15.0\Bin"); SetEnv("VSINSTALLDIR", @"C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional"); SetEnv("VisualStudioVersion", @"15.0"); if (Directory.GetFiles(Path.GetDirectoryName(solutionPath), "*.cache", SearchOption.TopDirectoryOnly).Length == 0) { var foo = SolutionWrapperProject.Generate( solutionPath, ToolLocationHelper.CurrentToolsVersion, null); //Console.WriteLine(foo); } } else if (!emit && Environment.GetEnvironmentVariable(EmitSolution, EnvironmentVariableTarget.Machine) == "1") { Environment.SetEnvironmentVariable(EmitSolution, "0", EnvironmentVariableTarget.Machine); } // THERE ARE A LOT OF PROPERTIES HERE, THESE MAP TO THE MSBUILD CLI PROPERTIES Dictionary <string, string> globalProperties = new Dictionary <string, string> { { "Configuration", configuration }, // always "Debug" { "Platform", platform }, // always "Any CPU" { "ToolsVersion", ToolLocationHelper.CurrentToolsVersion }, { "OutputPath", outputDir }, }; var logger = new ConsoleLogger(); BuildParameters bp = new BuildParameters(pc) { Loggers = new[] { logger } }; BuildRequestData buildRequest = new BuildRequestData( projectFullPath: solutionPath, globalProperties: globalProperties, toolsVersion: ToolLocationHelper.CurrentToolsVersion, targetsToBuild: new string[] { "Build" }, hostServices: null); // THIS IS WHERE THE MAGIC HAPPENS - IN PROCESS MSBUILD try { BuildResult buildResult = BuildManager.DefaultBuildManager.Build(bp, buildRequest); // A SIMPLE WAY TO CHECK THE RESULT return(buildResult.OverallResult == BuildResultCode.Success); } catch { throw; } finally { pc.UnregisterAllLoggers(); logger.Shutdown(); } }