public void TargetOverride_Escaped2()
{
ProjectRootElement projectXml = ProjectRootElement.Create();
projectXml.AddTarget("t;").Inputs = "i1";
projectXml.AddTarget("t%3b").Inputs = "i2";
Project project = new Project(projectXml);
ProjectInstance instance = project.CreateProjectInstance();
ProjectTargetInstance target = instance.Targets["t;"];
Assert.AreEqual("i2", target.Inputs);
}
public void FindItemsWithMissingInvalidSettingsFile()
{
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);
File.WriteAllText(Path.Combine(_rootDir, "CustomSettings.StyleCop"), "This is not valid Xml");
projectRootElement.AddProperty(StyleCopPredictor.StyleCopOverrideSettingsFilePropertyName, "CustomSettings.StyleCop");
// Ensure the default project settings do get picked up
File.WriteAllText(Path.Combine(_rootDir, StyleCopPredictor.StyleCopSettingsDefaultFileName), "SomeContent");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem(StyleCopPredictor.StyleCopSettingsDefaultFileName, nameof(StyleCopPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"bin\x64\StyleCopViolations.xml", nameof(StyleCopPredictor)),
};
new StyleCopPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles.MakeAbsolute(_rootDir),
null,
expectedOutputFiles.MakeAbsolute(_rootDir),
null);
}
public void FindItemsWithMultipleSettingsFiles()
{
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);
// Only the default one will be chosen as it's the first one which exists.
File.WriteAllText(Path.Combine(_rootDir, StyleCopPredictor.StyleCopSettingsDefaultFileName), "SomeContent");
File.WriteAllText(Path.Combine(_rootDir, StyleCopPredictor.StyleCopSettingsAlternateFileName), "SomeContent");
File.WriteAllText(Path.Combine(_rootDir, StyleCopPredictor.StyleCopSettingsLegacyFileName), "SomeContent");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem(StyleCopPredictor.StyleCopSettingsDefaultFileName, nameof(StyleCopPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"bin\x64\StyleCopViolations.xml", nameof(StyleCopPredictor)),
};
new StyleCopPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles.MakeAbsolute(_rootDir),
null,
expectedOutputFiles.MakeAbsolute(_rootDir),
null);
}
public void SetReturns()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTargetElement target = project.AddTarget("t");
Helpers.ClearDirtyFlag(project);
target.Returns = "@(a)";
Assert.AreEqual("@(a)", target.Returns);
Assert.AreEqual(true, project.HasUnsavedChanges);
Helpers.ClearDirtyFlag(project);
target.Returns = String.Empty;
Assert.AreEqual(String.Empty, target.Returns);
Assert.AreEqual(true, project.HasUnsavedChanges);
Helpers.ClearDirtyFlag(project);
target.Returns = null;
Assert.IsNull(target.Returns);
Assert.AreEqual(true, project.HasUnsavedChanges);
}
public void SetCondition()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTaskElement task = project.AddTarget("t").AddTask("tt");
Helpers.ClearDirtyFlag(task.ContainingProject);
task.Condition = "c";
Assert.AreEqual("c", task.Condition);
Assert.AreEqual(true, project.HasUnsavedChanges);
}
public void SetContinueOnError()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTaskElement task = project.AddTarget("t").AddTask("tt");
Helpers.ClearDirtyFlag(task.ContainingProject);
task.ContinueOnError = "true";
Assert.Equal("true", task.ContinueOnError);
Assert.True(project.HasUnsavedChanges);
}
public void SetKeepDuplicateOutputs()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTargetElement target = project.AddTarget("t");
Helpers.ClearDirtyFlag(project);
target.KeepDuplicateOutputs = "true";
Assert.AreEqual("true", target.KeepDuplicateOutputs);
Assert.AreEqual(true, project.HasUnsavedChanges);
}
public void SetName()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTargetElement target = project.AddTarget("t");
Helpers.ClearDirtyFlag(project);
target.Name = "t2";
Assert.AreEqual("t2", target.Name);
Assert.AreEqual(true, project.HasUnsavedChanges);
}
public void SetDependsOnTargets()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTargetElement target = project.AddTarget("t");
Helpers.ClearDirtyFlag(project);
target.DependsOnTargets = "dot";
Assert.AreEqual("dot", target.DependsOnTargets);
Assert.AreEqual(true, project.HasUnsavedChanges);
}
public void SetCondition()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTargetElement target = project.AddTarget("t");
Helpers.ClearDirtyFlag(project);
target.Condition = "c";
Assert.Equal("c", target.Condition);
Assert.True(project.HasUnsavedChanges);
}
public void SetOutputs()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTargetElement target = project.AddTarget("t");
Helpers.ClearDirtyFlag(project);
target.Outputs = "out";
Assert.Equal("out", target.Outputs);
Assert.True(project.HasUnsavedChanges);
}
public void BuildNullTargetNameIsDefaultTarget()
{
ProjectRootElement xml = ProjectRootElement.Create();
xml.AddTarget("t").AddTask("Message").SetParameter("Text", "[OK]");
ProjectInstance instance = new ProjectInstance(xml);
MockLogger logger = new MockLogger();
string target = null;
instance.Build(target, new ILogger[] { logger });
logger.AssertLogContains("[OK]");
}
public void SetCondition()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTargetElement target = project.AddTarget("t");
ProjectOnErrorElement onError = project.CreateOnErrorElement("et");
target.AppendChild(onError);
Helpers.ClearDirtyFlag(project);
onError.Condition = "c";
Assert.AreEqual("c", onError.Condition);
Assert.AreEqual(true, project.HasUnsavedChanges);
}
public void SettingItemRemoveDirties()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectItemElement item = project.AddTarget("t").AddItemGroup().AddItem("i", "i1");
item.Include = null;
Helpers.ClearDirtyFlag(project);
item.Remove = "i2";
Assert.Equal("i2", item.Remove);
Assert.Equal(true, project.HasUnsavedChanges);
}
public void SetExecuteTargets()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectTargetElement target = project.AddTarget("t");
ProjectOnErrorElement onError = project.CreateOnErrorElement("et");
target.AppendChild(onError);
Helpers.ClearDirtyFlag(project);
onError.ExecuteTargetsAttribute = "et2";
Assert.AreEqual("et2", onError.ExecuteTargetsAttribute);
Assert.AreEqual(true, project.HasUnsavedChanges);
}
public void SkipWhenStyleCopDisabled()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"project.csproj"));
projectRootElement.AddProperty(StyleCopPredictor.StyleCopEnabledPropertyName, "false");
projectRootElement.AddProperty(StyleCopPredictor.StyleCopOutputFilePropertyName, @"bin\x64\StyleCopViolations.xml");
projectRootElement.AddTarget(StyleCopPredictor.StyleCopTargetName);
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
new StyleCopPredictor()
.GetProjectPredictions(projectInstance)
.AssertNoPredictions();
}
private string GenerateBootstrapper(string manifestFile, string applicationName, string applicationUrl, params string[] prerequisites)
{
// root element
ProjectRootElement xml = ProjectRootElement.Create();
xml.ToolsVersion = "4.0";
xml.DefaultTargets = "BuildBootstrapper";
// build properties
var propertyGroup = xml.AddPropertyGroup();
propertyGroup.AddProperty("TargetFrameworkVersion", "v4.5");
propertyGroup.AddProperty("VisualStudioVersion", "11.0");
// prerequisites (product codes of each required package, e.g. ".NETFramework,Version=v4.5")
var itemGroup = xml.AddItemGroup();
foreach (string productCode in prerequisites)
{
itemGroup.AddItem("BootstrapperFile", productCode);
}
// target
var target = xml.AddTarget("BuildBootstrapper");
var task = target.AddTask("GenerateBootstrapper");
task.SetParameter("ApplicationFile", Path.GetFileName(manifestFile));
task.SetParameter("ApplicationName", applicationName);
task.SetParameter("ApplicationUrl", applicationUrl);
task.SetParameter("BootstrapperItems", "@(BootstrapperFile)");
task.SetParameter("OutputPath", Path.GetDirectoryName(manifestFile));
task.SetParameter("Path", @"C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0A\Bootstrapper"); // replace with actual path
var proj = new ProjectInstance(xml);
var req = new BuildRequestData(proj, new string[] { "BuildBootstrapper" });
var parameters = new BuildParameters();
// optional logging of the build process
var logger = new FileLogger();
Uri codeBase = new Uri(Assembly.GetEntryAssembly().CodeBase);
logger.Parameters = "logfile=" + Path.Combine(Path.GetDirectoryName(codeBase.LocalPath), "msbuild.log");
parameters.Loggers = new ILogger[] { logger };
// build the bootstrapper executable (setup.exe)
var result = BuildManager.DefaultBuildManager.Build(parameters, req);
if (result.OverallResult == BuildResultCode.Failure)
{
throw new InvalidOperationException("MSBuild task failed!", result.Exception);
}
// return path to the built setup.exe
return(Path.Combine(Path.GetDirectoryName(manifestFile), "setup.exe"));
}
private void SetParameter(ProjectRootElement projectXml, string unevaluatedPropertyValue)
{
var result = FindExecTaskInTargets(projectXml);
if (result.success == true)
{
SetExecParameter(result.execTask, unevaluatedPropertyValue);
}
else
{
var target = projectXml.AddTarget(TargetName);
SetTargetDependencies(target);
var execTask = target.AddTask(ExecTask);
SetExecParameter(execTask, unevaluatedPropertyValue);
}
}
private void SetParameter(ProjectRootElement projectXml, string unevaluatedPropertyValue)
{
ProjectTaskElement?execTask = FindExecTaskInTargets(projectXml);
if (execTask != null)
{
SetExecParameter(execTask, unevaluatedPropertyValue);
}
else
{
ProjectTargetElement target = projectXml.AddTarget(TargetName);
SetTargetDependencies(target);
execTask = target.AddTask(ExecTask);
SetExecParameter(execTask, unevaluatedPropertyValue);
}
}
/// <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);
}
public void BuildProject(string projectName, IEnumerable <ComponentGeneratorOutput> files, string csprojDir, string packageConfigFilename)
{
ProjectRootElement root = ProjectRootElement.Create();
AddProperties(projectName, root);
// references
AddItems(root, "Reference", "System", "System.Core", "System.Drawing", "System.Xml.Linq", "System.Data.DataSetExtensions", "Microsoft.CSharp", "System.Data", "System.Net.Http", "System.Xml");
// items to compile
AddItems(root, "Compile", files.Select(file => file.CsFilePath).ToArray());
AddItems(root, "None", packageConfigFilename);
ProjectTargetElement target = root.AddTarget("Build");
ProjectTaskElement task = target.AddTask("Csc");
task.SetParameter("Sources", "@(Compile)");
task.SetParameter("OutputAssembly", $"{projectName}.dll");
AddImports(root);
root.Save($"{csprojDir}\\{projectName}.csproj");
}
public void FileLocationAvailableEvenAfterEdits()
{
string path = null;
try
{
path = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
ProjectRootElement projectXml = ProjectRootElement.Create(path);
projectXml.Save();
projectXml.AddTarget("t");
Project project = new Project(projectXml);
ProjectTargetInstance target = project.Targets["t"];
Assert.AreEqual(project.FullPath, target.FullPath);
}
finally
{
File.Delete(path);
}
}
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 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);
}
/// <summary>
/// Adds target to project.
/// </summary>
private static ProjectTargetElement AddProjectTarget(ProjectRootElement project, string target)
{
return(project.Targets.FirstOrDefault(t => t.Name == target) ?? project.AddTarget(target));
}
public static TestExclusionMap Create(BuildOptions options)
{
TestExclusionMap outputMap = new TestExclusionMap();
if (options.IssuesPath != null)
{
Dictionary <string, List <TestExclusion> > exclusionsByCondition = new Dictionary <string, List <TestExclusion> >();
foreach (FileInfo issuesProject in options.IssuesPath)
{
string issuesProjectPath = issuesProject.FullName;
XDocument issuesXml = XDocument.Load(issuesProjectPath);
foreach (XElement itemGroupElement in issuesXml.Root.Elements(s_xmlNamespace + "ItemGroup"))
{
string condition = itemGroupElement.Attribute("Condition")?.Value ?? "";
List <TestExclusion> exclusions;
if (!exclusionsByCondition.TryGetValue(condition, out exclusions))
{
exclusions = new List <TestExclusion>();
exclusionsByCondition.Add(condition, exclusions);
}
foreach (XElement excludeListElement in itemGroupElement.Elements(s_xmlNamespace + "ExcludeList"))
{
string testPath = excludeListElement.Attribute("Include")?.Value ?? "";
string issueID = excludeListElement.Element(s_xmlNamespace + "Issue")?.Value ?? "N/A";
exclusions.Add(CreateTestExclusion(testPath, issueID));
}
}
}
Project project = new Project();
project.SetGlobalProperty("XunitTestBinBase", "*");
project.SetGlobalProperty("BuildArch", "amd64");
project.SetGlobalProperty("TargetsWindows", "true");
project.SetGlobalProperty("AltJitArch", "amd64");
project.SetGlobalProperty("RunTestViaIlLink", "false");
ProjectRootElement root = project.Xml;
root.AddTarget("GetListOfTestCmds");
ProjectPropertyGroupElement propertyGroup = root.AddPropertyGroup();
// Generate properties into the project to make it evaluate all conditions found in the targets file
List <List <TestExclusion> > testExclusionLists = new List <List <TestExclusion> >();
testExclusionLists.Capacity = exclusionsByCondition.Count;
foreach (KeyValuePair <string, List <TestExclusion> > kvp in exclusionsByCondition)
{
string propertyName = "Condition_" + testExclusionLists.Count.ToString();
bool emptyKey = string.IsNullOrEmpty(kvp.Key);
propertyGroup.AddProperty(propertyName, emptyKey ? "true" : "false");
if (!emptyKey)
{
propertyGroup.AddProperty(propertyName, "true").Condition = kvp.Key;
}
testExclusionLists.Add(kvp.Value);
}
project.Build();
for (int exclusionListIndex = 0; exclusionListIndex < testExclusionLists.Count; exclusionListIndex++)
{
string conditionValue = project.GetProperty("Condition_" + exclusionListIndex.ToString()).EvaluatedValue;
if (conditionValue.Equals("true", StringComparison.OrdinalIgnoreCase))
{
foreach (TestExclusion exclusion in testExclusionLists[exclusionListIndex])
{
outputMap.Add(exclusion);
}
}
}
}
return(outputMap);
}
