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