public void NoCopy()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
projectRootElement.AddProperty(NoneItemsPredictor.OutDirPropertyName, @"bin\");
projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource1.resx");
projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource2.resx");
projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource3.resx");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem("Resource1.resx", nameof(EmbeddedResourceItemsPredictor)),
new PredictedItem("Resource2.resx", nameof(EmbeddedResourceItemsPredictor)),
new PredictedItem("Resource3.resx", nameof(EmbeddedResourceItemsPredictor)),
};
new EmbeddedResourceItemsPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles,
null,
null,
null);
}
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.AreEqual("v1", project.GetPropertyValue("p"));
project.ReevaluateIfNecessary();
Assert.AreEqual(String.Empty, project.GetPropertyValue("p"));
}
finally
{
File.Delete(file);
}
}
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);
}
public void ImportGroupFalseCondition()
{
ProjectRootElement xml1 = ProjectRootElement.Create("p1");
xml1.AddProperty("p", "v1");
xml1.AddImportGroup().AddImport("p2");
xml1.LastChild.Condition = "false";
ProjectRootElement xml2 = ProjectRootElement.Create("p2");
xml2.AddProperty("p", "v2");
Project project = new Project(xml1);
StringWriter writer = new StringWriter();
project.SaveLogicalProject(writer);
string expected = ObjectModelHelpers.CleanupFileContents(
@"<?xml version=""1.0"" encoding=""utf-16""?>
<!--
============================================================================================================================================
" + CurrentDirectoryXmlCommentFriendly + Path.DirectorySeparatorChar + @"p1
============================================================================================================================================
-->
<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<PropertyGroup>
<p>v1</p>
</PropertyGroup>
<!--<ImportGroup Condition=""false"">-->
<!--<Import Project=""p2"" />-->
<!--</ImportGroup>-->
</Project>");
Helpers.VerifyAssertLineByLine(expected, writer.ToString());
}
public void WriteProjectInfo_AnalysisFileList_FilesTypes_Defaults()
{
// Check that all default item types are included for analysis
// 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
AddFileToProject(projectRoot, "fooType");
AddFileToProject(projectRoot, "barType");
// Files we expect to be included by default
string managed1 = AddFileToProject(projectRoot, TargetProperties.ItemType_Compile, sonarQubeExclude: null);
string content1 = AddFileToProject(projectRoot, TargetProperties.ItemType_Content, sonarQubeExclude: null);
string embedded1 = AddFileToProject(projectRoot, "EmbeddedResource", sonarQubeExclude: null);
string none1 = AddFileToProject(projectRoot, "None", sonarQubeExclude: null);
string nativeCompile1 = AddFileToProject(projectRoot, "ClCompile", sonarQubeExclude: null);
string page1 = AddFileToProject(projectRoot, "Page", sonarQubeExclude: null);
string typeScript1 = AddFileToProject(projectRoot, "TypeScriptCompile", sonarQubeExclude: null);
// Act
ProjectInfo projectInfo = ExecuteWriteProjectInfo(projectRoot, rootOutputFolder);
// Assert
AssertResultFileExists(projectInfo, AnalysisType.FilesToAnalyze, managed1, content1, embedded1, none1, nativeCompile1, page1, typeScript1);
projectRoot.AddProperty("SQAnalysisFileItemTypes", "$(SQAnalysisFileItemTypes);fooType;barType;");
}
public void WithCopy()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
projectRootElement.AddProperty(XamlAppDefPredictor.OutDirPropertyName, @"bin\");
projectRootElement.AddItem(XamlAppDefPredictor.XamlAppDefItemName, "Foo.xaml")
.AddMetadata("CopyToOutputDirectory", "PreserveNewest");
projectRootElement.AddItem(XamlAppDefPredictor.XamlAppDefItemName, "Bar.xaml")
.AddMetadata("CopyToOutputDirectory", "Always");
projectRootElement.AddItem(XamlAppDefPredictor.XamlAppDefItemName, "Baz.xaml")
.AddMetadata("CopyToOutputDirectory", "Never");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem("Foo.xaml", nameof(XamlAppDefPredictor)),
new PredictedItem("Bar.xaml", nameof(XamlAppDefPredictor)),
new PredictedItem("Baz.xaml", nameof(XamlAppDefPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"bin\Foo.xaml", nameof(XamlAppDefPredictor)),
new PredictedItem(@"bin\Bar.xaml", nameof(XamlAppDefPredictor)),
};
new XamlAppDefPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles,
null,
expectedOutputFiles,
null);
}
public void WriteProjectInfo_AnalysisFileList_FilesTypes_OnlySpecified()
{
// 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
AddFileToProject(projectRoot, TargetProperties.ItemType_Compile, sonarQubeExclude: null);
AddFileToProject(projectRoot, TargetProperties.ItemType_Content, sonarQubeExclude: null);
projectRoot.AddProperty("SQAnalysisFileItemTypes", "fooType;xxxType");
// Act
ProjectInfo projectInfo = ExecuteWriteProjectInfo(projectRoot, rootOutputFolder);
// Assert
AssertResultFileExists(projectInfo, AnalysisType.FilesToAnalyze, fooType1, xxxType1);
}
public void NoCopy()
{
string projectFile = Path.Combine(_rootDir, @"src\project.csproj");
ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile);
projectRootElement.AddProperty(ContentItemsPredictor.OutDirPropertyName, @"bin\");
const bool shouldCopy = false;
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();
}
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);
}
private static Project CreateTestProject(string outDir, string outputPath)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
if (outDir != null)
{
projectRootElement.AddProperty(OutDirOrOutputPathIsOutputDir.OutDirMacro, outDir);
}
if (outputPath != null)
{
projectRootElement.AddProperty(OutDirOrOutputPathIsOutputDir.OutputPathMacro, outputPath);
}
return(TestHelpers.CreateProjectFromRootElement(projectRootElement));
}
public void FindItemsForClickOnceWithBaseApplicationManifests()
{
ProjectRootElement projectRootElement = CreateProjectRootElement();
// This is generally set by the toolset for certain output types
projectRootElement.AddProperty(ManifestsPredictor.GenerateClickOnceManifestsPropertyName, "true");
projectRootElement.AddItem(ManifestsPredictor.BaseApplicationManifestItemName, @"Properties\app.manifest");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem(@"Properties\app.manifest", nameof(ManifestsPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"obj\Release\MyApplication.exe.manifest", nameof(ManifestsPredictor)),
new PredictedItem(@"bin\Release\MyApplication.exe.manifest", nameof(ManifestsPredictor)),
new PredictedItem(@"obj\Release\MyApplication.application", nameof(ManifestsPredictor)),
new PredictedItem(@"bin\Release\MyApplication.application", nameof(ManifestsPredictor)),
};
new ManifestsPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles.MakeAbsolute(_rootDir),
null,
expectedOutputFiles.MakeAbsolute(_rootDir),
null);
}
public void Roslyn_Settings_TempFolderIsNotSet()
{
// Arrange
BuildLogger logger = new BuildLogger();
WellKnownProjectProperties properties = new WellKnownProjectProperties();
properties.ErrorLog = "pre-existing.log";
properties.ResolvedCodeAnalysisRuleset = "pre-existing.ruleset";
properties.WarningsAsErrors = "CS101";
properties.TreatWarningsAsErrors = "true";
ProjectRootElement projectRoot = CreateValidProjectSetup(properties);
projectRoot.AddProperty(TargetProperties.SonarQubeTempPath, string.Empty); // needs to overwritten once the valid project has been created
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget);
// Assert
logger.AssertTargetNotExecuted(TargetConstants.OverrideRoslynAnalysisTarget);
logger.AssertTargetNotExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget);
// Existing properties should not be changed
AssertExpectedErrorLog(result, "pre-existing.log");
AssertExpectedResolvedRuleset(result, "pre-existing.ruleset");
BuildAssertions.AssertExpectedItemGroupCount(result, TargetProperties.AnalyzerItemType, 0);
BuildAssertions.AssertExpectedItemGroupCount(result, TargetProperties.AdditionalFilesItemType, 0);
BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, TargetProperties.TreatWarningsAsErrors, "true");
BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, TargetProperties.WarningsAsErrors, "CS101");
}
public void OutputFileNamesWithoutVersion()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
projectRootElement.AddProperty(GeneratePackageOnBuildPredictor.GeneratePackageOnBuildPropertyName, "true");
projectRootElement.AddProperty(GeneratePackageOnBuildPredictor.PackageIdPropertyName, "SomePackage");
projectRootElement.AddProperty(GeneratePackageOnBuildPredictor.PackageVersionPropertyName, "1.2.3");
projectRootElement.AddProperty(GeneratePackageOnBuildPredictor.OutputPathPropertyName, "bin");
projectRootElement.AddProperty(GeneratePackageOnBuildPredictor.NuspecOutputPathPropertyName, "obj");
projectRootElement.AddProperty(GeneratePackageOnBuildPredictor.SymbolPackageFormatPropertyName, "symbols.nupkg");
projectRootElement.AddProperty(GeneratePackageOnBuildPredictor.OutputFileNamesWithoutVersionPropertyName, "true");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedOutputFiles = new[]
{
new PredictedItem(@"obj\SomePackage.nuspec", nameof(GeneratePackageOnBuildPredictor)),
new PredictedItem(@"bin\SomePackage.nupkg", nameof(GeneratePackageOnBuildPredictor)),
};
new GeneratePackageOnBuildPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
null,
null,
expectedOutputFiles,
null);
}
/// <summary>
/// Create a build file that build the projects in the specified order
/// </summary>
/// <param name="buildFilePath"></param>
/// <param name="projectList"></param>
/// <returns></returns>
public static bool CreateBuildFile(string buildFilePath, List <string> projectList)
{
ProjectRootElement proj = ProjectRootElement.Create(buildFilePath);
proj.AddProperty("Configuration", "Release");
proj.AddProperty("Platform", "x86");
ProjectTargetElement trgt = proj.AddTarget("Build");
foreach (string p in projectList)
{
ProjectTaskElement task = trgt.AddTask("MSBuild");
task.SetParameter("Projects", p);
}
proj.Save();
return(true);
}
/// <summary>
/// Creates and returns a minimal C# or VB project file that can be built.
/// The project imports the C#/VB targets and any other optional targets that are specified.
/// The project is NOT saved.
/// </summary>
/// <param name="preImportProperties">Any properties that need to be set before the C# targets are imported. Can be null.</param>
/// <param name="importsBeforeTargets">Any targets that should be imported before the C# targets are imported. Optional.</param>
public static ProjectRootElement CreateMinimalBuildableProject(IDictionary <string, string> preImportProperties, bool isVBProject, params string[] importsBeforeTargets)
{
ProjectRootElement root = ProjectRootElement.Create();
foreach (string importTarget in importsBeforeTargets)
{
Assert.IsTrue(File.Exists(importTarget), "Test error: the specified target file does not exist. Path: {0}", importTarget);
root.AddImport(importTarget);
}
if (preImportProperties != null)
{
foreach (KeyValuePair <string, string> kvp in preImportProperties)
{
root.AddProperty(kvp.Key, kvp.Value);
}
}
// Ensure the output path is set
if (preImportProperties == null || !preImportProperties.ContainsKey("OutputPath"))
{
root.AddProperty("OutputPath", @"bin\");
}
// Ensure the language is set
if (preImportProperties == null || !preImportProperties.ContainsKey("Language"))
{
root.AddProperty("Language", isVBProject ? "VB" : "C#");
}
// Import the standard Microsoft targets
if (isVBProject)
{
root.AddImport("$(MSBuildToolsPath)\\Microsoft.VisualBasic.targets");
}
else
{
root.AddImport("$(MSBuildToolsPath)\\Microsoft.CSharp.targets");
}
root.AddProperty("OutputType", "library"); // build a library so we don't need a Main method
return(root);
}
public void SigningDisabled()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create("project.csproj");
projectRootElement.AddProperty(AssemblyOriginatorKeyFilePredictor.AssemblyOriginatorKeyFilePropertyName, "StrongNaming.snk");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
new AssemblyOriginatorKeyFilePredictor()
.GetProjectPredictions(projectInstance)
.AssertNoPredictions();
}
public void SetCondition()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectPropertyElement property = project.AddProperty("p", "v1");
Helpers.ClearDirtyFlag(property.ContainingProject);
property.Condition = "c";
Assert.Equal("c", property.Condition);
Assert.Equal(true, property.ContainingProject.HasUnsavedChanges);
}
public void SetSameValue()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectPropertyElement property = project.AddProperty("p", "v1");
Helpers.ClearDirtyFlag(property.ContainingProject);
property.Value = "v1";
Assert.Equal("v1", property.Value);
Assert.Equal(false, property.ContainingProject.HasUnsavedChanges);
}
public void NoKeyFile()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create("project.csproj");
projectRootElement.AddProperty(AssemblyOriginatorKeyFilePredictor.SignAssemblyPropertyName, "true");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
new AssemblyOriginatorKeyFilePredictor()
.GetProjectPredictions(projectInstance)
.AssertNoPredictions();
}
private static ProjectInstance CreateTestProjectInstance(string intermediateOutDir)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
if (intermediateOutDir != null)
{
projectRootElement.AddProperty(IntermediateOutputPathPredictor.IntermediateOutputPathMacro, intermediateOutDir);
}
return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement));
}
public void FindItems()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create("project.csproj");
projectRootElement.AddProperty(AssemblyOriginatorKeyFilePredictor.SignAssemblyPropertyName, "true");
projectRootElement.AddProperty(AssemblyOriginatorKeyFilePredictor.AssemblyOriginatorKeyFilePropertyName, "StrongNaming.snk");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem("StrongNaming.snk", nameof(AssemblyOriginatorKeyFilePredictor)),
};
new AssemblyOriginatorKeyFilePredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles,
null,
null,
null);
}
public static void SetProperty(this ProjectRootElement prel, string name, string value)
{
var existing = prel.PropertyGroups.SelectMany(g => g.Properties).FirstOrDefault(p => p.Name == name);
if (existing != null)
{
existing.Value = value;
}
else
{
prel.AddProperty(name, value);
}
}
public void FindItemsWithAddinPaths()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"project.csproj"));
projectRootElement.AddProperty(StyleCopPredictor.StyleCopEnabledPropertyName, "true");
projectRootElement.AddProperty(StyleCopPredictor.StyleCopOutputFilePropertyName, @"bin\x64\StyleCopViolations.xml");
projectRootElement.AddTarget(StyleCopPredictor.StyleCopTargetName);
projectRootElement.AddItem(StyleCopPredictor.StyleCopAdditionalAddinPathsItemName, @"addinPaths\1");
projectRootElement.AddItem(StyleCopPredictor.StyleCopAdditionalAddinPathsItemName, @"addinPaths\2");
projectRootElement.AddItem(StyleCopPredictor.StyleCopAdditionalAddinPathsItemName, @"addinPaths\3");
projectRootElement.AddItem(StyleCopPredictor.StyleCopAdditionalAddinPathsItemName, @"addinPaths\doesNotExist"); // Will be excluded
Directory.CreateDirectory(Path.Combine(_rootDir, @"addinPaths\1"));
Directory.CreateDirectory(Path.Combine(_rootDir, @"addinPaths\2"));
Directory.CreateDirectory(Path.Combine(_rootDir, @"addinPaths\3"));
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputDirectories = new[]
{
new PredictedItem(@"addinPaths\1", nameof(StyleCopPredictor)),
new PredictedItem(@"addinPaths\2", nameof(StyleCopPredictor)),
new PredictedItem(@"addinPaths\3", nameof(StyleCopPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"bin\x64\StyleCopViolations.xml", nameof(StyleCopPredictor)),
};
new StyleCopPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
null,
expectedInputDirectories.MakeAbsolute(_rootDir),
expectedOutputFiles.MakeAbsolute(_rootDir),
null);
}
public void ImportGroup()
{
ProjectRootElement xml1 = ProjectRootElement.Create("p1");
xml1.AddProperty("p", "v1");
xml1.AddImportGroup().AddImport("p2");
ProjectRootElement xml2 = ProjectRootElement.Create("p2");
xml2.AddProperty("p", "v2");
Project project = new Project(xml1);
StringWriter writer = new StringWriter();
project.SaveLogicalProject(writer);
string expected = ObjectModelHelpers.CleanupFileContents(
@"<?xml version=""1.0"" encoding=""utf-16""?>
<!--
============================================================================================================================================
" + Directory.GetCurrentDirectory() + @"\p1
============================================================================================================================================
-->
<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<PropertyGroup>
<p>v1</p>
</PropertyGroup>
<!--<ImportGroup>-->
<!--
============================================================================================================================================
<Import Project=""p2"">
" + Directory.GetCurrentDirectory() + @"\p2
============================================================================================================================================
-->
<PropertyGroup>
<p>v2</p>
</PropertyGroup>
<!--
============================================================================================================================================
</Import>
" + Directory.GetCurrentDirectory() + @"\p1
============================================================================================================================================
-->
<!--</ImportGroup>-->
</Project>");
Helpers.VerifyAssertLineByLine(expected, writer.ToString());
}
public void SkipOtherProjectTypes()
{
string projectFile = Path.Combine(_rootDir, @"src\project.csproj");
ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile);
projectRootElement.AddProperty(ServiceFabricPackageRootFilesGraphPredictor.ServicePackageRootFolderPropertyName, "PackageRoot");
projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.csproj");
projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.csproj");
projectRootElement.AddItem("ProjectReference", @"..\dep3\dep3.csproj");
projectRootElement.AddItem("ProjectReference", @"..\dep4\dep4.csproj");
// Content package file
string dependency1File = Path.Combine(_rootDir, @"dep1\dep1.csproj");
ProjectRootElement dependency1RootElement = ProjectRootElement.Create(dependency1File);
dependency1RootElement.AddItem(ContentItemsPredictor.ContentItemName, @"PackageRoot\Config\Settings.xml");
Directory.CreateDirectory(Path.Combine(_rootDir, @"dep1\PackageRoot"));
// None package file
string dependency2File = Path.Combine(_rootDir, @"dep2\dep2.csproj");
ProjectRootElement dependency2RootElement = ProjectRootElement.Create(dependency2File);
dependency2RootElement.AddItem(NoneItemsPredictor.NoneItemName, @"PackageRoot\Config\Settings.xml");
Directory.CreateDirectory(Path.Combine(_rootDir, @"dep2\PackageRoot"));
// Linked package file
string dependency3File = Path.Combine(_rootDir, @"dep3\dep3.csproj");
ProjectRootElement dependency3RootElement = ProjectRootElement.Create(dependency3File);
dependency3RootElement.AddItem(ContentItemsPredictor.ContentItemName, @"..\dep3_linked\PackageRoot\Config\Settings.xml")
.AddMetadata("Link", @"PackageRoot\Config\Settings.xml");
Directory.CreateDirectory(Path.Combine(_rootDir, @"dep3\PackageRoot"));
// Package file on disk
string dependency4File = Path.Combine(_rootDir, @"dep4\dep4.csproj");
ProjectRootElement dependency4RootElement = ProjectRootElement.Create(dependency4File);
Directory.CreateDirectory(Path.Combine(_rootDir, @"dep4\PackageRoot\Config"));
File.WriteAllText(Path.Combine(_rootDir, @"dep4\PackageRoot\Config\Settings.xml"), "dummy");
projectRootElement.Save();
dependency1RootElement.Save();
dependency2RootElement.Save();
dependency3RootElement.Save();
dependency4RootElement.Save();
new ServiceFabricPackageRootFilesGraphPredictor()
.GetProjectPredictions(projectFile)
.AssertNoPredictions();
}
protected static void AddOrSetProperty(ProjectRootElement project, string name, string value)
{
bool anySet = false;
foreach (var prop in project.Properties.Where(p => p.Name == name))
{
prop.Value = value;
anySet = true;
}
if (!anySet)
{
project.AddProperty(name, value);
}
}
public void FindItemsWithNoSettingsFile()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"project.csproj"));
projectRootElement.AddProperty(StyleCopPredictor.StyleCopEnabledPropertyName, "true");
projectRootElement.AddProperty(StyleCopPredictor.StyleCopOutputFilePropertyName, @"bin\x64\StyleCopViolations.xml");
projectRootElement.AddTarget(StyleCopPredictor.StyleCopTargetName);
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedOutputFiles = new[]
{
new PredictedItem(@"bin\x64\StyleCopViolations.xml", nameof(StyleCopPredictor)),
};
new StyleCopPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
null,
null,
expectedOutputFiles.MakeAbsolute(_rootDir),
null);
}
public void SetMetadata()
{
ProjectRootElement xml = ProjectRootElement.Create();
xml.AddProperty("p", "v");
xml.AddItemDefinitionGroup().AddItemDefinition("i").AddMetadata("m", "m0");
xml.AddItem("i", "i1");
Project project = new Project(xml);
ProjectMetadata metadatum = project.ItemDefinitions["i"].GetMetadata("m");
metadatum.UnevaluatedValue = "$(p)";
Assert.Equal("v", Helpers.GetFirst(project.GetItems("i")).GetMetadataValue("m"));
}
private ProjectPropertyElement MergeProperties(ProjectPropertyElement baseProperty, ProjectPropertyElement addedProperty)
{
var mergedProperty = _projectElementGenerator.AddProperty("___TEMP___", "___TEMP___");
mergedProperty.CopyFrom(addedProperty);
var basePropertyValues = baseProperty.Value.Split(';');
var addedPropertyValues = addedProperty.Value.Split(';');
var intersectedValues = basePropertyValues.Intersect(addedPropertyValues, StringComparer.Ordinal);
intersectedValues = RemoveValuesWithVariable(intersectedValues);
mergedProperty.Value = string.Join(";", addedPropertyValues.Except(intersectedValues));
return(mergedProperty);
}
public void NoCopy()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
projectRootElement.AddProperty(ContentItemsPredictor.OutDirPropertyName, @"bin\");
projectRootElement.AddItem(ContentItemsPredictor.ContentItemName, "Foo.xml");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
new ContentItemsPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
new[] { new PredictedItem("Foo.xml", nameof(ContentItemsPredictor)) },
null,
null,
null);
}
