public static ProjectInstance ThreadSafeCreateProjectInstance(this Microsoft.Build.Evaluation.Project thisp)
{
lock (thisp)
{
return(thisp.CreateProjectInstance());
}
}
public void CreateProjectInstancePassesEnvironment()
{
Project p = new Project();
ProjectInstance i = p.CreateProjectInstance();
Assert.Equal(true, i.GetPropertyValue("username") != null);
}
/// <summary>
/// Builds all the content files which have been added to the project,
/// dynamically creating .xnb files in the OutputDirectory.
/// Returns an error message if the build fails.
/// </summary>
public string Build()
{
// Clear any previous errors.
errorLogger.Errors.Clear();
// Create and submit a new asynchronous build request.
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
BuildRequestData request = new BuildRequestData(buildProject.CreateProjectInstance(), new string[0]);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(request);
submission.ExecuteAsync(null, null);
// Wait for the build to finish.
submission.WaitHandle.WaitOne();
BuildManager.DefaultBuildManager.EndBuild();
// If the build failed, return an error string.
if (submission.BuildResult.OverallResult == BuildResultCode.Failure)
{
return(string.Join("\n", errorLogger.Errors.ToArray()));
}
return(null);
}
/// <summary>
/// Get a single metadata instance
/// </summary>
private static ProjectMetadataInstance GetMetadataInstance()
{
Project project = new Project();
ProjectInstance projectInstance = project.CreateProjectInstance();
ProjectItemInstance item = projectInstance.AddItem("i", "i1");
ProjectMetadataInstance metadata = item.SetMetadata("m", "m1");
return metadata;
}
private IEnumerable <string> ResolveAssemblyReferences(Microsoft.Build.Evaluation.Project project)
{
var projectInstance = project.CreateProjectInstance();
projectInstance.SetProperty("BuildingProject", "false");
project.SetProperty("DesignTimeBuild", "true");
projectInstance.Build("ResolveAssemblyReferences", new[] { new ConsoleLogger(LoggerVerbosity.Minimal) });
var items = projectInstance.GetItems("_ResolveAssemblyReferenceResolvedFiles");
return(items.Select(i => Path.Combine(Path.GetDirectoryName(this.FileName), i.GetMetadataValue("Identity"))));
}
public void TargetOverride_Escaped()
{
ProjectRootElement projectXml = ProjectRootElement.Create();
projectXml.AddTarget("t%3b").Inputs = "i1";
projectXml.AddTarget("t;").Inputs = "i2";
Project project = new Project(projectXml);
ProjectInstance instance = project.CreateProjectInstance();
ProjectTargetInstance target = instance.Targets["t;"];
Assert.Equal("i2", target.Inputs);
}
/// <summary>
/// Creates a project instance with a single empty target named 'foo'
/// </summary>
/// <returns>A project instance.</returns>
internal static ProjectInstance CreateEmptyProjectInstance()
{
XmlReader reader = XmlReader.Create(new StringReader
(
@"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' ToolsVersion='4.0'>
<Target Name='foo'/>
</Project>"
));
Project project = new Project(reader);
ProjectInstance instance = project.CreateProjectInstance();
return instance;
}
/// <summary>
/// Return a task instance representing the task XML string passed in
/// </summary>
private static ProjectTaskInstance GetTaskInstance(string taskXmlString)
{
string content = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' >
<Target Name='t'>
" + taskXmlString + @"
</Target>
</Project>
";
ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(content)));
Project project = new Project(xml);
ProjectInstance instance = project.CreateProjectInstance();
ProjectTaskInstance task = (ProjectTaskInstance)(instance.Targets["t"].Children[0]);
return task;
}
/// <summary>
/// Create a TaskInstance with some parameters
/// </summary>
private static ProjectOnErrorInstance GetSampleOnErrorInstance()
{
string content = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' >
<Target Name='t'>
<OnError ExecuteTargets='et' Condition='c'/>
</Target>
</Project>
";
ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(content)));
Project project = new Project(xml);
ProjectInstance instance = project.CreateProjectInstance();
ProjectOnErrorInstance onError = (ProjectOnErrorInstance)instance.Targets["t"].OnErrorChildren[0];
return onError;
}
/// <summary>
/// Generates a project object of the elements set so forth in this object. This returns the new MSBuild project instance
/// </summary>
public ProjectInstance GetMSBuildProjectInstance()
{
if (!this.createMSBuildProject)
{
return(null);
}
if (this.msbuildProjectInstance != null)
{
return(this.msbuildProjectInstance);
}
CreateDefaultTarget();
ProjectRootElement pXml = ProjectRootElement.Open(this.projectXmlDocument);
Microsoft.Build.Evaluation.Project pDef = new Microsoft.Build.Evaluation.Project(pXml);
return(pDef.CreateProjectInstance());
}
/// <summary>
/// Create a ProjectTaskOutputPropertyInstance with some parameters
/// </summary>
private static ProjectTaskOutputPropertyInstance GetSampleTaskOutputInstance()
{
string content = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' >
<Target Name='t'>
<t1>
<Output TaskParameter='p' Condition='c' PropertyName='p1'/>
</t1>
</Target>
</Project>
";
ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(content)));
Project project = new Project(xml);
ProjectInstance instance = project.CreateProjectInstance();
ProjectTaskInstance task = (ProjectTaskInstance)instance.Targets["t"].Children[0];
ProjectTaskOutputPropertyInstance output = (ProjectTaskOutputPropertyInstance)task.Outputs[0];
return output;
}
public void AddItem_EscapedItemInclude()
{
Project project = new Project();
project.AddItem("i", "i%281%29");
string expected = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<ItemGroup>
<i Include=""i%281%29"" />
</ItemGroup>
</Project>");
Helpers.VerifyAssertProjectContent(expected, project.Xml);
List<ProjectItem> items = Helpers.MakeList(project.Items);
Assert.Equal(1, items.Count);
Assert.Equal("i", items[0].ItemType);
Assert.Equal("i(1)", items[0].EvaluatedInclude);
Assert.Equal("i(1)", Helpers.GetFirst(project.GetItems("i")).EvaluatedInclude);
Assert.Equal("i(1)", Helpers.MakeList(project.CreateProjectInstance().GetItems("i"))[0].EvaluatedInclude);
}
public void BuildAndAnalyze()
{
var globalProps = new Dictionary<string, string> {
{"VisualStudioVersion","12.0"}
};
pc = new ProjectCollection(globalProps);
var diagLogger = new DiagnosticXmlLogger(this);
diagLogger.LogFile = _logFilepath;
project = pc.LoadProject(_projectFilepath, "12.0");
projInst = project.CreateProjectInstance();
buildManager = new BuildManager();
var buildParams = new BuildParameters();
buildParams.Loggers = new ILogger[] { diagLogger };
buildManager.BeginBuild(buildParams);
var brd = new BuildRequestData(projInst, _targets, null, BuildRequestDataFlags.ReplaceExistingProjectInstance);
submission = buildManager.PendBuildRequest(brd);
buildResult = submission.Execute();
buildManager.EndBuild();
}
public void RemoveProperty()
{
Project project = new Project();
int environmentPropertyCount = Helpers.MakeList(project.Properties).Count;
project.SetProperty("p1", "v1");
project.ReevaluateIfNecessary();
project.RemoveProperty(project.GetProperty("p1"));
string expected = ObjectModelHelpers.CleanupFileContents(@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"" />");
Helpers.VerifyAssertProjectContent(expected, project.Xml);
Assert.Equal(null, project.GetProperty("p1"));
ProjectInstance instance = project.CreateProjectInstance();
Assert.Equal(String.Empty, instance.GetPropertyValue("p1"));
Assert.Equal(0, Helpers.Count(project.Properties) - environmentPropertyCount);
}
public void SetProperty_EscapedValue()
{
Project project = new Project();
int environmentPropertyCount = Helpers.MakeList(project.Properties).Count;
project.SetProperty("p1", "v%5E1");
string expected = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<PropertyGroup>
<p1>v%5E1</p1>
</PropertyGroup>
</Project>");
Helpers.VerifyAssertProjectContent(expected, project.Xml);
Assert.Equal("v^1", project.GetPropertyValue("p1"));
Assert.Equal("v^1", project.CreateProjectInstance().GetPropertyValue("p1"));
Assert.Equal(1, Helpers.Count(project.Properties) - environmentPropertyCount);
}
public void RemoveItem()
{
Project project = new Project();
project.AddItem("i", "i1");
project.ReevaluateIfNecessary();
project.RemoveItem(Helpers.GetFirst(project.GetItems("i")));
string expected = ObjectModelHelpers.CleanupFileContents(@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"" />");
Helpers.VerifyAssertProjectContent(expected, project.Xml);
Assert.Equal(0, Helpers.Count(project.Items));
Assert.Equal(0, Helpers.MakeList(project.CreateProjectInstance().GetItems("i")).Count);
}
/// <summary>
/// Create a ProjectInstance from provided project content and host services object
/// </summary>
private static ProjectInstance GetProjectInstance(string content, HostServices hostServices, IDictionary<string, string> globalProperties, ProjectCollection projectCollection, string toolsVersion = null)
{
XmlReader reader = XmlReader.Create(new StringReader(content));
if (globalProperties == null)
{
// choose some interesting defaults if we weren't explicitly asked to use a set.
globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
globalProperties.Add("g1", "v1");
globalProperties.Add("g2", "v2");
}
Project project = new Project(reader, globalProperties, toolsVersion ?? "4.0", projectCollection ?? ProjectCollection.GlobalProjectCollection);
ProjectInstance instance = project.CreateProjectInstance();
return instance;
}
private IEnumerable<string> ResolveAssemblyReferences(Project project)
{
var projectInstance = project.CreateProjectInstance();
projectInstance.SetProperty("BuildingProject", "false");
project.SetProperty("DesignTimeBuild", "true");
projectInstance.Build("ResolveAssemblyReferences", new[] { new ConsoleLogger(LoggerVerbosity.Minimal) });
var items = projectInstance.GetItems("_ResolveAssemblyReferenceResolvedFiles");
var baseDirectory = Path.GetDirectoryName(this.FileName);
return items.Select(i => Path.Combine(baseDirectory, i.GetMetadataValue("Identity")));
}
/// <summary>
/// Creates a test project.
/// </summary>
/// <returns>The project.</returns>
private ProjectInstance CreateTestProject()
{
string projectFileContents = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<Compile Include='b.cs' />
<Compile Include='c.cs' />
</ItemGroup>
<ItemGroup>
<Reference Include='System' />
</ItemGroup>
<Target Name='Empty' />
<Target Name='Skip' Inputs='testProject.proj' Outputs='testProject.proj' />
<Target Name='Error' >
<ErrorTask1 ContinueOnError='True'/>
<ErrorTask2 ContinueOnError='False'/>
<ErrorTask3 />
<OnError ExecuteTargets='Foo'/>
<OnError ExecuteTargets='Bar'/>
</Target>
<Target Name='Foo' Inputs='foo.cpp' Outputs='foo.o'>
<FooTask1/>
</Target>
<Target Name='Bar'>
<BarTask1/>
</Target>
<Target Name='Baz' DependsOnTargets='Bar'>
<BazTask1/>
<BazTask2/>
</Target>
<Target Name='Baz2' DependsOnTargets='Bar;Foo'>
<Baz2Task1/>
<Baz2Task2/>
<Baz2Task3/>
</Target>
<Target Name='DepSkip' DependsOnTargets='Skip'>
<DepSkipTask1/>
<DepSkipTask2/>
<DepSkipTask3/>
</Target>
<Target Name='DepError' DependsOnTargets='Foo;Skip;Error'>
<DepSkipTask1/>
<DepSkipTask2/>
<DepSkipTask3/>
</Target>
</Project>
");
IConfigCache cache = (IConfigCache)_host.GetComponent(BuildComponentType.ConfigCache);
BuildRequestConfiguration config = new BuildRequestConfiguration(1, new BuildRequestData("testfile", new Dictionary<string, string>(), "3.5", new string[0], null), "2.0");
Project project = new Project(XmlReader.Create(new StringReader(projectFileContents)));
config.Project = project.CreateProjectInstance();
cache.AddConfiguration(config);
return config.Project;
}
public void TestDetailedSummary()
{
string contents = ObjectModelHelpers.CleanupFileContents(@"
<Project xmlns='msbuildnamespace' ToolsVersion='msbuilddefaulttoolsversion'>
<Target Name='test'>
<Message Text='[success]'/>
</Target>
</Project>
");
_parameters.DetailedSummary = true;
Project project = new Project(new XmlTextReader(new StringReader(contents)));
BuildRequestData data = new BuildRequestData(project.CreateProjectInstance(), new string[] { "test" });
BuildResult result = _buildManager.Build(_parameters, data);
Assert.Equal(BuildResultCode.Success, result.OverallResult);
_logger.AssertLogContains("[success]");
// Verify the existence of the first line of the header.
StringReader reader = new StringReader(ResourceUtilities.FormatResourceString("BuildHierarchyHeader"));
_logger.AssertLogContains(reader.ReadLine());
}
public void ItemsByEvaluatedIncludeAndExpansion()
{
List<string> filePaths = new List<string>();
string testFileRoot = null;
try
{
int count = 0;
testFileRoot = Path.Combine(Path.GetTempPath(), "foodir");
Directory.CreateDirectory(testFileRoot);
int maxFiles = 2;
for (int i = 0; i < maxFiles; i++)
{
string fileName = String.Format("foo{0}.foo", i);
string filePath = Path.Combine(testFileRoot, fileName);
File.WriteAllText(filePath, String.Empty);
filePaths.Add(filePath);
}
ProjectRootElement projectConstruction = ProjectRootElement.Create();
projectConstruction.AddItem("foo", Path.Combine(testFileRoot, "*.foo"));
count = Helpers.Count(projectConstruction.Items);
Assert.Equal(1, count); // "Construction Model"
Project project = new Project(projectConstruction);
count = Helpers.Count(project.GetItems("foo"));
Assert.Equal(2, count); // "Evaluation Model, Before Removal"
ProjectItem itemToRemove = null;
// Get the first item from IEnumerable Collection.
foreach (ProjectItem item in project.Items)
{
itemToRemove = item;
break;
}
project.RemoveItem(itemToRemove);
count = Helpers.Count(project.GetItems("foo"));
Assert.Equal(1, count); // "Evaluation Model, After Removal"
ProjectInstance projectInstance = project.CreateProjectInstance();
count = Helpers.Count(projectInstance.Items);
Assert.Equal(1, count); // "Instance Model"
// Ensure XML has been updated accordingly on the Evaluation model (projectInstance doesn't back onto XML)
Assert.False(project.Xml.RawXml.Contains(itemToRemove.Xml.Include));
Assert.False(project.Xml.RawXml.Contains("*.foo"));
}
finally
{
foreach (string filePathToRemove in filePaths)
{
File.Delete(filePathToRemove);
}
Directory.Delete(testFileRoot);
}
}
public static void Publish(EnvDTE.Project project, Dictionary <string, string> buildProperties, Microsoft.Build.Framework.LoggerVerbosity verbosity)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (buildProperties == null)
{
throw new ArgumentNullException("buildProperties");
}
System.Threading.Tasks.Task.Factory.StartNew(() =>
{
DTE dte = (DTE)CloudFoundryVisualStudioPackage.GetGlobalService(typeof(DTE));
var window = dte.Windows.Item(EnvDTE.Constants.vsWindowKindOutput);
var output = (OutputWindow)window.Object;
OutputWindowPane pane = null;
pane = output.OutputWindowPanes.Cast <OutputWindowPane>().FirstOrDefault(x => x.Name == "Publish");
if (pane == null)
{
pane = output.OutputWindowPanes.Add("Publish");
}
var showOutputWindowPropertyValue = VsUtils.GetVisualStudioSetting("Environment", "ProjectsAndSolution", "ShowOutputWindowBeforeBuild");
if (showOutputWindowPropertyValue != null)
{
if ((bool)showOutputWindowPropertyValue == true)
{
window.Visible = true;
}
}
pane.Activate();
ErrorListProvider errorList = CloudFoundryVisualStudioPackage.GetErrorListPane;
if (errorList == null)
{
throw new InvalidOperationException("Could not retrieve error list provider");
}
errorList.Tasks.Clear();
MSBuildLogger customLogger = new MSBuildLogger(pane, errorList);
customLogger.Verbosity = verbosity;
pane.Clear();
pane.OutputString("Starting push...");
Microsoft.Build.Evaluation.Project websiteProject = null;
using (var buildManager = new BuildManager())
{
using (var projectCollection = new ProjectCollection())
{
string proj = project.FullName;
if (project.Object is VsWebSite.VSWebSite)
{
string projectDir = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(buildProperties["PublishProfile"])).Parent.Parent.FullName;
proj = Path.Combine(projectDir, CloudFoundry.VisualStudio.ProjectPush.PushEnvironment.DefaultWebsiteProjectName);
}
websiteProject = projectCollection.LoadProject(proj);
foreach (KeyValuePair <string, string> parameter in buildProperties)
{
websiteProject.SetProperty(parameter.Key, parameter.Value);
}
BuildParameters buildParameters = new BuildParameters(projectCollection);
buildParameters.Loggers = new List <ILogger>()
{
customLogger
};
BuildRequestData buildRequestData = new BuildRequestData(websiteProject.CreateProjectInstance(), new string[] { });
buildManager.Build(buildParameters, buildRequestData);
if (errorList.Tasks.Count > 0)
{
errorList.BringToFront();
}
pane.OutputString("Push operation finished!");
projectCollection.UnregisterAllLoggers();
}
}
});
}
public void AddMetadata_EscapedValue()
{
Project project = new Project();
ProjectItem item = project.AddItem("i", "i1")[0];
item.SetMetadataValue("m", "m1%24%24");
string expected = ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<ItemGroup>
<i Include=""i1"">
<m>m1%24%24</m>
</i>
</ItemGroup>
</Project>");
Helpers.VerifyAssertProjectContent(expected, project.Xml);
List<ProjectItem> items = Helpers.MakeList(project.Items);
Assert.Equal("m1$$", items[0].GetMetadataValue("m"));
Assert.Equal("m1$$", Helpers.MakeList(project.CreateProjectInstance().GetItems("i"))[0].GetMetadataValue("m"));
}
/// <summary>
/// Get a ProjectPropertyInstance
/// </summary>
private static ProjectPropertyInstance GetPropertyInstance()
{
Project project = new Project();
ProjectInstance projectInstance = project.CreateProjectInstance();
ProjectPropertyInstance property = projectInstance.SetProperty("p", "v1");
return property;
}
public void ITaskItem2Operations()
{
Project project = new Project();
ProjectInstance projectInstance = project.CreateProjectInstance();
ProjectItemInstance item = projectInstance.AddItem("EscapedItem", "esca%20ped%3bitem");
item.SetMetadata("m", "m1");
item.SetMetadata("m;", "m%3b1");
ITaskItem2 taskItem = (ITaskItem2)item;
Assert.Equal(taskItem.EvaluatedIncludeEscaped, "esca%20ped%3bitem");
Assert.Equal(taskItem.ItemSpec, "esca ped;item");
Assert.Equal(taskItem.GetMetadata("m;"), "m;1");
Assert.Equal(taskItem.GetMetadataValueEscaped("m;"), "m%3b1");
Assert.Equal(taskItem.GetMetadataValueEscaped("m"), "m1");
Assert.Equal(taskItem.EvaluatedIncludeEscaped, "esca%20ped%3bitem");
Assert.Equal(taskItem.ItemSpec, "esca ped;item");
ITaskItem2 taskItem2 = new Microsoft.Build.Utilities.TaskItem(taskItem);
taskItem2.SetMetadataValueLiteral("m;", "m;2");
Assert.Equal(taskItem2.GetMetadataValueEscaped("m;"), "m%3b2");
Assert.Equal(taskItem2.GetMetadata("m;"), "m;2");
IDictionary<string, string> taskItem2Metadata = (IDictionary<string, string>)taskItem2.CloneCustomMetadata();
Assert.Equal(3, taskItem2Metadata.Count);
foreach (KeyValuePair<string, string> pair in taskItem2Metadata)
{
if (pair.Key.Equals("m"))
{
Assert.Equal("m1", pair.Value);
}
if (pair.Key.Equals("m;"))
{
Assert.Equal("m;2", pair.Value);
}
if (pair.Key.Equals("OriginalItemSpec"))
{
Assert.Equal("esca ped;item", pair.Value);
}
}
IDictionary<string, string> taskItem2MetadataEscaped = (IDictionary<string, string>)taskItem2.CloneCustomMetadataEscaped();
Assert.Equal(3, taskItem2MetadataEscaped.Count);
foreach (KeyValuePair<string, string> pair in taskItem2MetadataEscaped)
{
if (pair.Key.Equals("m"))
{
Assert.Equal("m1", pair.Value);
}
if (pair.Key.Equals("m;"))
{
Assert.Equal("m%3b2", pair.Value);
}
if (pair.Key.Equals("OriginalItemSpec"))
{
Assert.Equal("esca%20ped%3bitem", pair.Value);
}
}
}
/// <summary>
/// Creates a test project.
/// </summary>
private ProjectInstance CreateTestProject(string projectBodyContents, string initialTargets, string defaultTargets)
{
string projectFileContents = String.Format("<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='http://schemas.microsoft.com/developer/msbuild/2003' InitialTargets='{0}' DefaultTargets='{1}'>{2}</Project>", initialTargets, defaultTargets, projectBodyContents);
// retries to deal with occasional locking issues where the file can't be written to initially
for (int retries = 0; retries < 5; retries++)
{
try
{
File.Create("testProject.proj").Close();
break;
}
catch (Exception ex)
{
if (retries < 4)
{
Console.WriteLine(ex.ToString());
}
else
{
// All the retries have failed. We will now fail with the
// actual problem now instead of with some more difficult-to-understand
// issue later.
throw;
}
}
}
IConfigCache cache = (IConfigCache)_host.GetComponent(BuildComponentType.ConfigCache);
BuildRequestConfiguration config = new BuildRequestConfiguration(1, new BuildRequestData("testFile", new Dictionary<string, string>(), "3.5", new string[0], null), "2.0");
Project project = new Project(XmlReader.Create(new StringReader(projectFileContents)));
config.Project = project.CreateProjectInstance();
cache.AddConfiguration(config);
return config.Project;
}
public void ExpandBuiltInMetadataAtPointOfUse_UseInBatching()
{
string content =
ObjectModelHelpers.CleanupFileContents(
@"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<ItemDefinitionGroup>
<h>
<m>%(extension)</m>
</h>
</ItemDefinitionGroup>
<ItemGroup>
<h Include='a.foo;a.bar'/>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<i Include=""@(h)"">
<n Condition=""'%(m)'=='.foo'"">n1</n>
</i>
</ItemGroup>
</Target>
</Project>");
Project project = new Project(XmlReader.Create(new StringReader(content)));
ProjectInstance instance = project.CreateProjectInstance();
MockLogger l = new MockLogger();
List<ILogger> loggers = new List<ILogger>() { l };
instance.Build(loggers);
ProjectItemInstance item1 = instance.GetItems("i").ElementAt(0);
Assert.Equal("n1", item1.GetMetadataValue("n"));
ProjectItemInstance item2 = instance.GetItems("i").ElementAt(1);
Assert.Equal("", item2.GetMetadataValue("n"));
}
public void FullPathMetadataOnItemUnescaped()
{
string projectName = "foo.proj";
string projectRelativePath = "(jay's parens test)";
string path = Path.Combine(Path.GetTempPath(), projectRelativePath);
string projectAbsolutePath = Path.Combine(path, projectName);
try
{
Directory.CreateDirectory(path);
ProjectRootElement projectElement = ProjectRootElement.Create(projectAbsolutePath);
ProjectItemGroupElement itemgroup = projectElement.AddItemGroup();
itemgroup.AddItem("ProjectFile", projectName);
Project project = new Project(projectElement, null, null, new ProjectCollection());
ProjectInstance projectInstance = project.CreateProjectInstance();
IEnumerable<ProjectItemInstance> items = projectInstance.GetItems("ProjectFile");
Assert.Equal(projectAbsolutePath, items.First().GetMetadataValue("FullPath"));
}
finally
{
if (File.Exists(projectAbsolutePath)) File.Delete(projectAbsolutePath);
if (Directory.Exists(path)) Directory.Delete(path);
}
}
public void TestSetProjectGood()
{
BuildRequestData data1 = new BuildRequestData("file", new Dictionary<string, string>(), "toolsVersion", new string[0], null);
BuildRequestConfiguration config1 = new BuildRequestConfiguration(data1, "2.0");
Assert.Null(config1.Project);
Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace' />"))));
ProjectInstance projectInstance = project.CreateProjectInstance();
config1.Project = projectInstance;
Assert.Same(config1.Project, projectInstance);
}
public void CreateProjectInstance ()
{
string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<PropertyGroup>
<AssemblyName>Foo</AssemblyName>
</PropertyGroup>
<Import Project='$(MSBuildToolsPath)\Microsoft.CSharp.targets' />
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
var proj = new Project (root, null, "4.0");
var inst = proj.CreateProjectInstance ();
Assert.AreEqual ("4.0", inst.ToolsVersion, "#1");
}
public void TestCache()
{
string projectBody = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<PropertyGroup>
<One>1</One>
<Two>2</Two>
<Three>$(ThreeIn)</Three>
</PropertyGroup>
<ItemGroup>
<Foo Include=""*""/>
<Bar Include=""msbuild.out"">
<One>1</One>
</Bar>
<Baz Include=""$(BazIn)""/>
</ItemGroup>
<Target Name='Build'>
<CallTarget Targets='Foo;Goo'/>
</Target>
<Target Name='Foo' DependsOnTargets='Foo2'>
<FooTarget/>
</Target>
<Target Name='Goo'>
<GooTarget/>
</Target>
<Target Name='Foo2'>
<Foo2Target/>
</Target>
</Project>");
Dictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
globalProperties["ThreeIn"] = "3";
globalProperties["BazIn"] = "bazfile";
Project project = new Project(XmlReader.Create(new StringReader(projectBody)), globalProperties, "4.0", new ProjectCollection());
project.FullPath = "foo";
ProjectInstance instance = project.CreateProjectInstance();
BuildRequestConfiguration configuration = new BuildRequestConfiguration(new BuildRequestData(instance, new string[] { }, null), "2.0");
configuration.ConfigurationId = 1;
string originalValue = Environment.GetEnvironmentVariable("MSBUILDCACHE");
try
{
Environment.SetEnvironmentVariable("MSBUILDCACHE", "1");
Assert.Equal("3", instance.GlobalProperties["ThreeIn"]);
Assert.Equal("bazfile", instance.GlobalProperties["BazIn"]);
Assert.Equal("1", instance.PropertiesToBuildWith["One"].EvaluatedValue);
Assert.Equal("2", instance.PropertiesToBuildWith["Two"].EvaluatedValue);
Assert.Equal("3", instance.PropertiesToBuildWith["Three"].EvaluatedValue);
int fooCount = instance.ItemsToBuildWith["Foo"].Count;
Assert.True(fooCount > 0);
Assert.Equal(1, instance.ItemsToBuildWith["Bar"].Count);
Assert.Equal(1, instance.ItemsToBuildWith["Baz"].Count);
Assert.Equal("bazfile", instance.ItemsToBuildWith["Baz"].First().EvaluatedInclude);
Lookup lookup = configuration.BaseLookup;
Assert.NotNull(lookup);
Assert.Equal(fooCount, lookup.GetItems("Foo").Count);
// Configuration initialized with a ProjectInstance should not be cacheable by default.
Assert.False(configuration.IsCacheable);
configuration.IsCacheable = true;
configuration.CacheIfPossible();
Assert.Null(instance.GlobalPropertiesDictionary);
Assert.Null(instance.ItemsToBuildWith);
Assert.Null(instance.PropertiesToBuildWith);
configuration.RetrieveFromCache();
Assert.Equal("3", instance.GlobalProperties["ThreeIn"]);
Assert.Equal("bazfile", instance.GlobalProperties["BazIn"]);
Assert.Equal("1", instance.PropertiesToBuildWith["One"].EvaluatedValue);
Assert.Equal("2", instance.PropertiesToBuildWith["Two"].EvaluatedValue);
Assert.Equal("3", instance.PropertiesToBuildWith["Three"].EvaluatedValue);
Assert.Equal(fooCount, instance.ItemsToBuildWith["Foo"].Count);
Assert.Equal(1, instance.ItemsToBuildWith["Bar"].Count);
Assert.Equal(1, instance.ItemsToBuildWith["Baz"].Count);
Assert.Equal("bazfile", instance.ItemsToBuildWith["Baz"].First().EvaluatedInclude);
lookup = configuration.BaseLookup;
Assert.NotNull(lookup);
Assert.Equal(fooCount, lookup.GetItems("Foo").Count);
}
finally
{
configuration.ClearCacheFile();
Environment.SetEnvironmentVariable("MSBUILDCACHE", originalValue);
}
}
public void CreateItemWithNullMetadataValue()
{
Project project = new Project();
ProjectInstance projectInstance = project.CreateProjectInstance();
IDictionary<string, string> metadata = new Dictionary<string, string>();
metadata.Add("m", null);
ProjectItemInstance item = projectInstance.AddItem("i", "i1", metadata);
Assert.Equal(String.Empty, item.GetMetadataValue("m"));
}
public void TestCache2()
{
string projectBody = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<PropertyGroup>
<One>1</One>
<Two>2</Two>
<Three>$(ThreeIn)</Three>
</PropertyGroup>
<ItemGroup>
<Foo Include=""*""/>
<Bar Include=""msbuild.out"">
<One>1</One>
</Bar>
<Baz Include=""$(BazIn)""/>
</ItemGroup>
<Target Name='Build'>
<CallTarget Targets='Foo;Bar'/>
</Target>
<Target Name='Foo' DependsOnTargets='Foo'>
<FooTarget/>
</Target>
<Target Name='Bar'>
<BarTarget/>
</Target>
<Target Name='Foo'>
<FooTarget/>
</Target>
</Project>");
Dictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
globalProperties["ThreeIn"] = "3";
globalProperties["BazIn"] = "bazfile";
Project project = new Project(XmlReader.Create(new StringReader(projectBody)), globalProperties, "4.0", new ProjectCollection());
project.FullPath = "foo";
ProjectInstance instance = project.CreateProjectInstance();
BuildRequestConfiguration configuration = new BuildRequestConfiguration(new BuildRequestData(instance, new string[] { }, null), "2.0");
string originalTmp = Environment.GetEnvironmentVariable("TMP");
string originalTemp = Environment.GetEnvironmentVariable("TEMP");
try
{
string problematicTmpPath = @"C:\Users\}\blabla\temp";
Environment.SetEnvironmentVariable("TMP", problematicTmpPath);
Environment.SetEnvironmentVariable("TEMP", problematicTmpPath);
FileUtilities.ClearCacheDirectoryPath();
string cacheFilePath = configuration.GetCacheFile();
Assert.True(cacheFilePath.StartsWith(problematicTmpPath, StringComparison.OrdinalIgnoreCase));
}
finally
{
Environment.SetEnvironmentVariable("TMP", originalTmp);
Environment.SetEnvironmentVariable("TEMP", originalTemp);
FileUtilities.ClearCacheDirectoryPath();
}
}
/// <summary>
/// Get a single item instance
/// </summary>
private static ProjectItemInstance GetItemInstance()
{
Project project = new Project();
ProjectInstance projectInstance = project.CreateProjectInstance();
ProjectItemInstance item = projectInstance.AddItem("i", "i1");
return item;
}
/// <summary>
/// Creates a dummy project instance.
/// </summary>
public ProjectInstance CreateDummyProject(string fileName)
{
string contents = ObjectModelHelpers.CleanupFileContents(@"
<Project xmlns='msbuildnamespace' ToolsVersion='msbuilddefaulttoolsversion'>
<Target Name='test'>
</Target>
</Project>
");
Project project = new Project(new XmlTextReader(new StringReader(contents)), new Dictionary<string, string>(), "4.0");
project.FullPath = fileName;
ProjectInstance instance = project.CreateProjectInstance();
return instance;
}
