public void OutputPropertyExists ()
{
string project_xml = @"
<Project DefaultTargets='Build' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<PropertyGroup>
<C>False</C>
</PropertyGroup>
<Target Name='Build' DependsOnTargets='ResolveReferences' />
<Target Name='Build2' DependsOnTargets='Bar' />
<Target Name='ResolveReferences' DependsOnTargets='Foo;Bar' />
<Target Name='Foo'>
<CreateProperty Value='True'>
<Output TaskParameter='Value' PropertyName='C' />
</CreateProperty>
</Target>
<Target Name='Bar' Condition='!($(C))' DependsOnTargets='ResolveReferences'>
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader(project_xml));
var root = ProjectRootElement.Create (xml);
var proj = new ProjectInstance (root);
Assert.AreEqual (5, proj.Targets.Count, "#1");
var foo = proj.Targets ["Foo"];
Assert.IsNotNull (foo, "#2");
Assert.AreEqual (1, foo.Tasks.Count, "#3");
var cp = foo.Tasks.First ();
Assert.AreEqual (1, cp.Outputs.Count, "#4");
var po = cp.Outputs.First () as ProjectTaskOutputPropertyInstance;
Assert.IsNotNull (po, "#5");
Assert.AreEqual ("C", po.PropertyName, "#5");
proj.Build ("Build", null);
Assert.AreEqual (string.Empty, foo.Outputs, "#6");
Assert.AreEqual ("True", proj.GetPropertyValue ("C"), "#7");
}
public Microsoft.Expression.Project.Build.BuildResult Build(IEnumerable <ILogger> loggers, params string[] targetNames)
{
Microsoft.Build.Execution.ProjectInstance projectInstance = new Microsoft.Build.Execution.ProjectInstance(this.CreateProject());
string[] strArrays = new string[] { "ResolveReferences", "MarkupCompilePass1" };
if (projectInstance.Build(strArrays, loggers))
{
return(Microsoft.Expression.Project.Build.BuildResult.Succeeded);
}
return(Microsoft.Expression.Project.Build.BuildResult.Failed);
}
public void BuildDoesNotIncreaseCollectionContent ()
{
string empty_project_xml = "<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' />";
var xml = XmlReader.Create (new StringReader (empty_project_xml));
var root = ProjectRootElement.Create (xml);
var coll = new ProjectCollection ();
var inst = new ProjectInstance (root, null, null, coll);
root.FullPath = "ProjectCollectionTest.BuildDoesNotIncreaseCollectionContent.proj";
Assert.AreEqual (0, coll.Count, "#1");
inst.Build ();
Assert.AreEqual (0, coll.Count, "#2");
}
public void TaskOutputsToLoggers ()
{
string project_xml = @"<Project DefaultTargets='Foo' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Import Project='$(MSBuildToolsPath)\Microsoft.Common.targets' />
<Target Name='Foo'>
<ItemGroup>
<Foo Condition='$(X)' Include='foo.txt' />
</ItemGroup>
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = "BuildSubmissionTest.TaskOutputsToLoggers.proj";
var proj = new ProjectInstance (root);
Assert.AreEqual ("$(X)", root.Targets.First ().ItemGroups.First ().Items.First ().Condition, "#0");
var sw = new StringWriter ();
Assert.IsFalse (proj.Build (new ILogger [] {new ConsoleLogger (LoggerVerbosity.Diagnostic, sw.WriteLine, null, null)}), "#1");
Assert.IsTrue (sw.ToString ().Contains ("$(X)"), "#2");
}
public void TestResolveProjectHome() {
var proj = ProjectRootElement.Create();
var g = proj.AddPropertyGroup();
var projectHome = g.AddProperty("ProjectHome", "");
var expected = g.AddProperty("Expected", "");
g.AddProperty("StartupFile", "app.py");
g.AddProperty("_PythonToolsPath", TestData.GetPath(""));
proj.AddImport(TestData.GetPath("Microsoft.PythonTools.targets"));
var target = proj.AddTarget("TestOutput");
foreach (var variable in new[] { "ProjectHome", "QualifiedProjectHome", "StartupFile", "StartupPath", "Expected" }) {
var task = target.AddTask("Message");
task.SetParameter("Importance", "high");
task.SetParameter("Text", string.Format("{0} = $({0})", variable));
}
var errTask = target.AddTask("Error");
errTask.Condition = "$(Expected) != $(QualifiedProjectHome)";
errTask.SetParameter("Text", "Expected did not match QualifiedProjectHome");
var loc = CommonUtils.EnsureEndSeparator(TestData.GetTempPath(randomSubPath: true));
proj.Save(Path.Combine(loc, string.Format("test.proj")));
foreach(var test in new [] {
new { ProjectHome="", Expected=loc },
new { ProjectHome=".", Expected=loc },
new { ProjectHome="..", Expected=CommonUtils.EnsureEndSeparator(Path.GetDirectoryName(Path.GetDirectoryName(loc))) },
new { ProjectHome="\\", Expected=Directory.GetDirectoryRoot(loc) },
new { ProjectHome="abc", Expected=loc + @"abc\" },
new { ProjectHome=@"a\b\c", Expected=loc + @"a\b\c\" },
new { ProjectHome=@"a\b\..\c", Expected=loc + @"a\c\" },
}) {
projectHome.Value = test.ProjectHome;
expected.Value = test.Expected;
var inst = new ProjectInstance(proj);
Assert.IsTrue(inst.Build("TestOutput", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed) }));
}
}
public void ToolsVersionFallbackIfCurrentToolsVersionDoesNotExist_ProjectInstance()
{
ProjectCollection p = new ProjectCollection();
p.RemoveToolset(ObjectModelHelpers.MSBuildDefaultToolsVersion);
MockLogger mockLogger = new MockLogger();
LoggingService service = (LoggingService)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1);
service.RegisterLogger(mockLogger);
bool success = false;
Project project = new Project(XmlReader.Create(new StringReader(@"<Project ToolsVersion='4.0' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Target Name='Foo'>
</Target>
</Project>")), null /* no global properties */, null /* don't explicitly set the toolsversion */, p);
ProjectInstance pi = new ProjectInstance(project.Xml, null /* no global properties */, null /* don't explicitly set the toolsversion */, p);
Assert.AreEqual("4.0", pi.ToolsVersion);
success = pi.Build(new ILogger[] { mockLogger });
Assert.IsTrue(success);
mockLogger.AssertLogContains("\"4.0\"");
mockLogger.AssertLogDoesntContain(ObjectModelHelpers.CleanupFileContents("\"msbuilddefaulttoolsversion\""));
}
public void DependsOnTargets ()
{
string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Target Name='Bar' DependsOnTargets='Foo' />
<Target Name='Foo'>
<Error Text='expected error' />
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = "ProjectInstanceTest.DependsOnTargets.proj";
var proj = new ProjectInstance (root);
Assert.AreEqual (2, proj.Targets.Count, "#1");
Assert.IsFalse (proj.Build ("Bar", new ILogger [0]), "#2");
}
public void InputsAndOutputs ()
{
string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Target Name='Foo' Inputs='inputsandoutputstest.txt' Outputs='inputsandoutputstest.txt'>
<Error Text='error' />
</Target>
</Project>";
try {
if (!File.Exists ("inputsandoutputstest.txt"))
File.CreateText ("inputsandoutputstest.txt").Close ();
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = "ProjectTargetInstanceTest.InputsAndOutputs.proj";
var proj = new ProjectInstance (root);
Assert.IsTrue (proj.Build (), "#1"); // if it does not skip Foo, it results in an error.
} finally {
if (File.Exists ("inputsandoutputstest.txt"))
File.Delete ("inputsandoutputstest.txt");
}
}
public void ConditionalCyclicDependence ()
{
string project_xml = @"<Project DefaultTargets='Build' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<PropertyGroup>
<C>False</C>
</PropertyGroup>
<Target Name='Build' DependsOnTargets='ResolveReferences' />
<Target Name='Build2' DependsOnTargets='Bar' />
<Target Name='ResolveReferences' DependsOnTargets='Foo;Bar' />
<Target Name='Foo'>
<CreateProperty Value='True'>
<Output TaskParameter='Value' PropertyName='C' />
</CreateProperty>
</Target>
<Target Name='Bar' Condition='!($(C))' DependsOnTargets='ResolveReferences'>
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = "ProjectInstanceTest.ConditionalCyclicDependence.proj";
var proj = new ProjectInstance (root, null, "4.0", ProjectCollection.GlobalProjectCollection);
Assert.IsTrue (proj.Build (), "#1");
Assert.IsFalse (proj.Build ("Build2", new ILogger [0]), "#2");
}
public void ItemsAndPostEvaluationCondition ()
{
// target-assigned property X is not considered when evaluating condition for C.
string project_xml = @"<Project DefaultTargets='X;Y' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<ItemGroup>
<A Include='foo.txt' />
<B Condition='False' Include='bar.txt' />
<C Condition=""'$(X)'=='True'"" Include='baz.txt' />
</ItemGroup>
<Target Name='X'>
<CreateProperty Value='True'>
<Output TaskParameter='Value' PropertyName='X' />
</CreateProperty>
</Target>
<Target Name='Y'>
<Error Condition=""'@(C)'==''"" Text='missing C. X is $(X)' />
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = "ProjectInstanceTest.ItemsAndPostEvaluationCondition.proj";
var proj = new ProjectInstance (root);
Assert.AreEqual (1, proj.Items.Count, "Count1");
Assert.IsFalse (proj.Build (), "Build");
Assert.AreEqual (1, proj.Items.Count, "Count2");
}
public void MetadataExpansion ()
{
string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<PropertyGroup>
<X>a/b/c.txt</X>
</PropertyGroup>
<Target Name='Foo'>
<CreateItem Include='$(X)'>
<Output TaskParameter='Include' ItemName='I' />
</CreateItem>
<CreateProperty Value=""@(I->'%(Filename)%(Extension)')"">
<Output TaskParameter='Value' PropertyName='P' />
</CreateProperty>
<Error Text=""Expected 'c.txt' but got '$(P)'"" Condition=""'$(P)'!='c.txt'"" />
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
var p = new ProjectInstance (root);
var sw = new StringWriter ();
var result = p.Build (new ILogger [] { new ConsoleLogger (LoggerVerbosity.Minimal, sw.WriteLine, null, null)});
Assert.IsTrue (result, "#1: " + sw);
}
public void FunctionCall ()
{
string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Target Name='Foo'>
<Warning Text=""$([Microsoft.Build.Utilities.ToolLocationHelper]::GetPathToStandardLibraries ('$(TargetFrameworkIdentifier)', '$(TargetFrameworkVersion)', '$(TargetFrameworkProfile)'))\mscorlib.dll'"" />
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
var p = new ProjectInstance (root, null, "4.0", ProjectCollection.GlobalProjectCollection);
var sw = new StringWriter ();
var result = p.Build (new ILogger [] { new ConsoleLogger (LoggerVerbosity.Minimal, sw.WriteLine, null, null)});
Assert.IsTrue (result, "#1: " + sw);
}
public void BuildNullTargetInArray()
{
Assert.Throws<ArgumentNullException>(() =>
{
ProjectInstance instance = new ProjectInstance(ProjectRootElement.Create());
instance.Build(new string[] { null }, null);
}
);
}
public void BuildNullLoggerInArray()
{
Assert.Throws<ArgumentNullException>(() =>
{
ProjectInstance instance = new ProjectInstance(ProjectRootElement.Create());
instance.Build("t", new ILogger[] { null });
}
);
}
public void BuildNullLoggerInArray()
{
ProjectInstance instance = new ProjectInstance(ProjectRootElement.Create());
instance.Build("t", new ILogger[] { null });
}
public void BuildNullRemoteLoggerInArray()
{
ProjectInstance instance = new ProjectInstance(ProjectRootElement.Create());
instance.Build("t", null, new ForwardingLoggerRecord[] { null });
}
public void BuildNullTargetInArray()
{
ProjectInstance instance = new ProjectInstance(ProjectRootElement.Create());
instance.Build(new string[] { null }, null);
}
public void PhoenixBatchingIssue()
{
ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<ItemGroup>
<CppCompile Include='gen.cpp'/>
<CppCompile Include='def.cpp'>
<ObjectFile>def.obj</ObjectFile>
</CppCompile>
</ItemGroup>
<Target Name='t'>
<ItemGroup>
<CppCompile>
<IncludeInLib Condition=""'%(CppCompile.IncludeInLib)' == ''"">true</IncludeInLib>
</CppCompile>
<CppCompile>
<ObjectFile>%(Filename).obj</ObjectFile>
</CppCompile>
</ItemGroup>
</Target>
</Project>
"))));
ProjectInstance instance = new ProjectInstance(xml);
instance.Build();
Assert.AreEqual(2, instance.Items.Count());
Assert.AreEqual("gen.obj", instance.GetItems("CppCompile").First().GetMetadataValue("ObjectFile"));
Assert.AreEqual("def.obj", instance.GetItems("CppCompile").Last().GetMetadataValue("ObjectFile"));
}
/// <summary>
/// Executes the given target with the given installer instance.
/// </summary>
/// <param name="pi">installer project instance</param>
/// <param name="target">target name</param>
private void Execute(ProjectInstance pi, string target)
{
ILogger msb2l4n = new BuildLogRedirector(_log);
if (!pi.Build(target, new ILogger[] { msb2l4n }))
throw new InstallException("Target '" + target + "' execution failed.");
}
public void InvalidToolsVersionFromEnvironmentVariable_ProjectInstance()
{
string oldDefaultToolsVersion = Environment.GetEnvironmentVariable("MSBUILDDEFAULTTOOLSVERSION");
try
{
Environment.SetEnvironmentVariable("MSBUILDDEFAULTTOOLSVERSION", "foo");
InternalUtilities.RefreshInternalEnvironmentValues();
ProjectCollection p = new ProjectCollection();
MockLogger mockLogger = new MockLogger();
LoggingService service = (LoggingService)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1);
service.RegisterLogger(mockLogger);
bool success = false;
Project project = new Project(XmlReader.Create(new StringReader(@"<Project ToolsVersion='4.0' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Target Name='Foo'>
</Target>
</Project>")), null /* no global properties */, null /* don't explicitly set the toolsversion */, p);
ProjectInstance pi = new ProjectInstance(project.Xml, null /* no global properties */, null /* don't explicitly set the toolsversion */, p);
success = pi.Build(new ILogger[] { mockLogger });
Assert.IsTrue(success);
mockLogger.AssertLogContains("ToolsVersion=\"4.0\"");
// falls back to the current ToolsVersion
mockLogger.AssertLogContains(ObjectModelHelpers.CleanupFileContents("ToolsVersion=\"msbuilddefaulttoolsversion\""));
}
finally
{
Environment.SetEnvironmentVariable("MSBUILDDEFAULTTOOLSVERSION", oldDefaultToolsVersion);
InternalUtilities.RefreshInternalEnvironmentValues();
}
}
public void BuildNullRemoteLoggerInArray()
{
Assert.Throws<ArgumentNullException>(() =>
{
ProjectInstance instance = new ProjectInstance(ProjectRootElement.Create());
instance.Build("t", null, new ForwardingLoggerRecord[] { null });
}
);
}
public void MissingTypeForUsingTaskStillWorks2 ()
{
string thisAssembly = new Uri (GetType ().Assembly.CodeBase).LocalPath;
string project_xml = @"<Project DefaultTargets='X' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<UsingTask AssemblyFile='nonexistent.dll' TaskName='NonExistent' />
<Target Name='X' />
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = "ProjectInstanceTest.MissingTypeForUsingTaskStillWorks2.proj";
var proj = new ProjectInstance (root);
Assert.IsTrue (proj.Build (), "#1");
}
public void TestCommandDefinitions() {
var proj = new ProjectInstance(TestData.GetPath(@"TestData\Targets\Commands1.pyproj"));
Assert.IsTrue(proj.Build("TestCommands", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed) }));
}
public void MultipleBinaryCondition ()
{
string cond = @"$(AndroidIncludeDebugSymbols) == '' And Exists ('$(_IntermediatePdbFile)') And '$(OS)' == 'Windows_NT'";
string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<PropertyGroup>
<X>a/b/c.txt</X>
</PropertyGroup>
<Target Name='Foo'>
<CreateItem Include='$(X)'>
<Output TaskParameter='Include' ItemName='I' />
</CreateItem>
<CreateProperty Value=""@(I->'%(Filename)%(Extension)')"">
<Output TaskParameter='Value' PropertyName='P' />
</CreateProperty>
<Error Text=""Expected 'c.txt' but got '$(P)'"" Condition=""" + cond + @""" />
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
var p = new ProjectInstance (root);
var sw = new StringWriter ();
var result = p.Build (new ILogger [] { new ConsoleLogger (LoggerVerbosity.Minimal, sw.WriteLine, null, null)});
Assert.IsTrue (result, "#1: " + sw);
}
public void TestResolveEnvironmentReference() {
var proj = new ProjectInstance(TestData.GetPath(@"TestData\Targets\EnvironmentReferences1.pyproj"));
Assert.IsTrue(proj.Build("TestResolveEnvironment", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed) }));
}
// To NOT reuse this IBuildEngine instance for different build, we create another BuildManager and BuildSubmisson and then run it.
public bool BuildProjectFile (string projectFileName, string[] targetNames, IDictionary globalProperties, IDictionary targetOutputs, string toolsVersion)
{
toolsVersion = string.IsNullOrEmpty (toolsVersion) ? project.ToolsVersion : toolsVersion;
var globalPropertiesThatMakeSense = new Dictionary<string,string> ();
foreach (DictionaryEntry p in globalProperties)
globalPropertiesThatMakeSense [(string) p.Key] = (string) p.Value;
var projectToBuild = new ProjectInstance (ProjectRootElement.Create (XmlReader.Create (projectFileName)), globalPropertiesThatMakeSense, toolsVersion, Projects);
// Not very sure if ALL of these properties should be added, but some are certainly needed.
foreach (var p in this.project.Properties.Where (p => !globalProperties.Contains (p.Name)))
projectToBuild.SetProperty (p.Name, p.EvaluatedValue);
IDictionary<string,TargetResult> outs;
var ret = projectToBuild.Build (targetNames ?? new string [] {"Build"}, Projects.Loggers, out outs);
foreach (var p in outs)
targetOutputs [p.Key] = p.Value.Items ?? new ITaskItem [0];
return ret;
}
[Category ("NotWorking")] // until we figure out why it fails on wrench.
public void ItemsInTargets ()
{
string project_xml = @"<Project DefaultTargets='Default' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Target Name='Default'>
<PropertyGroup>
<_ExplicitMSCorlibPath>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetPathToStandardLibraries ('$(TargetFrameworkIdentifier)', '$(TargetFrameworkVersion)', '$(TargetFrameworkProfile)'))\mscorlib.dll</_ExplicitMSCorlibPath>
</PropertyGroup>
<ItemGroup>
<_ExplicitReference
Include='$(_ExplicitMSCorlibPath)'
Condition='Exists($(_ExplicitMSCorlibPath))'>
<Private>false</Private>
</_ExplicitReference>
</ItemGroup>
</Target>
<Import Project='$(MSBuildBinPath)\\Microsoft.CSharp.targets' />
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = "ProjectInstanceTest.ConditionalExpression.proj";
var proj = new ProjectInstance (root, null, "4.0", ProjectCollection.GlobalProjectCollection);
proj.Build ();
// make sure the property value expansion is done successfully.
Assert.IsTrue (!string.IsNullOrEmpty (proj.GetPropertyValue ("_ExplicitMSCorlibPath")), "premise: propertyValue by ToolLocationHelper func call");
var items = proj.GetItems ("_ExplicitReference");
// make sure items are stored after build.
Assert.IsTrue (items.Any (), "items.Any");
Assert.IsTrue (!string.IsNullOrEmpty (items.First ().EvaluatedInclude), "item.EvaluatedInclude");
}
// To NOT reuse this IBuildEngine instance for different build, we create another BuildManager and BuildSubmisson and then run it.
public bool BuildProjectFile (string projectFileName, string[] targetNames, IDictionary globalProperties, IDictionary targetOutputs, string toolsVersion)
{
toolsVersion = string.IsNullOrEmpty (toolsVersion) ? project.ToolsVersion : toolsVersion;
var globalPropertiesThatMakeSense = new Dictionary<string,string> ();
foreach (DictionaryEntry p in globalProperties)
globalPropertiesThatMakeSense [(string) p.Key] = (string) p.Value;
var projectToBuild = new ProjectInstance (ProjectRootElement.Create (XmlReader.Create (projectFileName)), globalPropertiesThatMakeSense, toolsVersion, Projects);
IDictionary<string,TargetResult> outs;
var ret = projectToBuild.Build (targetNames ?? new string [] {"Build"}, Projects.Loggers, out outs);
foreach (var p in outs)
targetOutputs [p.Key] = p.Value.Items ?? new ITaskItem [0];
return ret;
}
public void MultipleDefaultTargets ()
{
bool[] expected = { true, false, true };
string [] defaultTargets = {"Foo", "Foo;Bar", "Foo;Bar"};
string [] targets = { string.Empty, string.Empty, "<Target Name='Bar' />" };
for (int i = 0; i < expected.Length; i++) {
string project_xml = string.Format (@"<Project DefaultTargets='{0}' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Import Project='$(MSBuildToolsPath)\Microsoft.Common.targets' />
<Target Name='Foo' />
{1}
</Project>", defaultTargets [i], targets [i]);
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = string.Format ("ProjectInstanceTest.MultipleDefaultTargets.{0}.proj", i);
var proj = new ProjectInstance (root);
Assert.AreEqual ("Foo", proj.DefaultTargets.FirstOrDefault (), "#1-" + i);
Assert.AreEqual (expected [i], proj.Build (), "#2-" + i);
}
}
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 EvaluatePropertyWithQuotation ()
{
string project_xml = @"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<ItemGroup>
<Foo Include='abc/xxx.txt' />
</ItemGroup>
<PropertyGroup>
<B>foobar</B>
</PropertyGroup>
<Target Name='default'>
<CreateProperty Value=""@(Foo->'%(Filename)%(Extension)')"">
<Output TaskParameter='Value' PropertyName='P' />
</CreateProperty>
<CreateProperty Value='$(B)|$(P)'>
<Output TaskParameter='Value' PropertyName='Q' />
</CreateProperty>
</Target>
</Project>";
var xml = XmlReader.Create (new StringReader (project_xml));
var root = ProjectRootElement.Create (xml);
root.FullPath = "ProjectInstanceTest.EvaluatePropertyWithQuotation.proj";
var proj = new ProjectInstance (root);
proj.Build ();
var p = proj.GetProperty ("P");
Assert.AreEqual ("xxx.txt", p.EvaluatedValue, "#1");
var q = proj.GetProperty ("Q");
Assert.AreEqual ("foobar|xxx.txt", q.EvaluatedValue, "#2");
}