public void UpdateMetadataImported() { Assert.Throws <InvalidOperationException>(() => { string file = null; try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); ProjectRootElement import = ProjectRootElement.Create(file); import.AddItemDefinitionGroup().AddItemDefinition("i").AddMetadata("m", "m0"); import.Save(); ProjectRootElement main = ProjectRootElement.Create(); Project project = new Project(main); main.AddImport(file); project.ReevaluateIfNecessary(); ProjectItemDefinition definition = project.ItemDefinitions["i"]; definition.SetMetadataValue("m", "m1"); } finally { File.Delete(file); } } ); }
public void StyleCop_TargetExecutionOrder() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = rootInputFolder; properties.SonarQubeOutputPath = rootInputFolder; properties.SonarQubeConfigPath = rootOutputFolder; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); // Add some settings we expect to be ignored AddAnalysisSetting("sonar.other.setting", "other value", projectRoot); AddAnalysisSetting("sonar.other.setting.2", "other value 2", projectRoot); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.DefaultBuildTarget); // Assert logger.AssertTargetExecuted(TargetConstants.SetStyleCopSettingsTarget); logger.AssertExpectedTargetOrdering(TargetConstants.SetStyleCopSettingsTarget, TargetConstants.WriteProjectDataTarget); AssertExpectedStyleCopSetting(projectRoot.ProjectFileLocation.File, result); }
public void WithCopy() { string projectFile = Path.Combine(_rootDir, @"src\project.csproj"); ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile); projectRootElement.AddProperty(GetCopyToOutputDirectoryItemsGraphPredictor.OutDirPropertyName, @"bin\"); const bool shouldCopy = true; ProjectRootElement dep1 = CreateDependencyProject("dep1", shouldCopy); ProjectRootElement dep2 = CreateDependencyProject("dep2", shouldCopy); ProjectRootElement dep3 = CreateDependencyProject("dep3", shouldCopy); // The main project depends on 1 and 2; 2 depends on 3; 3 depends on 1. Note that this should *not* be transitive projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.proj"); dep2.AddItem("ProjectReference", @"..\dep3\dep3.proj"); dep3.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.Save(); dep1.Save(); dep2.Save(); dep3.Save(); var expectedInputFiles = new[] { new PredictedItem(@"dep1\dep1.xml", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep1\dep1.resx", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep1\dep1.cs", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep1\dep1.txt", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep1\dep1.xaml", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.xml", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.resx", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.cs", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.txt", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.xaml", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), }; var expectedOutputFiles = new[] { new PredictedItem(@"src\bin\dep1.xml", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep1.resx", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep1.cs", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep1.txt", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep1.xaml", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep2.xml", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep2.resx", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep2.cs", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep2.txt", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\dep2.xaml", nameof(GetCopyToOutputDirectoryItemsGraphPredictor)), }; new GetCopyToOutputDirectoryItemsGraphPredictor() .GetProjectPredictions(projectFile) .AssertPredictions( _rootDir, expectedInputFiles, null, expectedOutputFiles, null); }
public void UseCommonOutputDirectory() { string projectFile = Path.Combine(_rootDir, @"src\project.csproj"); ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile); projectRootElement.AddProperty(GetCopyToOutputDirectoryItemsGraphPredictor.OutDirPropertyName, @"bin\"); projectRootElement.AddProperty(GetCopyToOutputDirectoryItemsGraphPredictor.UseCommonOutputDirectoryPropertyName, "true"); const bool shouldCopy = true; ProjectRootElement dep1 = CreateDependencyProject("dep1", shouldCopy); ProjectRootElement dep2 = CreateDependencyProject("dep2", shouldCopy); ProjectRootElement dep3 = CreateDependencyProject("dep3", shouldCopy); // The main project depends on 1 and 2; 2 depends on 3; 3 depends on 1. Note that this predictor should *not* be transitive projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.proj"); dep2.AddItem("ProjectReference", @"..\dep3\dep3.proj"); dep3.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.Save(); dep1.Save(); dep2.Save(); dep3.Save(); new GetCopyToOutputDirectoryItemsGraphPredictor() .GetProjectPredictions(projectFile) .AssertNoPredictions(); }
/// <summary> /// Executes the WriteProjectInfoFile target in the the supplied project. /// The method will check the build succeeded and that a single project /// output file was created. /// </summary> /// <returns>The project info file that was created during the build</returns> private ProjectInfo ExecuteWriteProjectInfo(ProjectRootElement projectRoot, string rootOutputFolder, bool noWarningOrErrors = true) { projectRoot.Save(); // Act var result = BuildRunner.BuildTargets(TestContext, projectRoot.FullPath, // The "write" target depends on a couple of other targets having executed first to set properties appropriately TargetConstants.CategoriseProjectTarget, TargetConstants.CalculateFilesToAnalyzeTarget, TargetConstants.CreateProjectSpecificDirs, TargetConstants.WriteProjectDataTarget); // Assert result.AssertTargetSucceeded(TargetConstants.CalculateFilesToAnalyzeTarget); result.AssertTargetSucceeded(TargetConstants.CreateProjectSpecificDirs); result.AssertTargetSucceeded(TargetConstants.WriteProjectDataTarget); result.AssertTargetExecuted(TargetConstants.WriteProjectDataTarget); if (noWarningOrErrors) { result.AssertNoWarningsOrErrors(); } // Check expected project outputs Directory.EnumerateDirectories(rootOutputFolder).Should().HaveCount(1, "Only expecting one child directory to exist under the root analysis output folder"); var projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); return(projectInfo); }
public void ProjectFinishedGenerating(Project project) { string PERSISTANCE_FOLDER = "Persistance"; ProjectItem modelsFolder = Utils.GetProjectItemFolder(project, PERSISTANCE_FOLDER) .FirstOrDefault(); List <string> projectNames = Utils.GetProjectNameFromDTE(project); if (projectNames.Count() > 0) { frmAddProjectsRef addPrjRef = new frmAddProjectsRef(projectNames); System.Windows.Forms.DialogResult settingResult = addPrjRef.ShowDialog(); IEnumerable <string> selectedProjectNames = frmAddProjectsRef.GetSelectCheckListBox.SelectedItems.OfType <string>().ToArray(); ProjectRootElement projectRoot = ProjectRootElement.Open(project.FullName); foreach (var selectedPrjName in selectedProjectNames) { if (selectedPrjName != project.Name) { ProjectItemGroupElement projectGroup01 = projectRoot.AddItemGroup(); projectGroup01.AddItem("ProjectReference", $"..\\{selectedPrjName}\\{selectedPrjName}.csproj"); } } projectRoot.Save(); } // 2020/10/12 後修正為最後才產生 ApplicationDbContext 物件 Utils.CreateDbContextFromSourceTables(project, modelsFolder, projectNames); }
private ProjectRootElement CreateProject() { Microsoft.Build.Evaluation.Project project = null; try { project = Microsoft.Expression.Project.Build.BuildManager.GetProject(DocumentReference.Create(this.originalProjectFilePath)); } catch (ArgumentException argumentException) { } ProjectRootElement projectRootElement = ProjectRootElement.Create(); projectRootElement.ToolsVersion = "4.0"; this.AddBuildProperties(projectRootElement, project); projectRootElement.AddItemGroup(); projectRootElement.AddPropertyGroup(); projectRootElement.AddProperty("IntermediateOutputPath", Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath)); this.AddAssemblyReferences(projectRootElement, project); this.AddImports(projectRootElement, project); if (!this.IsSilverlightApplication(project)) { this.AddWpfImports(projectRootElement); } projectRootElement.AddItem("Page", this.xamlPath); string str = Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath), "MarkupCompileAssembly.proj"); projectRootElement.Save(str); return(projectRootElement); }
async Task ConvertProjectAsync(Project project) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); IVsSolution4 solution = await ServiceProvider.GetServiceAsync(typeof(SVsSolution)) as IVsSolution4; ProjectRootElement projectRoot = ProjectRootElement.Open(project.FullName); var projectData = ReadProjectData(projectRoot); projectData.FilePath = Path.GetDirectoryName(project.FullName); projectData.AssemblyVersion = project.Properties.Item(Constants.AssemblyVersion)?.Value.ToString(); UnloadProject(solution, projectData.ProjectGuid); DeleteCSProjContents(projectRoot); UpdateCSProjContents(projectRoot, projectData); projectRoot.Save(); UpdateAssemblyInfo(projectData.FilePath); ReloadProject(solution, projectData.ProjectGuid); }
private bool TryWriteProjectsFile(ProjectCollection projectCollection, FileInfo projectsFile) { Log.LogMessageFromText($"Generating file '{projectsFile.FullName}'", MessageImportance.Low); Directory.CreateDirectory(projectsFile.DirectoryName); ProjectRootElement rootElement = ProjectRootElement.Create(projectsFile.FullName); ProjectItemGroupElement projectFileItemGroup = rootElement.AddItemGroup(); ProjectItemGroupElement traversalFileItemGroup = rootElement.AddItemGroup(); foreach (Project project in projectCollection.LoadedProjects) { if (String.Equals(project.GetPropertyValue("IsTraversal"), "true", StringComparison.OrdinalIgnoreCase)) { traversalFileItemGroup.AddItem("TraversalFile", project.FullPath); } else { projectFileItemGroup.AddItem("ProjectFile", project.FullPath); } } rootElement.Save(); return(true); }
public void InvalidSaveWithoutFullPath() { XmlReader reader = XmlReader.Create(new StringReader("<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\"/>")); ProjectRootElement project = ProjectRootElement.Create(reader); project.Save(); }
public void StyleCop_ValueAlreadySet() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = rootInputFolder; properties.SonarQubeOutputPath = rootInputFolder; properties.SonarQubeConfigPath = rootOutputFolder; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); // Apply some SonarQubeSettings, one of which specifies the StyleCop setting AddAnalysisSetting("sonar.other.setting", "other value", projectRoot); AddAnalysisSetting(TargetConstants.StyleCopProjectPathItemName, "xxx.yyy", projectRoot); AddAnalysisSetting("sonar.other.setting.2", "other value 2", projectRoot); projectRoot.Save(); BuildLogger logger = new BuildLogger(); BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.SetStyleCopSettingsTarget); // Assert logger.AssertTargetExecuted(TargetConstants.SetStyleCopSettingsTarget); AssertExpectedStyleCopSetting("xxx.yyy", result); }
public void GetProjectRootElementChangedOnDisk2() { string path = null; try { ProjectRootElementCache cache = new ProjectRootElementCache(false /* do not auto reload from disk */); path = FileUtilities.GetTemporaryFile(); ProjectRootElement xml0 = ProjectRootElement.Create(path); xml0.Save(); cache.AddEntry(xml0); ProjectRootElement xml1 = cache.TryGet(path); Assert.AreEqual(true, Object.ReferenceEquals(xml0, xml1)); File.SetLastWriteTime(path, DateTime.Now + new TimeSpan(1, 0, 0)); ProjectRootElement xml2 = cache.TryGet(path); Assert.AreEqual(true, Object.ReferenceEquals(xml0, xml2)); } finally { File.Delete(path); } }
public void SaveWithTransformsToFile() { ProjectRootElement project = ProjectRootElement.Create(); project.AddItem("i", "@(h->'%(x)')"); string file = null; try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); project.Save(file); string expected = ObjectModelHelpers.CleanupFileContents( @"<?xml version=""1.0"" encoding=""utf-8""?> <Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""@(h->'%(x)')"" /> </ItemGroup> </Project>"); string actual = File.ReadAllText(file); Helpers.VerifyAssertLineByLine(expected, actual); } finally { File.Delete(file); } }
private static string ProjectXmlToString(ProjectRootElement projectXml) { using var writer = new StringWriterWithUtf8Encoding(); projectXml.Save(writer); return(writer.ToString()); }
public static void AddTargetsFileToOldProjects(VCProject vcProject) { string projectFilePath = vcProject.ProjectFile; ProjectRootElement projectRootElement = ProjectRootElement.Open(projectFilePath); ICollection <ProjectImportElement> imports = projectRootElement.Imports; ProjectPropertyGroupElement userMacrosPropertyGroup = projectRootElement.PropertyGroups.Where(g => g.Label.Equals("UserMacros")).FirstOrDefault(); ProjectImportElement userFileImport = imports.Where(i => i.Project.Equals("$(VCTargetsPath)\\Microsoft.Cpp.targets")).FirstOrDefault(); if (userMacrosPropertyGroup != null && !userMacrosPropertyGroup.NextSibling.Equals(userFileImport)) { projectRootElement.RemoveChild(userFileImport); projectRootElement.InsertAfterChild(userFileImport, userMacrosPropertyGroup); //delete all occurences of PLCnCLIIncludes and PLCnCLIMacros -> saved in .users file now IEnumerable <ProjectPropertyElement> elementsToDelete = projectRootElement.PropertyGroups .Where(g => g.Label.Equals("Configuration")) .SelectMany(g => g.Properties .Where(p => p.Name.Equals("PLCnCLIMacros") || p.Name.Equals("PLCnCLIIncludes"))); elementsToDelete.ToList().ForEach(e => e.Parent.RemoveChild(e)); MessageBox.Show("The project file needs to be updated outside of the environment. Please choose 'Reload all...' in the next dialog.", "Project update needed", MessageBoxButton.OK, MessageBoxImage.Exclamation); projectRootElement.Save(); } }
public void WriteProjectInfo_AnalysisFileList_FilesTypes_SpecifiedPlusDefaults() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); ProjectDescriptor descriptor = BuildUtilities.CreateValidProjectDescriptor(rootInputFolder, "fileTypes.proj.txt"); ProjectRootElement projectRoot = CreateInitializedProject(descriptor, new WellKnownProjectProperties(), rootOutputFolder); // Files we don't expect to be included by default string fooType1 = AddFileToProject(projectRoot, "fooType", sonarQubeExclude: null); string xxxType1 = AddFileToProject(projectRoot, "xxxType", sonarQubeExclude: null); AddFileToProject(projectRoot, "barType", sonarQubeExclude: null); // Files we'd normally expect to be included by default string managed1 = AddFileToProject(projectRoot, TargetProperties.ItemType_Compile, sonarQubeExclude: null); string content1 = AddFileToProject(projectRoot, TargetProperties.ItemType_Content, sonarQubeExclude: null); // Update the "item types" property to add some extra item type // NB this has to be done *after* the integration targets have been imported ProjectPropertyGroupElement group = projectRoot.CreatePropertyGroupElement(); projectRoot.AppendChild(group); group.AddProperty("SQAnalysisFileItemTypes", "fooType;$(SQAnalysisFileItemTypes);xxxType"); projectRoot.Save(); // Act ProjectInfo projectInfo = ExecuteWriteProjectInfo(projectRoot, rootOutputFolder); // Assert AssertResultFileExists(projectInfo, AnalysisType.FilesToAnalyze, fooType1, xxxType1, content1, managed1); }
public void SettingConditionDirties() { string file = null; try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); ProjectRootElement importProject = ProjectRootElement.Create(); importProject.AddProperty("p", "v1"); importProject.Save(file); string content = String.Format ( @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' > <Import Project='{0}'/> </Project>", file ); Project project = new Project(XmlReader.Create(new StringReader(content))); ProjectImportElement import = Helpers.GetFirst(project.Xml.Imports); import.Condition = "false"; Assert.Equal("v1", project.GetPropertyValue("p")); project.ReevaluateIfNecessary(); Assert.Equal(String.Empty, project.GetPropertyValue("p")); } finally { File.Delete(file); } }
/// <summary> /// Executes the WriteProjectInfoFile target in the the supplied project. /// The method will check the build succeeded and that a single project /// output file was created. /// </summary> /// <returns>The project info file that was created during the build</returns> private ProjectInfo ExecuteWriteProjectInfo(ProjectRootElement projectRoot, string rootOutputFolder, bool noWarningOrErrors = true) { projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, // The "write" target depends on a couple of other targets having executed first to set properties appropriately TargetConstants.CategoriseProjectTarget, TargetConstants.CalculateFilesToAnalyzeTarget, TargetConstants.CreateProjectSpecificDirs, TargetConstants.WriteProjectDataTarget); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.CalculateFilesToAnalyzeTarget); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.CreateProjectSpecificDirs); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.WriteProjectDataTarget); logger.AssertTargetExecuted(TargetConstants.WriteProjectDataTarget); if (noWarningOrErrors) { logger.AssertNoWarningsOrErrors(); } // Check expected project outputs Assert.AreEqual(1, Directory.EnumerateDirectories(rootOutputFolder).Count(), "Only expecting one child directory to exist under the root analysis output folder"); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); return(projectInfo); }
public override bool Execute() { ProjectRootElement project = ProjectRootElement.Create(); CreateRuntimeIdentifier(project); project.Save(RuntimePropsFilePath); return(!Log.HasLoggedErrors); }
public void SaveUnnamedProject() { Assert.Throws <InvalidOperationException>(() => { ProjectRootElement project = ProjectRootElement.Create(); project.Save(); } ); }
// TEMPORARY WORKAROUND // https://github.com/dotnet/roslyn/issues/36781 // Adding documents to a project can result in extra "<include Compile=...>" items // since Roslyn always adds an explicit include regardless of whether the new file // would be picked up by a globbing pattern. Until that is fixed, this workaround // cleans up extra explicit include items that duplicate globbing patterns. internal static void WorkAroundRoslynIssue36781(this ProjectRootElement rootElement) { if (rootElement is null) { throw new ArgumentNullException(nameof(rootElement)); } using var projectCollection = new ProjectCollection(); var project = projectCollection.LoadProject(rootElement.FullPath); // Find duplicate items in the project var duplicateItems = project.Items.Where(i => { // Only consider items that are added explicitly (not via a globbing pattern) if (!i.EvaluatedInclude.Equals(i.UnevaluatedInclude, StringComparison.Ordinal)) { return(false); } // Only consider compile or content items if (!ItemTypesToDeduplicate.Contains(i.ItemType, StringComparer.OrdinalIgnoreCase)) { return(false); } // Skip items that are only included once if (project.Items.Count(i2 => i2.EvaluatedInclude.Equals(i.EvaluatedInclude, StringComparison.Ordinal)) <= 1) { return(false); } return(true); }); if (duplicateItems.Any()) { foreach (var projectItem in duplicateItems) { // For any duplcate items, find them in the project root element and remove them foreach (var item in rootElement.Items.Where(i => i.Include.Equals(projectItem.EvaluatedInclude, StringComparison.Ordinal))) { var parent = item.Parent; parent.RemoveChild(item); // If that item was the only child of its parent itemGroup, // remove the parent, too if (!parent.Children.Any()) { parent.Parent.RemoveChild(parent); } } } rootElement.Save(); } }
async Task ConvertProjectAsync(Project project) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); await DeleteProjectItemAsync(project, "Web.Config"); //await DeleteProjectItemAsync(project, "Web.Debug.config"); //await DeleteProjectItemAsync(project, "Web.Release.config"); await DeleteProjectItemAsync(project, "packages.config"); //await DeleteProjectItemAsync(project, "Global.asax.cs"); await DeleteProjectItemAsync(project, "Global.asax"); await DeleteProjectItemAsync(project, "App_Start"); await DeleteProjectItemAsync(project, "Properties"); await DeleteProjectItemAsync(project, "Views"); //await DeleteProjectItemAsync(project, "RouteConfig.cs"); //await DeleteProjectItemAsync(project, "WebApiConfig.cs"); //var resultAll = prjItems.OfType<ProjectItem>().Select(c => c); //var test1 = resultAll.Where(c => //{ // Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); // return c.Name.ToLower() == "packages.config"; //}) //.FirstOrDefault(); //test1.Remove(); IVsSolution4 solution = await ServiceProvider.GetServiceAsync(typeof(SVsSolution)) as IVsSolution4; ProjectRootElement projectRoot = ProjectRootElement.Open(project.FullName); //建立 .NET Core 相關檔案 await CreateProjectItemAsync(project, "startup.cs", projectRoot.PropertyGroups.FirstOrDefault()); await CreateProjectItemAsync(project, "program.cs", projectRoot.PropertyGroups.FirstOrDefault()); await CreateProjectItemAsync(project, "appsettings.json", projectRoot.PropertyGroups.FirstOrDefault()); var projectData = ReadProjectData(projectRoot); projectData.FilePath = Path.GetDirectoryName(project.FullName); projectData.AssemblyVersion = project.Properties.Item(Constants.AssemblyVersion)?.Value.ToString(); UnloadProject(solution, projectData.ProjectGuid); DeleteCSProjContents(projectRoot); UpdateCSProjectFolders(projectRoot); UpdateCSProjContents(projectRoot, projectData); projectRoot.Save(); //UpdateAssemblyInfo(projectData.FilePath); ReloadProject(solution, projectData.ProjectGuid); }
public void E2E_FxCop_AllConditionsMet_VB() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.RunCodeAnalysis = "false"; preImportProperties.CodeAnalysisLogFile = fxCopLogFile; preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset"; preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder; CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "vbnet")); ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties, isVBProject: true); string itemPath = TestUtils.CreateTextFile(rootInputFolder, "my.vb", @"Public Class Class1 Public Sub DoStuff() End Sub End Class"); projectRoot.AddItem(TargetProperties.ItemType_Compile, itemPath); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertExpectedTargetOrdering( TargetConstants.DetectFxCopRulesetTarget, TargetConstants.CategoriseProjectTarget, TargetConstants.OverrideFxCopSettingsTarget, TargetConstants.FxCopTarget, TargetConstants.SetFxCopResultsTarget, TargetConstants.DefaultBuildTarget, TargetConstants.CalculateFilesToAnalyzeTarget, TargetConstants.WriteProjectDataTarget); AssertAllFxCopTargetsExecuted(logger); Assert.IsTrue(File.Exists(fxCopLogFile), "FxCop log file should have been produced"); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); ProjectInfoAssertions.AssertAnalysisResultExists(projectInfo, AnalysisType.FxCop.ToString(), fxCopLogFile); }
public static string SaveAndGetChanges(this ProjectRootElement root) { var tempFile = Path.GetTempFileName(); root.Save(tempFile); var result = File.ReadAllText(tempFile); File.Delete(tempFile); return(result); }
private void AddCaptureTargetsImport(string projectFolder, ProjectRootElement projectRoot) { // Add an additional import that will dump data we are interested in to the build log var captureTargetsFilePath = CreateCaptureDataTargetsFile(projectFolder); var captureTarget = projectRoot.AddImport(captureTargetsFilePath); var projectFilePath = Path.Combine(projectFolder, "valid.project.proj"); projectRoot.Save(projectFilePath); }
public void ConstructOverSameFileReturnsSame() { ProjectRootElement projectXml1 = ProjectRootElement.Create(); projectXml1.Save(Microsoft.Build.Shared.FileUtilities.GetTemporaryFile()); ProjectRootElement projectXml2 = ProjectRootElement.Open(projectXml1.FullPath); Assert.AreEqual(true, Object.ReferenceEquals(projectXml1, projectXml2)); }
public void Save(string filePath) { _autoPackageVersions.RemoveAllChildren(); foreach (var item in _versionVariables.Values.Where(v => !v.IsReadOnly).OrderBy(v => v.Name)) { item.AddToGroup(_autoPackageVersions); } _document.Save(filePath, Encoding.UTF8); }
public void E2E_FxCop_NoFilesToAnalyse() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.RunCodeAnalysis = "false"; preImportProperties.CodeAnalysisLogFile = fxCopLogFile; preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset"; preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder; CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "cs")); ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); // Add some files to the project string itemPath = CreateTextFile(rootInputFolder, "content1.txt", "aaaa"); projectRoot.AddItem("Content", itemPath); itemPath = CreateTextFile(rootInputFolder, "code1.cs", "class myclassXXX{} // wrong item type"); projectRoot.AddItem("CompileXXX", itemPath); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertExpectedTargetOrdering( TargetConstants.CategoriseProjectTarget, TargetConstants.OverrideFxCopSettingsTarget, TargetConstants.FxCopTarget, TargetConstants.SetFxCopResultsTarget, // should set the FxCop results after the platform "run Fx Cop" target TargetConstants.DefaultBuildTarget, TargetConstants.CalculateFilesToAnalyzeTarget, TargetConstants.WriteProjectDataTarget); logger.AssertTargetExecuted(TargetConstants.SetFxCopResultsTarget); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); ProjectInfoAssertions.AssertAnalysisResultDoesNotExists(projectInfo, AnalysisType.FxCop.ToString()); }
public void ImportWithRelativePath() { string tempPath = Path.GetTempPath(); string testTempPath = Path.Combine(tempPath, "UnitTestsPublicOm"); string projectfile = Path.Combine(testTempPath, "a.proj"); string targetsFile = Path.Combine(tempPath, "x.targets"); string projectfileContent = String.Format ( @" <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' > <Import Project='{0}'/> </Project> ", testTempPath + "\\..\\x.targets" ); string targetsfileContent = @" <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' > </Project> "; try { Directory.CreateDirectory(testTempPath); ProjectRootElement project = ProjectRootElement.Create(XmlReader.Create(new StringReader(projectfileContent))); project.Save(projectfile); project = ProjectRootElement.Create(XmlReader.Create(new StringReader(targetsfileContent))); project.Save(targetsFile); Project msbuildProject = new Project(projectfile); } finally { if (Directory.Exists(testTempPath)) { FileUtilities.DeleteWithoutTrailingBackslash(testTempPath, true); } if (File.Exists(targetsFile)) { File.Delete(targetsFile); } } }
public void E2E_FxCop_TestProject_TestProjectTypeGuid() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.CodeAnalysisLogFile = fxCopLogFile; preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset"; preImportProperties.ProjectTypeGuids = "X;" + TargetConstants.MsTestProjectTypeGuid.ToUpperInvariant() + ";Y"; preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder; CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "cs")); ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); // Add a file to the project string itemPath = CreateTextFile(rootInputFolder, "code1.cs", "class myclassXXX{}"); projectRoot.AddItem(TargetProperties.ItemType_Compile, itemPath); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertExpectedTargetOrdering( TargetConstants.CategoriseProjectTarget, TargetConstants.OverrideFxCopSettingsTarget, TargetConstants.FxCopTarget, TargetConstants.DefaultBuildTarget, TargetConstants.CalculateFilesToAnalyzeTarget, TargetConstants.WriteProjectDataTarget); // We expect the FxCop target to be executed... logger.AssertTargetExecuted(TargetConstants.FxCopTarget); // ... but we don't expect the FxCop *task* to have executed logger.AssertTaskNotExecuted(TargetConstants.FxCopTask); logger.AssertTargetNotExecuted(TargetConstants.SetFxCopResultsTarget); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); ProjectInfoAssertions.AssertAnalysisResultDoesNotExists(projectInfo, AnalysisType.FxCop.ToString()); }