public void TestExecution()
{
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='1'>
<Message Text='Text' Importance='Low'/>
<Message Text='Text' Importance='Normal'/>
<Message Text='Text' Importance='High'/>
<Message Text='Text' Importance='low'/>
<Message Text='Text' Importance='normal'/>
<Message Text='Text' Importance='high'/>
<Message Text='Text' />
<Message Text='Text' Importance='weird_importance'/>
</Target>
</Project>
" ;
engine = new Engine(Consts.BinPath);
testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project = engine.CreateNewProject();
project.LoadXml(documentString);
project.Build("1");
Assert.AreEqual(0, testLogger.CheckHead("Text", MessageImportance.Low), "A1");
Assert.AreEqual(0, testLogger.CheckHead("Text", MessageImportance.Normal), "A2");
Assert.AreEqual(0, testLogger.CheckHead("Text", MessageImportance.High), "A3");
Assert.AreEqual(0, testLogger.CheckHead("Text", MessageImportance.Low), "A4");
Assert.AreEqual(0, testLogger.CheckHead("Text", MessageImportance.Normal), "A5");
Assert.AreEqual(0, testLogger.CheckHead("Text", MessageImportance.High), "A6");
Assert.AreEqual(0, testLogger.CheckHead("Text", MessageImportance.Normal), "A7");
Assert.AreEqual(1, testLogger.CheckHead("Text", MessageImportance.Normal), "A8");
}
// test for metadata refs via metadata refs
// batching should happen only on basis of the task attributes,
// and not the resolved expression values
public void TestBatching1()
{
string projectString = projectHeader + @"
<ItemGroup>
<item3 Include=""foo""/>
<item2 Include=""%(item3.Identity)""/>
<item4 Include=""%(item2.Identity);@(item3);@(nonexistant)""/>
<item4 Include=""bar""/>
</ItemGroup>
<Target Name='1'>
<Message Text=""Item4: %(item4.Identity)""/>
</Target>
</Project>";
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
testLogger.CheckLoggedMessageHead("Item4: %(item2.Identity)", "A1");
testLogger.CheckLoggedMessageHead("Item4: foo", "A2");
testLogger.CheckLoggedMessageHead("Item4: bar", "A3");
Assert.AreEqual(0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
void CheckResourceNames (string [,] files, string [] names, string rootNamespace)
{
Assert.AreEqual (files.GetUpperBound (0) + 1, names.Length, "Number of files and names must match");
string projectText = CreateProject (files, rootNamespace);
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger logger = new TestMessageLogger ();
engine.RegisterLogger (logger);
project.LoadXml (projectText);
if (!project.Build ("1")) {
Console.WriteLine (projectText);
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
bool has_targetpaths = files.GetUpperBound (1) == 3;
BuildItemGroup group = project.GetEvaluatedItemsByName ("ResourceNames");
Assert.AreEqual (names.Length, group.Count, "A2");
for (int i = 0; i <= files.GetUpperBound (0); i++) {
Assert.AreEqual (names [i], group [i].FinalItemSpec, "A3 #" + (i + 1));
Assert.AreEqual (files [i, 1] != null, group [i].HasMetadata ("LogicalName"), "A4 #" + (i + 1));
if (files [i, 1] != null)
Assert.AreEqual (files [i, 1], group [i].GetMetadata ("LogicalName"), "A5 #" + (i + 1));
Assert.AreEqual (files [i, 2] != null, group [i].HasMetadata ("DependentUpon"), "A6 #" + (i + 1));
if (files [i, 2] != null)
Assert.AreEqual (files [i, 2], group [i].GetMetadata ("DependentUpon"), "A7 #" + (i + 1));
if (has_targetpaths && files [i, 3] != null)
Assert.AreEqual (files [i, 3], group [i].GetMetadata ("TargetPath"), "A8 #" + (i + 1));
}
}
void CheckLoggedMessageAny(TestMessageLogger logger, string expected, string id)
{
if (logger.CheckAny(expected, MessageImportance.Normal) == 1)
{
Assert.Fail("{0}: Expected message '{1}' was not emitted.", id, expected);
}
}
// test for metadata refs in properties or items
public void TestNoBatching()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<item3 Include=""foo""/>
<item2 Include=""%(item3.Identity)""/>
<item0 Include=""@(item3)""/>
</ItemGroup>
<PropertyGroup>
<Prop1>%(item0.Identity)</Prop1>
</PropertyGroup>
<Target Name='1'>
<Message Text=""Prop1: $(Prop1)""/>
<Message Text=""Item2: @(item2)""/>
</Target>
</Project>";
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
testLogger.CheckLoggedMessageHead("Prop1: %(item0.Identity)", "A1");
testLogger.CheckLoggedMessageHead("Item2: %(item3.Identity)", "A2");
Assert.AreEqual(0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
void CheckEngineEventCounts(TestMessageLogger logger, int target_start, int target_finish, int task_start, int task_finish)
{
Assert.AreEqual(target_start, logger.TargetStarted, "TargetStarted event count doesn't match");
Assert.AreEqual(target_finish, logger.TargetFinished, "TargetFinished event count doesn't match");
Assert.AreEqual(task_start, logger.TaskStarted, "TaskStarted event count doesn't match");
Assert.AreEqual(task_finish, logger.TaskFinished, "TaskFinished event count doesn't match");
}
// test for metadata refs via metadata refs
// batching should happen only on basis of the task attributes,
// and not the resolved expression values
public void TestConditionalBatching2()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" ToolsVersion=""3.5"">
<ItemGroup>
<item2 Include=""%(item3.Identity)""/>
<item4 Include=""%(item2.Identity);@(item3)""/>
</ItemGroup>
<Target Name='1'>
<Message Text=""Item3: %(item2.Identity)"" Condition="" '%(item5.Identity)' == '' ""/>
<Message Text=""Item4: %(item4.Identity)""/>
</Target>
</Project>";
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
testLogger.CheckLoggedMessageHead("Item3: %(item3.Identity)", "A1");
testLogger.CheckLoggedMessageHead("Item4: %(item2.Identity)", "A2");
Assert.AreEqual(0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
public void TestTargetBatching5()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name=""foo"" Inputs=""@(List1)"" Outputs=""%(Culture).foo"">
<Message Text=""TargetStarted""/>
</Target>
</Project>" ;
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
bool res = project.Build("foo");
if (!res)
{
testLogger.DumpMessages();
Assert.Fail("A1: Build failed");
}
Assert.AreEqual(1, testLogger.CheckAny("TargetStarted", MessageImportance.Normal),
"A2: Target should've been skipped because of no inputs");
CheckEngineEventCounts(testLogger, 1, 1, 0, 0);
}
void CreateAndCheckProject(string[] guids, string[] project_ref_guids, string[] messages, bool build_result, string prefix)
{
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
string projectString = CreateProject(guids, project_ref_guids);
project.LoadXml(projectString);
try {
Assert.AreEqual(build_result, project.Build(), "Build " + (build_result ? "failed" : "should've failed"));
if (!build_result || messages == null)
{
// build failed as expected, don't check outputs
return;
}
for (int i = 0; i < messages.Length; i++)
{
testLogger.CheckLoggedMessageHead(messages [i], prefix + i.ToString());
}
Assert.AreEqual(0, testLogger.NormalMessageCount);
} catch (AssertionException) {
Console.WriteLine(projectString);
testLogger.DumpMessages();
throw;
}
}
public void TestCopy_EmptyDestFolder()
{
Engine engine;
Project project;
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<SFiles Include='foo.txt'><Md>1</Md></SFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFolder='@(NonExistant)' DestinationFiles='@(NonExistant)' SkipUnchangedFiles='true' >
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
</Target>
</Project>
" ;
engine = new Engine(Consts.BinPath);
project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(documentString);
if (project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build should have failed");
}
}
public void TestMultipleMetadataReference2()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<GroupA Include=""file1.txt""/>
<GroupA Include=""file2.txt""/>
<GroupA Include=""file3.txt""/>
<GroupA Include=""file3.txt""/>
<GroupA Include=""file4.txt""/>
</ItemGroup>
<ItemGroup>
<GroupB Include=""file1.txt""/>
<GroupB Include=""file3.txt""/>
<GroupB Include=""file5.txt""/>
<GroupC Include=""PreExistingValue""/>
</ItemGroup>
<Target Name=""Build"">
<CreateItem Include=""@(GroupA)"" Condition=""'%(Identity)' != '' and '@(GroupA)' != '' and '@(GroupB)' != ''"" >
<Output TaskParameter=""Include"" ItemName=""GroupC""/>
</CreateItem>
<Message Text=""%(GroupC.Identity)""/>
</Target>
</Project>" ;
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
Assert.IsTrue(project.Build("Build"), "A1: Build failed");
BuildItemGroup include = project.GetEvaluatedItemsByName("GroupC");
Assert.AreEqual(4, include.Count, "A2");
string [,] additional_metadata = new string [, ] {
{ "Identity", "PreExistingValue" }
};
CreateItemTest.CheckBuildItem(include [0], "GroupC", additional_metadata, "PreExistingValue", "A3");
additional_metadata = new string [, ] {
{ "Identity", "file1.txt" }
};
CreateItemTest.CheckBuildItem(include [1], "GroupC", additional_metadata, "file1.txt", "A4");
additional_metadata = new string [, ] {
{ "Identity", "file3.txt" }
};
CreateItemTest.CheckBuildItem(include [2], "GroupC", additional_metadata, "file3.txt", "A5");
CreateItemTest.CheckBuildItem(include [3], "GroupC", additional_metadata, "file3.txt", "A6");
CheckEngineEventCounts(testLogger, 1, 1, 5, 5);
}
public void TestCopy_OverwriteReadOnlyTrue()
{
Engine engine;
Project project;
string file_path = Path.Combine(source_path, "copyro1.txt");
string target_file = Path.Combine(target_path, "copyro1.txt");
using (File.CreateText(file_path)) { }
using (File.CreateText(target_file)) { }
File.SetAttributes(target_file, FileAttributes.ReadOnly);
Assert.AreEqual(FileAttributes.ReadOnly, File.GetAttributes(target_file), "A1");
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" ToolsVersion=""4.0"">
<PropertyGroup><DestFile>" + target_file + @"</DestFile></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_path + @"'><Md>1</Md></SFiles>
<DFiles Include='$(DestFile)'><Mde>2</Mde></DFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFiles='@(DFiles)' OverwriteReadOnlyFiles='true'>
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
<Message Text=""I0 : @(I0), I1: @(I1)""/>
</Target>
</Project>
" ;
engine = new Engine(Consts.BinPath);
project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(documentString);
if (!project.Build("1"))
{
var sb = new StringBuilder();
testLogger.DumpMessages(sb);
Assert.Fail("Build failed " + sb.ToString());
}
Assert.IsTrue(File.Exists(target_file), "A2");
var target_file_attrs = File.GetAttributes(target_file);
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
Assert.AreEqual(FileAttributes.Normal, File.GetAttributes(target_file), "A3");
}
else
{
// On Windows the Archive attribute will be set, not the Normal attribute.
Assert.AreEqual(FileAttributes.Archive, File.GetAttributes(target_file), "A3");
}
}
void CreateProjectAndCheck(string file, string[] lines, bool overwrite, bool use_overwrite, Action action)
{
Engine engine;
Project project;
StringBuilder sb = new StringBuilder();
sb.Append(@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
<ItemGroup>
");
if (lines != null)
{
foreach (string line in lines)
{
sb.AppendFormat("\t\t<Lines Include='{0}'/>\n", line);
}
}
sb.AppendFormat(@"</ItemGroup>
<Target Name='1'>
<WriteLinesToFile File='{0}' Lines='@(Lines)'" , file);
if (use_overwrite)
{
sb.AppendFormat(" Overwrite='{0}' ", overwrite);
}
sb.Append(@"/>
</Target>
</Project>" );
engine = new Engine(Consts.BinPath);
project = engine.CreateNewProject();
TestMessageLogger logger = new TestMessageLogger();
engine.RegisterLogger(logger);
project.LoadXml(sb.ToString());
try {
if (!project.Build("1"))
{
Assert.Fail("Build failed");
}
if (action != null)
{
action.Invoke();
}
} catch (AssertionException) {
logger.DumpMessages();
Console.WriteLine(sb.ToString());
throw;
} finally {
File.Delete(file);
}
}
public void TestPropertiesWithDynamicItems()
{
string projectString = projectHeader + @"
<ItemGroup>
<Item1 Include=""One""/>
<Item1 Include=""Two""/>
<Item2 Include=""Z""/>
<Item2Ref Include=""@(Item2)"" />
</ItemGroup>
<PropertyGroup>
<Prop1>@(Item2)</Prop1>
<Prop2>@(Item2Ref)</Prop2>
</PropertyGroup>
<Target Name='1'>
<Message Text=""Item1: %(Item1.Identity) | Prop1: $(Prop1) | Prop2: $(Prop2)""/>
<Message Text=""Item2: @(Item2) | Item2Ref: @(Item2Ref)""/>
<CreateItem Include=""A;B"">
<Output TaskParameter=""Include"" ItemName=""Item2""/>
</CreateItem>
<Message Text=""Item1: %(Item1.Identity) | Prop1: $(Prop1) | Prop2: $(Prop2)""/>
<Message Text=""Item2: @(Item2) | Item2Ref: @(Item2Ref)""/>
</Target>
</Project>";
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
try
{
testLogger.CheckLoggedMessageHead("Item1: One | Prop1: Z | Prop2: Z", "A1");
testLogger.CheckLoggedMessageHead("Item1: Two | Prop1: Z | Prop2: Z", "A2");
testLogger.CheckLoggedMessageHead("Item2: Z | Item2Ref: Z", "A3");
testLogger.CheckLoggedMessageHead("Item1: One | Prop1: Z;A;B | Prop2: Z", "A4");
testLogger.CheckLoggedMessageHead("Item1: Two | Prop1: Z;A;B | Prop2: Z", "A5");
testLogger.CheckLoggedMessageHead("Item2: Z;A;B | Item2Ref: Z", "A3");
Assert.AreEqual(0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
catch (AssertionException)
{
testLogger.DumpMessages();
throw;
}
}
public void TestFilter()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<fruit Include=""apple"">
<consistency>firm</consistency>
</fruit>
<fruit Include=""orange"">
<consistency>pulpy</consistency>
</fruit>
<fruit Include=""banana"">
<consistency>softish</consistency>
</fruit>
<fruit Include=""pear"">
<consistency>unsound</consistency>
</fruit>
<fruit Include=""apricot"">
<consistency>unsound</consistency>
</fruit>
</ItemGroup>
<Target Name=""Compost"">
<CreateItem Include=""@(fruit)"" Condition=""'%(consistency)' == 'pulpy' or '%(consistency)' == 'unsound' "">
<Output TaskParameter=""Include"" ItemName=""Final""/>
</CreateItem>
</Target>
</Project>" ;
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
Assert.IsTrue(project.Build("Compost"), "A1: Build failed");
BuildItemGroup include = project.GetEvaluatedItemsByName("Final");
Assert.AreEqual(3, include.Count, "A2");
string [,] additional_metadata = new string [, ] {
{ "Identity", "orange" }
};
CreateItemTest.CheckBuildItem(include [0], "Final", additional_metadata, "orange", "A3");
additional_metadata = new string [, ] {
{ "Identity", "pear" }
};
CreateItemTest.CheckBuildItem(include [1], "Final", additional_metadata, "pear", "A4");
additional_metadata = new string [, ] {
{ "Identity", "apricot" }
};
CreateItemTest.CheckBuildItem(include [2], "Final", additional_metadata, "apricot", "A5");
CheckEngineEventCounts(testLogger, 1, 1, 2, 2);
}
public void TestTargetBatching4()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<List1 Include=""fr_a.txt""><Culture>fr</Culture></List1>
<List1 Include=""en_b.txt""><Culture>en</Culture></List1>
<List1 Include=""fr_c.txt""><Culture>fr</Culture></List1>
<List1 Include=""gb_d.txt""><Culture>gb</Culture></List1>
<List2 Include=""fr_x.txt""><Culture>fr</Culture></List2>
<List2 Include=""gb_z.txt""><Culture>gb</Culture></List2>
<Foo Include=""1_a1""><Md>1</Md></Foo>
<Foo Include=""2_b1""><Md>2</Md></Foo>
<Foo Include=""1_c1""><Md>1</Md></Foo>
</ItemGroup>
<Target Name=""foo"" Inputs=""@(List1)"" Outputs=""%(Culture).foo"">
<Message Text=""TargetStarted""/>
<Message Text=""List1: @(List1): %(Culture)""/>
<Message Text=""List2: @(List2): %(Culture)""/>
<Message Text=""Foo: @(Foo): %(Md)""/>
</Target>
</Project>" ;
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
bool res = project.Build("foo");
if (!res)
{
testLogger.DumpMessages();
Assert.Fail("A1: Build failed");
}
CheckLoggedMessagesInOrder(testLogger, new string []
{
"TargetStarted", "List1: fr_a.txt;fr_c.txt: fr",
"List2: fr_x.txt: fr", "List2: gb_z.txt: gb",
"Foo: 1_a1;1_c1: 1", "Foo: 2_b1: 2",
"TargetStarted", "List1: en_b.txt: en",
"List2: fr_x.txt: fr", "List2: gb_z.txt: gb",
"Foo: 1_a1;1_c1: 1", "Foo: 2_b1: 2",
"TargetStarted", "List1: gb_d.txt: gb",
"List2: fr_x.txt: fr", "List2: gb_z.txt: gb",
"Foo: 1_a1;1_c1: 1", "Foo: 2_b1: 2"
}, "A2");
CheckEngineEventCounts(testLogger, 3, 3, 18, 18);
}
public void TestCopy2()
{
Engine engine;
Project project;
string [] file_paths = new string []
{
Path.Combine(source_path, "copy1.txt"),
Path.Combine(source_path, "copy2.txt")
};
using (File.CreateText(file_paths[0])) { }
using (File.CreateText(file_paths[1])) { }
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup><TargetPath>" + target_path + @"</TargetPath></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_paths [0] + @"'><Md>1</Md></SFiles>
<SFiles Include='" + file_paths [1] + @"'><Md>2</Md></SFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFolder='$(TargetPath)' SkipUnchangedFiles='true' >
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
</Target>
</Project>
" ;
engine = new Engine(Consts.BinPath);
project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(documentString);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
CheckCopyBuildItems(project, file_paths, target_path, "A1");
// build again, this time files won't get copied because
// of SkipUnchangedFiles=true
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed #2");
}
CheckCopyBuildItems(project, file_paths, target_path, "A2");
}
public void TestCopy_Retries()
{
Engine engine;
Project project;
string file_path = Path.Combine(source_path, "copyretries.txt");
string target_file = Path.Combine(target_path, "copyretries.txt");
using (File.CreateText(file_path)) { }
using (File.CreateText(target_file)) { }
File.SetAttributes(target_file, FileAttributes.ReadOnly);
Assert.AreEqual(FileAttributes.ReadOnly, File.GetAttributes(target_file), "A1");
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup><DestFile>" + target_file + @"</DestFile></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_path + @"'><Md>1</Md></SFiles>
<DFiles Include='$(DestFile)'><Mde>2</Mde></DFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFiles='@(DFiles)' Retries='3' RetryDelayMilliseconds='2000'>
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
<Message Text=""I0 : @(I0), I1: @(I1)""/>
</Target>
</Project>
" ;
engine = new Engine(Consts.BinPath);
project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(documentString);
// remove the read-only flag from the file after a few secs,
// so copying works after retries
new Thread(() => {
Thread.Sleep(3000);
File.SetAttributes(target_file, FileAttributes.Normal);
}).Start();
if (!project.Build("1"))
{
var sb = new StringBuilder();
testLogger.DumpMessages(sb);
Assert.Fail("Build failed " + sb.ToString());
}
testLogger.CheckLoggedAny("Copying failed. Retries left: 3.", MessageImportance.Normal, "A2");
}
public void TestTargetInvocationFromBatchedTask()
{
string projectString = projectHeader + @"
<ItemGroup>
<Item1 Include=""One""/>
<Item1 Include=""Two""/>
<Item1Ref Include=""@(Item1)"" />
</ItemGroup>
<PropertyGroup>
<Prop1>@(Item1)</Prop1>
<Prop2>@(Item1Ref)</Prop2>
</PropertyGroup>
<Target Name='1'>
<CallTarget Targets='foo' Condition="" '%(Item1.Identity)' != ''"" />
<Message Text=""Item1: @(Item1) Item1Ref: @(Item1Ref)""/>
<Message Text=""Prop1: $(Prop1) Prop2: $(Prop2)""/>
</Target>
<Target Name='foo'>
<Message Text=""(foo) Item1: @(Item1) Item1Ref: @(Item1Ref)""/>
<Message Text=""(foo) Prop1: $(Prop1) Prop2: $(Prop2)""/>
</Target>
</Project>";
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
try
{
testLogger.CheckLoggedMessageHead("(foo) Item1: One;Two Item1Ref: One;Two", "A1");
testLogger.CheckLoggedMessageHead("(foo) Prop1: One;Two Prop2: One;Two", "A2");
testLogger.CheckLoggedMessageHead("Item1: One;Two Item1Ref: One;Two", "A3");
testLogger.CheckLoggedMessageHead("Prop1: One;Two Prop2: One;Two", "A4");
Assert.AreEqual(0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
catch (AssertionException)
{
testLogger.DumpMessages();
throw;
}
}
public void TestBatchingWithUnqualifiedMetadataReference()
{
string projectString = projectHeader + @"
<ItemGroup>
<Item1 Include=""One""><Md>1</Md></Item1>
<Item1 Include=""Two""><Md>2</Md></Item1>
<Item1Ref Include=""@(Item1)"" />
<Item2 Include=""Three""><Md>3</Md></Item2>
<Item2 Include=""Four""><Md>4</Md></Item2>
<Item2Ref Include=""@(Item2)"" />
</ItemGroup>
<PropertyGroup>
<Prop1>@(Item1)</Prop1>
<Prop1Ref>@(Item1Ref)</Prop1Ref>
<Prop2>@(Item2)</Prop2>
<Prop2Ref>@(Item2Ref)</Prop2Ref>
</PropertyGroup>
<Target Name='1'>
<Message Text=""For md: %(Md) Item1: @(Item1) Item1Ref: @(Item1Ref) Item2: @(Item2) Item2Ref: @(Item2Ref) " +
@" Prop1: $(Prop1) Prop1Ref: $(Prop1Ref) Prop2: $(Prop2) Prop2Ref: $(Prop2Ref)""/>
</Target>
</Project>";
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
try
{
testLogger.CheckLoggedAny("For md: 3 Item1: Item1Ref: Item2: Three Item2Ref: Three Prop1: Prop1Ref: Prop2: Three Prop2Ref: Three", MessageImportance.Normal, "A1");
testLogger.CheckLoggedAny("For md: 4 Item1: Item1Ref: Item2: Four Item2Ref: Four Prop1: Prop1Ref: Prop2: Four Prop2Ref: Four", MessageImportance.Normal, "A2");
testLogger.CheckLoggedAny("For md: 1 Item1: One Item1Ref: One Item2: Item2Ref: Prop1: One Prop1Ref: One Prop2: Prop2Ref: ", MessageImportance.Normal, "A3");
testLogger.CheckLoggedAny("For md: 2 Item1: Two Item1Ref: Two Item2: Item2Ref: Prop1: Two Prop1Ref: Two Prop2: Prop2Ref: ", MessageImportance.Normal, "A4");
Assert.AreEqual(0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
catch (AssertionException)
{
testLogger.DumpMessages();
throw;
}
}
public void TestBeforeAndAfterTargets()
{
Engine engine;
Project project;
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" ToolsVersion=""4.0"">
<Target Name=""DefaultBeforeTarget1"" BeforeTargets=""Default"">
<Message Text=""Hello from DefaultBeforeTarget1""/>
</Target>
<Target Name=""DefaultBeforeTarget2"" BeforeTargets=""Default;Default;NonExistant"">
<Message Text=""Hello from DefaultBeforeTarget2""/>
</Target>
<Target Name=""DefaultAfterTarget"" AfterTargets=""Default ; Foo"">
<Message Text=""Hello from DefaultAfterTarget""/>
</Target>
<Target Name=""Default"" DependsOnTargets=""DefaultDependsOn"">
<Message Text=""Hello from Default""/>
</Target>
<Target Name=""DefaultDependsOn"">
<Message Text=""Hello from DefaultDependsOn""/>
</Target>
</Project>" ;
engine = new Engine();
project = engine.CreateNewProject();
project.LoadXml(projectString);
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger();
engine.RegisterLogger(logger);
if (!project.Build("Default"))
{
logger.DumpMessages();
Assert.Fail("Build failed");
}
logger.CheckLoggedMessageHead("Hello from DefaultDependsOn", "A1");
logger.CheckLoggedMessageHead("Hello from DefaultBeforeTarget1", "A1");
logger.CheckLoggedMessageHead("Hello from DefaultBeforeTarget2", "A1");
logger.CheckLoggedMessageHead("Hello from Default", "A1");
logger.CheckLoggedMessageHead("Hello from DefaultAfterTarget", "A1");
Assert.AreEqual(0, logger.NormalMessageCount, "Unexpected messages found");
//warnings for referencing unknown targets: NonExistant and Foo
Assert.AreEqual(2, logger.WarningsCount, "Expected warnings not raised");
}
public void TestMultiItemCollections()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ResXFile Include=""Item1"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item2"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item3"">
<Culture>en</Culture>
</ResXFile>
<ResXFile Include=""Item4"">
<Culture>gb</Culture>
</ResXFile>
<ResXFile Include=""Item6"">
<Culture>it</Culture>
</ResXFile>
<NonResXFile Include=""Item7"">
<Culture>it</Culture>
</NonResXFile>
<NonResXFile Include=""Item8"">
<Culture>en</Culture>
</NonResXFile>
<NonResXFile Include=""Item9"">
<Culture>en</Culture>
</NonResXFile>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message
Text = ""Culture: %(Culture) -- ResXFiles: @(ResXFile) NonResXFiles: @(NonResXFile)"" />
</Target>
</Project>" ;
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
Assert.IsTrue(project.Build("ShowMessage"), "A1: Build failed");
CheckMessage2(testLogger, "fr", "Item1;Item2", string.Empty, "A2");
CheckMessage2(testLogger, "en", "Item3", "Item8;Item9", "A3");
CheckMessage2(testLogger, "gb", "Item4", string.Empty, "A4");
CheckMessage2(testLogger, "it", "Item6", "Item7", "A6");
CheckEngineEventCounts(testLogger, 1, 1, 4, 4);
}
public void TestItemsWithWildcards()
{
Engine engine = new Engine(Consts.BinPath);
Project proj = engine.CreateNewProject();
TestMessageLogger logger = new TestMessageLogger();
engine.RegisterLogger(logger);
// Setup
string projectdir = Path.Combine("Test", "resources");
string basedir = "dir";
string aaa = PathCombine(basedir, "a", "aa", "aaa");
string bb = PathCombine(basedir, "b", "bb");
string c = PathCombine(basedir, "c");
string[] dirs = { aaa, bb, c };
string[] files =
{
PathCombine(aaa, "foo.dll"),
PathCombine(bb, "bar.dll"),
PathCombine(bb, "sample.txt"),
Path.Combine(basedir, "xyz.dll")
};
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
<Target Name='Main'>
<CreateItem Include='dir\**'>
<Output TaskParameter='Include' ItemName='CI1' />
</CreateItem>
<Message Text=""CI1: @(CI1)""/>
</Target>
</Project>" ;
try {
CreateDirectoriesAndFiles(projectdir, dirs, files);
File.WriteAllText(Path.Combine(projectdir, "wild1.proj"), documentString);
proj.Load(Path.Combine(projectdir, "wild1.proj"));
if (!proj.Build("Main"))
{
Assert.Fail("Build failed");
}
string full_base_dir = Path.GetFullPath(basedir);
logger.CheckLoggedAny("CI1: " + String.Join(";", files), MessageImportance.Normal, "A1");
} catch (AssertionException) {
logger.DumpMessages();
throw;
} finally {
Directory.Delete(Path.Combine(projectdir, basedir), true);
}
}
void CheckOutput(string[] primary_list, string[] secondary_list, string expected)
{
StringBuilder sb = new StringBuilder();
sb.Append(@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + ">");
sb.Append("\t<ItemGroup>");
if (primary_list != null)
{
foreach (string s in primary_list)
{
sb.AppendFormat("\t\t<List1 Include=\"{0}\"><Source>List1</Source></List1>", s);
}
}
if (secondary_list != null)
{
foreach (string s in secondary_list)
{
sb.AppendFormat("\t\t<List2 Include=\"{0}\"><Source>List2</Source></List2>", s);
}
}
sb.Append("\t</ItemGroup>");
sb.Append(@"
<Target Name='1'>
<FindAppConfigFile PrimaryList=""@(List1)"" SecondaryList=""@(List2)"" TargetPath=""Foo.exe.config"">
<Output TaskParameter=""AppConfigFile"" ItemName=""AppConfigWithTargetPath""/>
</FindAppConfigFile>
<Message Text=""AppConfigWithTargetPath: %(AppConfigWithTargetPath.Identity) %(AppConfigWithTargetPath.Source) %(AppConfigWithTargetPath.TargetPath)""/>
</Target>
</Project>" );
string projectXml = sb.ToString();
Engine engine = new Engine(Consts.BinPath);
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
Project project = engine.CreateNewProject();
project.LoadXml(projectXml);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
testLogger.DumpMessages();
Assert.AreEqual(1, testLogger.NormalMessageCount, "Expected number of messages");
testLogger.CheckLoggedMessageHead(expected, "A1");
}
public void TestConditionalBatching()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ResXFile Include=""Item1"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item2"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item3"">
<Culture>en</Culture>
</ResXFile>
<ResXFile Include=""Item4"">
<Culture>gb</Culture>
</ResXFile>
<ResXFile Include=""Item6"">
<Culture>it</Culture>
</ResXFile>
<NonResXFile Include=""Item7"">
<Culture>it</Culture>
</NonResXFile>
<NonResXFile Include=""Item8"">
<Culture>en</Culture>
</NonResXFile>
<NonResXFile Include=""Item9"">
<Culture>en</Culture>
</NonResXFile>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message
Text = ""ResXFiles: @(ResXFile) NonResXFiles: @(NonResXFile)""
Condition = ""'%(Culture)' == 'fr'""/>
</Target>
</Project>" ;
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
Assert.IsTrue(project.Build("ShowMessage"), "A1: Build failed");
testLogger.CheckLoggedMessageHead("ResXFiles: Item1;Item2 NonResXFiles: ", "A2");
CheckEngineEventCounts(testLogger, 1, 1, 1, 1);
}
public void TestOverridingTargets()
{
Engine engine;
Project project;
string second = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='BeforeBuild'/>
<Target Name='AfterBuild'/>
<Target Name='Build' DependsOnTargets='BeforeBuild'>
<Message Text='Build executing'/>
<CallTarget Targets='AfterBuild'/>
</Target>
</Project>" ;
using (StreamWriter sw = new StreamWriter(Path.Combine("Test", Path.Combine("resources", "second.proj")))) {
sw.Write(second);
}
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='AfterBuild'>
<Message Text='Overriding AfterBuild'/>
</Target>
<Import Project='Test/resources/second.proj'/>
<Target Name='BeforeBuild'>
<Message Text='Overriding BeforeBuild'/>
</Target>
</Project>" ;
engine = new Engine(Consts.BinPath);
project = engine.CreateNewProject();
project.LoadXml(documentString);
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger();
engine.RegisterLogger(logger);
bool result = project.Build("Build");
if (!result)
{
logger.DumpMessages();
Assert.Fail("Build failed");
}
logger.CheckLoggedMessageHead("Overriding BeforeBuild", "A1");
logger.CheckLoggedMessageHead("Build executing", "A1");
Assert.AreEqual(0, logger.NormalMessageCount, "Unexpected extra messages found");
}
public void TestMultipleMetadataReference()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ExampColl Include=""Item1"">
<Number>1</Number>
</ExampColl>
<ExampColl Include=""Item2"">
<Number>2</Number>
</ExampColl>
<ExampColl Include=""Item3"">
<Number>1</Number>
</ExampColl>
<ExampColl2 Include=""Item4"">
<Number>1</Number>
</ExampColl2>
<ExampColl2 Include=""Item5"">
<Number>2</Number>
<Color>Red</Color>
</ExampColl2>
<ExampColl2 Include=""Item6"">
<Number>3</Number>
<Color>Green</Color>
</ExampColl2>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message Text = ""Number: %(Number) Color: %(ExampColl2.Color)-- Items in ExampColl: @(ExampColl) ExampColl2: @(ExampColl2)""/>
</Target>
</Project>" ;
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
Assert.IsTrue(project.Build("ShowMessage"), "A1: Build failed");
CheckLoggedMessageAny(testLogger, "Number: 1 Color: -- Items in ExampColl: Item1;Item3 ExampColl2: Item4", "A2");
CheckLoggedMessageAny(testLogger, "Number: 2 Color: Red-- Items in ExampColl: ExampColl2: Item5", "A3");
CheckLoggedMessageAny(testLogger, "Number: 3 Color: Green-- Items in ExampColl: ExampColl2: Item6", "A4");
CheckLoggedMessageAny(testLogger, "Number: 2 Color: -- Items in ExampColl: Item2 ExampColl2: ", "A5");
Assert.AreEqual(0, testLogger.NormalMessageCount, "A6");
Assert.AreEqual(0, testLogger.WarningMessageCount, "A7");
CheckEngineEventCounts(testLogger, 1, 1, 4, 4);
}
void LoadAndBuildProject(string [] files_list)
{
string projectText = CreateProjectString(files_list);
project.LoadXml(projectText);
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("A1 : Error in building");
}
}
void CheckLoggedMessagesInOrder(TestMessageLogger logger, string [] values, string prefix)
{
try {
for (int i = 0; i < values.Length; i++)
{
logger.CheckLoggedMessageHead(values [i], prefix + "#" + i);
}
if (logger.NormalMessageCount > 0)
{
Assert.Fail("{0}: Expected {1} messages, but found {2}",
prefix, values.Length, values.Length + logger.NormalMessageCount);
}
} catch (NUnit.Framework.AssertionException) {
logger.DumpMessages();
throw;
}
}
public void Test1 ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ResXFile Include=""Item1"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item2"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item3"">
<Culture>en</Culture>
</ResXFile>
<ResXFile Include=""Item4"">
<Culture>gb</Culture>
</ResXFile>
<ResXFile Include=""Item5"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item6"">
<Culture>it</Culture>
</ResXFile>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message
Text = ""Culture: %(ResXFile.Culture) -- ResXFile: @(ResXFile)"" />
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
CheckMessage (testLogger, "fr", "Item1;Item2;Item5", "A2");
CheckMessage (testLogger, "en", "Item3", "A3");
CheckMessage (testLogger, "gb", "Item4", "A4");
CheckMessage (testLogger, "it", "Item6", "A5");
CheckEngineEventCounts (testLogger, 1, 1, 4, 4);
}
public void TestPropertiesWithBatchedReferences()
{
string projectString = projectHeader + @"
<ItemGroup>
<Item1 Include=""One""/>
<Item1 Include=""Two""/>
<Item1Ref Include=""@(Item1)""/>
</ItemGroup>
<PropertyGroup>
<Prop1>@(Item1)</Prop1>
<Prop2>@(Item1Ref)</Prop2>
</PropertyGroup>
<Target Name='1'>
<Message Text=""Item1: %(Item1.Identity) | Prop1: $(Prop1) | Prop2: $(Prop2)""/>
</Target>
</Project>";
Engine engine = new Engine(Consts.BinPath);
Project project = engine.CreateNewProject();
TestMessageLogger testLogger = new TestMessageLogger();
engine.RegisterLogger(testLogger);
project.LoadXml(projectString);
if (!project.Build("1"))
{
testLogger.DumpMessages();
Assert.Fail("Build failed");
}
try
{
testLogger.CheckLoggedMessageHead("Item1: One | Prop1: One | Prop2: One;Two", "A1");
testLogger.CheckLoggedMessageHead("Item1: Two | Prop1: Two | Prop2: One;Two", "A2");
Assert.AreEqual(0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
catch (AssertionException)
{
testLogger.DumpMessages();
throw;
}
}
public void TestCopy_OverwriteReadOnlyTrue ()
{
Engine engine;
Project project;
string file_path = Path.Combine (source_path, "copyro1.txt");
string target_file = Path.Combine (target_path, "copyro1.txt");
using (File.CreateText (file_path)) { }
using (File.CreateText (target_file)) { }
File.SetAttributes (target_file, FileAttributes.ReadOnly);
Assert.AreEqual (FileAttributes.ReadOnly, File.GetAttributes (target_file), "A1");
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" ToolsVersion=""4.0"">
<PropertyGroup><DestFile>" + target_file + @"</DestFile></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_path + @"'><Md>1</Md></SFiles>
<DFiles Include='$(DestFile)'><Mde>2</Mde></DFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFiles='@(DFiles)' OverwriteReadOnlyFiles='true'>
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
<Message Text=""I0 : @(I0), I1: @(I1)""/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (documentString);
if (!project.Build ("1")) {
var sb = new StringBuilder ();
testLogger.DumpMessages (sb);
Assert.Fail ("Build failed " + sb.ToString ());
}
Assert.IsTrue (File.Exists (target_file), "A2");
var target_file_attrs = File.GetAttributes (target_file);
if (Environment.OSVersion.Platform == PlatformID.Unix)
Assert.AreEqual (FileAttributes.Normal, File.GetAttributes (target_file), "A3");
else
// On Windows the Archive attribute will be set, not the Normal attribute.
Assert.AreEqual (FileAttributes.Archive, File.GetAttributes (target_file), "A3");
}
public void TestCopy_EmptyDestFolder () {
Engine engine;
Project project;
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<SFiles Include='foo.txt'><Md>1</Md></SFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFolder='@(NonExistant)' DestinationFiles='@(NonExistant)' SkipUnchangedFiles='true' >
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (documentString);
if (project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build should have failed");
}
}
public void Test4 ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ResXFile Include=""Item1"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item5"" />
<ResXFile Include=""Item6"">
<Culture>it</Culture>
</ResXFile>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message
Text = ""Culture: %(ResXFile.Culture) -- ResXFile: @(ResXFile)"" />
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
//no Culture is specified for "Item5", but
//Culture is being referenced __qualified__, so works
Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
CheckMessage (testLogger, "fr", "Item1", "A2");
CheckMessage (testLogger, "", "Item5", "A3");
CheckMessage (testLogger, "it", "Item6", "A3");
CheckEngineEventCounts (testLogger, 1, 1, 3, 3);
}
void LoadAndBuildProject (string [] files_list)
{
string projectText = CreateProjectString (files_list);
project.LoadXml (projectText);
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("A1 : Error in building");
}
}
public void TestBeforeAndAfterTargets ()
{
Engine engine;
Project project;
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" ToolsVersion=""4.0"">
<Target Name=""DefaultBeforeTarget1"" BeforeTargets=""Default"">
<Message Text=""Hello from DefaultBeforeTarget1""/>
</Target>
<Target Name=""DefaultBeforeTarget2"" BeforeTargets=""Default;Default;NonExistant"">
<Message Text=""Hello from DefaultBeforeTarget2""/>
</Target>
<Target Name=""DefaultAfterTarget"" AfterTargets=""Default ; Foo"">
<Message Text=""Hello from DefaultAfterTarget""/>
</Target>
<Target Name=""Default"" DependsOnTargets=""DefaultDependsOn"">
<Message Text=""Hello from Default""/>
</Target>
<Target Name=""DefaultDependsOn"">
<Message Text=""Hello from DefaultDependsOn""/>
</Target>
</Project>";
engine = new Engine ();
project = engine.CreateNewProject ();
project.LoadXml (projectString);
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
if (!project.Build ("Default")) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
logger.CheckLoggedMessageHead ("Hello from DefaultDependsOn", "A1");
logger.CheckLoggedMessageHead ("Hello from DefaultBeforeTarget1", "A1");
logger.CheckLoggedMessageHead ("Hello from DefaultBeforeTarget2", "A1");
logger.CheckLoggedMessageHead ("Hello from Default", "A1");
logger.CheckLoggedMessageHead ("Hello from DefaultAfterTarget", "A1");
Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected messages found");
//warnings for referencing unknown targets: NonExistant and Foo
Assert.AreEqual (2, logger.WarningsCount, "Expected warnings not raised");
}
public void TestTargetOutputsIncludingMetadata ()
{
Engine engine;
Project project;
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<fruit Include=""apple""><md>a</md></fruit>
<fruit Include=""rhubarb""><md>b</md></fruit>
<fruit Include=""apricot""><md>c</md></fruit>
</ItemGroup>
<Target Name=""Main"">
<CallTarget Targets=""foo"">
<Output TaskParameter=""TargetOutputs"" ItemName=""AllOut""/>
</CallTarget>
<CallTarget Targets=""foo"">
<Output TaskParameter=""TargetOutputs"" ItemName=""AllOut""/>
</CallTarget>
<Message Text=""AllOut: @(AllOut) metadata: %(AllOut.md)""/>
</Target>
<Target Name=""foo"" Outputs=""@(FooItem)"">
<Message Text=""foo called""/>
<CreateItem Include=""@(fruit)"">
<Output TaskParameter=""Include"" ItemName=""FooItem""/>
</CreateItem>
<Message Text=""FooItem: @(FooItem) metadata: %(FooItem.md)""/>
</Target>
</Project>";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
bool result = project.Build ("Main");
if (!result) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
try {
logger.CheckLoggedMessageHead ("foo called", "A1");
logger.CheckLoggedMessageHead ("FooItem: apple metadata: a", "A2");
logger.CheckLoggedMessageHead ("FooItem: rhubarb metadata: b", "A3");
logger.CheckLoggedMessageHead ("FooItem: apricot metadata: c", "A4");
logger.CheckLoggedMessageHead ("AllOut: apple;apple metadata: a", "A5");
logger.CheckLoggedMessageHead ("AllOut: rhubarb;rhubarb metadata: b", "A6");
logger.CheckLoggedMessageHead ("AllOut: apricot;apricot metadata: c", "A7");
Assert.AreEqual (0, logger.NormalMessageCount, "Extra messages found");
Assert.AreEqual (2, logger.TargetStarted, "TargetStarted count");
Assert.AreEqual (2, logger.TargetFinished, "TargetFinished count");
Assert.AreEqual (10, logger.TaskStarted, "TaskStarted count");
Assert.AreEqual (10, logger.TaskFinished, "TaskFinished count");
} catch (AssertionException) {
logger.DumpMessages ();
throw;
}
}
void CheckEngineEventCounts (TestMessageLogger logger, int target_start, int target_finish, int task_start, int task_finish)
{
Assert.AreEqual (target_start, logger.TargetStarted, "TargetStarted event count doesn't match");
Assert.AreEqual (target_finish, logger.TargetFinished, "TargetFinished event count doesn't match");
Assert.AreEqual (task_start, logger.TaskStarted, "TaskStarted event count doesn't match");
Assert.AreEqual (task_finish, logger.TaskFinished, "TaskFinished event count doesn't match");
}
public void TestCopy1 ()
{
Engine engine;
Project project;
string file_path = Path.Combine (source_path, "copy.txt");
string target_file = Path.Combine (target_path, "copy.txt");
using (File.CreateText (file_path)) { }
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup><DestFile>" + target_file + @"</DestFile></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_path + @"'><Md>1</Md></SFiles>
<DFiles Include='$(DestFile)'><Mde>2</Mde></DFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFiles='@(DFiles)' SkipUnchangedFiles='true' >
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
<Message Text=""I0 : @(I0), I1: @(I1)""/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (documentString);
if (!project.Build ("1")) {
var sb = new StringBuilder ();
testLogger.DumpMessages (sb);
Assert.Fail ("Build failed " + sb.ToString ());
}
Assert.IsTrue (File.Exists (target_file), "A2");
BuildItemGroup big = project.GetEvaluatedItemsByName ("I0");
Assert.AreEqual (1, big.Count, "A3");
BuildItem bi = big [0];
Assert.AreEqual (target_file, bi.FinalItemSpec, "A4");
Assert.AreEqual ("1", bi.GetMetadata ("Md"), "A4");
Assert.AreEqual ("2", bi.GetMetadata ("Mde"), "A5");
big = project.GetEvaluatedItemsByName ("I1");
Assert.AreEqual (1, big.Count, "A10");
bi = big [0];
Assert.AreEqual (target_file, bi.FinalItemSpec, "A11");
Assert.AreEqual ("1", bi.GetMetadata ("Md"), "A12");
Assert.AreEqual ("2", bi.GetMetadata ("Mde"), "A13");
// build again, this time files won't get copied because
// of SkipUnchangedFiles=true
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed #2");
}
Assert.IsTrue (File.Exists (target_file), "A20");
big = project.GetEvaluatedItemsByName ("I0");
Assert.AreEqual (1, big.Count, "A21");
bi = big [0];
Assert.AreEqual (target_file, bi.FinalItemSpec, "A22");
Assert.AreEqual ("1", bi.GetMetadata ("Md"), "A23");
Assert.AreEqual ("2", bi.GetMetadata ("Mde"), "A24");
big = project.GetEvaluatedItemsByName ("I1");
Assert.AreEqual (1, big.Count, "A25");
bi = big [0];
Assert.AreEqual (target_file, bi.FinalItemSpec, "A26");
Assert.AreEqual ("1", bi.GetMetadata ("Md"), "A27");
Assert.AreEqual ("2", bi.GetMetadata ("Mde"), "A28");
}
void CreateAndCheckProject (string[] guids, string[] project_ref_guids, string[] messages, bool build_result, string prefix)
{
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
string projectString = CreateProject (guids, project_ref_guids);
project.LoadXml (projectString);
try {
Assert.AreEqual (build_result, project.Build (), "Build " + (build_result ? "failed" : "should've failed"));
if (!build_result || messages == null)
// build failed as expected, don't check outputs
return;
for (int i = 0; i < messages.Length; i++)
testLogger.CheckLoggedMessageHead (messages [i], prefix + i.ToString ());
Assert.AreEqual (0, testLogger.NormalMessageCount);
} catch (AssertionException) {
Console.WriteLine (projectString);
testLogger.DumpMessages ();
throw;
}
}
public void TestFilter ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<fruit Include=""apple"">
<consistency>firm</consistency>
</fruit>
<fruit Include=""orange"">
<consistency>pulpy</consistency>
</fruit>
<fruit Include=""banana"">
<consistency>softish</consistency>
</fruit>
<fruit Include=""pear"">
<consistency>unsound</consistency>
</fruit>
<fruit Include=""apricot"">
<consistency>unsound</consistency>
</fruit>
</ItemGroup>
<Target Name=""Compost"">
<CreateItem Include=""@(fruit)"" Condition=""'%(consistency)' == 'pulpy' or '%(consistency)' == 'unsound' "">
<Output TaskParameter=""Include"" ItemName=""Final""/>
</CreateItem>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
Assert.IsTrue (project.Build ("Compost"), "A1: Build failed");
BuildItemGroup include = project.GetEvaluatedItemsByName ("Final");
Assert.AreEqual (3, include.Count, "A2");
string [,] additional_metadata = new string [,] { { "Identity", "orange" } };
CreateItemTest.CheckBuildItem (include [0], "Final", additional_metadata, "orange", "A3");
additional_metadata = new string [,] { { "Identity", "pear" } };
CreateItemTest.CheckBuildItem (include [1], "Final", additional_metadata, "pear", "A4");
additional_metadata = new string [,] { { "Identity", "apricot" } };
CreateItemTest.CheckBuildItem (include [2], "Final", additional_metadata, "apricot", "A5");
CheckEngineEventCounts (testLogger, 1, 1, 2, 2);
}
public void TestIdentity ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ExampColl Include=""Item1""/>
<ExampColl Include=""Item2""/>
<ExampColl Include=""Item3""/>
<ExampColl Include=""Item4""/>
<ExampColl Include=""Item4""/>
<ExampColl Include=""Item5""/>
<ExampColl Include=""Item6""/>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message Text = ""Identity: %(IdenTIty) -- Items in ExampColl: @(ExampColl)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
CheckLoggedMessageAny (testLogger, "Identity: Item1 -- Items in ExampColl: Item1", "A2");
CheckLoggedMessageAny (testLogger, "Identity: Item2 -- Items in ExampColl: Item2", "A3");
CheckLoggedMessageAny (testLogger, "Identity: Item3 -- Items in ExampColl: Item3", "A4");
CheckLoggedMessageAny (testLogger, "Identity: Item4 -- Items in ExampColl: Item4;Item4", "A5");
CheckLoggedMessageAny (testLogger, "Identity: Item5 -- Items in ExampColl: Item5", "A6");
CheckLoggedMessageAny (testLogger, "Identity: Item6 -- Items in ExampColl: Item6", "A7");
Assert.AreEqual (0, testLogger.NormalMessageCount, "A8");
Assert.AreEqual (0, testLogger.WarningMessageCount, "A7");
CheckEngineEventCounts (testLogger, 1, 1, 6, 6);
}
public void TestCopy_OverwriteReadOnlyFalse ()
{
Engine engine;
Project project;
string file_path = Path.Combine (source_path, "copyro2.txt");
string target_file = Path.Combine (target_path, "copyro2.txt");
using (File.CreateText (file_path)) { }
using (File.CreateText (target_file)) { }
File.SetAttributes (target_file, FileAttributes.ReadOnly);
Assert.AreEqual (FileAttributes.ReadOnly, File.GetAttributes (target_file), "A1");
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup><DestFile>" + target_file + @"</DestFile></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_path + @"'><Md>1</Md></SFiles>
<DFiles Include='$(DestFile)'><Mde>2</Mde></DFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFiles='@(DFiles)'>
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
<Message Text=""I0 : @(I0), I1: @(I1)""/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (documentString);
// build should fail because of the readonly target file
Assert.IsFalse (project.Build ("1"));
File.SetAttributes (target_file, FileAttributes.Normal);
}
public void TestConditionalBatching ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ResXFile Include=""Item1"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item2"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item3"">
<Culture>en</Culture>
</ResXFile>
<ResXFile Include=""Item4"">
<Culture>gb</Culture>
</ResXFile>
<ResXFile Include=""Item6"">
<Culture>it</Culture>
</ResXFile>
<NonResXFile Include=""Item7"">
<Culture>it</Culture>
</NonResXFile>
<NonResXFile Include=""Item8"">
<Culture>en</Culture>
</NonResXFile>
<NonResXFile Include=""Item9"">
<Culture>en</Culture>
</NonResXFile>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message
Text = ""ResXFiles: @(ResXFile) NonResXFiles: @(NonResXFile)""
Condition = ""'%(Culture)' == 'fr'""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
testLogger.CheckLoggedMessageHead ("ResXFiles: Item1;Item2 NonResXFiles: ", "A2");
CheckEngineEventCounts (testLogger, 1, 1, 1, 1);
}
public void TestCopy_Retries ()
{
Engine engine;
Project project;
string file_path = Path.Combine (source_path, "copyretries.txt");
string target_file = Path.Combine (target_path, "copyretries.txt");
using (File.CreateText (file_path)) { }
using (File.CreateText (target_file)) { }
File.SetAttributes (target_file, FileAttributes.ReadOnly);
Assert.AreEqual (FileAttributes.ReadOnly, File.GetAttributes (target_file), "A1");
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup><DestFile>" + target_file + @"</DestFile></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_path + @"'><Md>1</Md></SFiles>
<DFiles Include='$(DestFile)'><Mde>2</Mde></DFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFiles='@(DFiles)' Retries='3' RetryDelayMilliseconds='2000'>
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
<Message Text=""I0 : @(I0), I1: @(I1)""/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (documentString);
// remove the read-only flag from the file after a few secs,
// so copying works after retries
new Thread ( () => {
Thread.Sleep (3000);
File.SetAttributes (target_file, FileAttributes.Normal);
}).Start ();
if (!project.Build ("1")) {
var sb = new StringBuilder ();
testLogger.DumpMessages (sb);
Assert.Fail ("Build failed " + sb.ToString ());
}
testLogger.CheckLoggedAny ("Copying failed. Retries left: 3.", MessageImportance.Normal, "A2");
}
public void TestMultipleMetadataReference ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ExampColl Include=""Item1"">
<Number>1</Number>
</ExampColl>
<ExampColl Include=""Item2"">
<Number>2</Number>
</ExampColl>
<ExampColl Include=""Item3"">
<Number>1</Number>
</ExampColl>
<ExampColl2 Include=""Item4"">
<Number>1</Number>
</ExampColl2>
<ExampColl2 Include=""Item5"">
<Number>2</Number>
<Color>Red</Color>
</ExampColl2>
<ExampColl2 Include=""Item6"">
<Number>3</Number>
<Color>Green</Color>
</ExampColl2>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message Text = ""Number: %(Number) Color: %(ExampColl2.Color)-- Items in ExampColl: @(ExampColl) ExampColl2: @(ExampColl2)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
CheckLoggedMessageAny (testLogger, "Number: 1 Color: -- Items in ExampColl: Item1;Item3 ExampColl2: Item4", "A2");
CheckLoggedMessageAny (testLogger, "Number: 2 Color: Red-- Items in ExampColl: ExampColl2: Item5", "A3");
CheckLoggedMessageAny (testLogger, "Number: 3 Color: Green-- Items in ExampColl: ExampColl2: Item6", "A4");
CheckLoggedMessageAny (testLogger, "Number: 2 Color: -- Items in ExampColl: Item2 ExampColl2: ", "A5");
Assert.AreEqual (0, testLogger.NormalMessageCount, "A6");
Assert.AreEqual (0, testLogger.WarningMessageCount, "A7");
CheckEngineEventCounts (testLogger, 1, 1, 4, 4);
}
public void TestPropertiesWithDynamicItems () {
string projectString = projectHeader + @"
<ItemGroup>
<Item1 Include=""One""/>
<Item1 Include=""Two""/>
<Item2 Include=""Z""/>
<Item2Ref Include=""@(Item2)"" />
</ItemGroup>
<PropertyGroup>
<Prop1>@(Item2)</Prop1>
<Prop2>@(Item2Ref)</Prop2>
</PropertyGroup>
<Target Name='1'>
<Message Text=""Item1: %(Item1.Identity) | Prop1: $(Prop1) | Prop2: $(Prop2)""/>
<Message Text=""Item2: @(Item2) | Item2Ref: @(Item2Ref)""/>
<CreateItem Include=""A;B"">
<Output TaskParameter=""Include"" ItemName=""Item2""/>
</CreateItem>
<Message Text=""Item1: %(Item1.Identity) | Prop1: $(Prop1) | Prop2: $(Prop2)""/>
<Message Text=""Item2: @(Item2) | Item2Ref: @(Item2Ref)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed");
}
try {
testLogger.CheckLoggedMessageHead ("Item1: One | Prop1: Z | Prop2: Z", "A1");
testLogger.CheckLoggedMessageHead ("Item1: Two | Prop1: Z | Prop2: Z", "A2");
testLogger.CheckLoggedMessageHead ("Item2: Z | Item2Ref: Z", "A3");
testLogger.CheckLoggedMessageHead ("Item1: One | Prop1: Z;A;B | Prop2: Z", "A4");
testLogger.CheckLoggedMessageHead ("Item1: Two | Prop1: Z;A;B | Prop2: Z", "A5");
testLogger.CheckLoggedMessageHead ("Item2: Z;A;B | Item2Ref: Z", "A3");
Assert.AreEqual (0, testLogger.NormalMessageCount, "Unexpected extra messages found");
} catch (AssertionException) {
testLogger.DumpMessages ();
throw;
}
}
public void TestTargetInvocationFromBatchedTarget () {
string projectString = projectHeader + @"
<ItemGroup>
<Item1 Include=""One""/>
<Item1 Include=""Two""/>
<Item1Ref Include=""@(Item1)"" />
</ItemGroup>
<PropertyGroup>
<Prop1>@(Item1)</Prop1>
<Prop2>@(Item1Ref)</Prop2>
</PropertyGroup>
<Target Name='1' Inputs=""%(Item1.Identity)"" Outputs=""Nonexistant.foobar"">
<Message Text=""Item1: @(Item1) Item1Ref: @(Item1Ref)""/>
<Message Text=""Prop1: $(Prop1) Prop2: $(Prop2)""/>
<CallTarget Targets='foo' />
<Message Text=""Item1: @(Item1) Item1Ref: @(Item1Ref)""/>
<Message Text=""Prop1: $(Prop1) Prop2: $(Prop2)""/>
</Target>
<Target Name='foo' Condition="" '@(Item1)' != 'One' "">
<Message Text=""(foo) Item1: @(Item1) Item1Ref: @(Item1Ref)""/>
<Message Text=""(foo) Prop1: $(Prop1) Prop2: $(Prop2)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed");
}
try {
testLogger.CheckLoggedMessageHead ("Item1: One Item1Ref: One;Two", "A1");
testLogger.CheckLoggedMessageHead ("Prop1: One Prop2: One;Two", "A2");
testLogger.CheckLoggedMessageHead ("(foo) Item1: One;Two Item1Ref: One;Two", "A3");
testLogger.CheckLoggedMessageHead ("(foo) Prop1: One;Two Prop2: One;Two", "A4");
testLogger.CheckLoggedMessageHead ("Item1: One Item1Ref: One;Two", "A5");
testLogger.CheckLoggedMessageHead ("Prop1: One Prop2: One;Two", "A6");
//second batch, foo has already run, so doesn't execute again
testLogger.CheckLoggedMessageHead ("Item1: Two Item1Ref: One;Two", "A7");
testLogger.CheckLoggedMessageHead ("Prop1: Two Prop2: One;Two", "A8");
testLogger.CheckLoggedMessageHead ("Item1: Two Item1Ref: One;Two", "A9");
testLogger.CheckLoggedMessageHead ("Prop1: Two Prop2: One;Two", "A10");
Assert.AreEqual (0, testLogger.NormalMessageCount, "Unexpected extra messages found");
} catch (AssertionException) {
testLogger.DumpMessages ();
throw;
}
}
TestMessageLogger CreateLogger (string projectXml)
{
var logger = new TestMessageLogger ();
var result = Build (projectXml, logger);
if (!result) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
return logger;
}
public void TestBatchingWithUnqualifiedMetadataReference () {
string projectString = projectHeader + @"
<ItemGroup>
<Item1 Include=""One""><Md>1</Md></Item1>
<Item1 Include=""Two""><Md>2</Md></Item1>
<Item1Ref Include=""@(Item1)"" />
<Item2 Include=""Three""><Md>3</Md></Item2>
<Item2 Include=""Four""><Md>4</Md></Item2>
<Item2Ref Include=""@(Item2)"" />
</ItemGroup>
<PropertyGroup>
<Prop1>@(Item1)</Prop1>
<Prop1Ref>@(Item1Ref)</Prop1Ref>
<Prop2>@(Item2)</Prop2>
<Prop2Ref>@(Item2Ref)</Prop2Ref>
</PropertyGroup>
<Target Name='1'>
<Message Text=""For md: %(Md) Item1: @(Item1) Item1Ref: @(Item1Ref) Item2: @(Item2) Item2Ref: @(Item2Ref) " +
@" Prop1: $(Prop1) Prop1Ref: $(Prop1Ref) Prop2: $(Prop2) Prop2Ref: $(Prop2Ref)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed");
}
try {
testLogger.CheckLoggedAny ("For md: 3 Item1: Item1Ref: Item2: Three Item2Ref: Three Prop1: Prop1Ref: Prop2: Three Prop2Ref: Three", MessageImportance.Normal, "A1");
testLogger.CheckLoggedAny ("For md: 4 Item1: Item1Ref: Item2: Four Item2Ref: Four Prop1: Prop1Ref: Prop2: Four Prop2Ref: Four", MessageImportance.Normal, "A2");
testLogger.CheckLoggedAny ("For md: 1 Item1: One Item1Ref: One Item2: Item2Ref: Prop1: One Prop1Ref: One Prop2: Prop2Ref: ", MessageImportance.Normal, "A3");
testLogger.CheckLoggedAny ("For md: 2 Item1: Two Item1Ref: Two Item2: Item2Ref: Prop1: Two Prop1Ref: Two Prop2: Prop2Ref: ", MessageImportance.Normal, "A4");
Assert.AreEqual (0, testLogger.NormalMessageCount, "Unexpected extra messages found");
} catch (AssertionException) {
testLogger.DumpMessages ();
throw;
}
}
public void TestOverridingTargets ()
{
Engine engine;
Project project;
string second = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='BeforeBuild'/>
<Target Name='AfterBuild'/>
<Target Name='Build' DependsOnTargets='BeforeBuild'>
<Message Text='Build executing'/>
<CallTarget Targets='AfterBuild'/>
</Target>
</Project>";
using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
sw.Write (second);
}
string documentString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<Target Name='AfterBuild'>
<Message Text='Overriding AfterBuild'/>
</Target>
<Import Project='Test/resources/second.proj'/>
<Target Name='BeforeBuild'>
<Message Text='Overriding BeforeBuild'/>
</Target>
</Project>";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
engine.RegisterLogger (logger);
bool result = project.Build ("Build");
if (!result) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
logger.CheckLoggedMessageHead ("Overriding BeforeBuild", "A1");
logger.CheckLoggedMessageHead ("Build executing", "A1");
Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
}
public void TestTargetBatching2 ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<List1 Include=""fr_a.txt""><Culture>fr</Culture></List1>
<List1 Include=""en_b.txt""><Culture>en</Culture></List1>
<List1 Include=""fr_c.txt""><Culture>fr</Culture></List1>
<List1 Include=""gb_d.txt""><Culture>gb</Culture></List1>
<List2 Include=""fr_x.txt""><Culture>fr</Culture></List2>
<List2 Include=""gb_z.txt""><Culture>gb</Culture></List2>
<Foo Include=""1_a1""><Md>1</Md></Foo>
<Foo Include=""2_b1""><Md>2</Md></Foo>
<Foo Include=""1_c1""><Md>1</Md></Foo>
</ItemGroup>
<Target Name=""foo"" Inputs=""@(List1)"" Outputs=""%(Culture).foo"">
<Message Text=""TargetStarted""/>
<Message Text=""List1: @(List1): %(Culture)""/>
<Message Text=""Foo: @(Foo): %(Md)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
bool res = project.Build ("foo");
if (!res) {
testLogger.DumpMessages ();
Assert.Fail ("A1: Build failed");
}
CheckLoggedMessagesInOrder (testLogger, new string [] {
"TargetStarted", "List1: fr_a.txt;fr_c.txt: fr",
"Foo: 1_a1;1_c1: 1", "Foo: 2_b1: 2",
"TargetStarted", "List1: en_b.txt: en",
"Foo: 1_a1;1_c1: 1", "Foo: 2_b1: 2",
"TargetStarted", "List1: gb_d.txt: gb",
"Foo: 1_a1;1_c1: 1", "Foo: 2_b1: 2"
}, "A2");
CheckEngineEventCounts (testLogger, 3, 3, 12, 12);
}
public void TestTargetReturns ()
{
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
project.Load (Path.Combine ("Test", Path.Combine ("resources", "TestReturns.csproj")));
var logger = new TestMessageLogger ();
engine.RegisterLogger (logger);
bool result = project.Build ("Main");
if (!result) {
logger.DumpMessages ();
Assert.Fail ("Build failed");
}
logger.CheckLoggedMessageHead ("Result: Bar", "A1");
Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
}
public void TestCopy2 ()
{
Engine engine;
Project project;
string [] file_paths = new string [] {
Path.Combine (source_path, "copy1.txt"),
Path.Combine (source_path, "copy2.txt")
};
using (File.CreateText (file_paths[0])) { }
using (File.CreateText (file_paths[1])) { }
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup><TargetPath>" + target_path + @"</TargetPath></PropertyGroup>
<ItemGroup>
<SFiles Include='" + file_paths [0] + @"'><Md>1</Md></SFiles>
<SFiles Include='" + file_paths [1] + @"'><Md>2</Md></SFiles>
</ItemGroup>
<Target Name='1'>
<Copy SourceFiles='@(SFiles)' DestinationFolder='$(TargetPath)' SkipUnchangedFiles='true' >
<Output TaskParameter='CopiedFiles' ItemName='I0'/>
<Output TaskParameter='DestinationFiles' ItemName='I1'/>
</Copy>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (documentString);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed");
}
CheckCopyBuildItems (project, file_paths, target_path, "A1");
// build again, this time files won't get copied because
// of SkipUnchangedFiles=true
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed #2");
}
CheckCopyBuildItems (project, file_paths, target_path, "A2");
}
// test for metadata refs in properties or items
public void TestNoBatching () {
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<item3 Include=""foo""/>
<item2 Include=""%(item3.Identity)""/>
<item0 Include=""@(item3)""/>
</ItemGroup>
<PropertyGroup>
<Prop1>%(item0.Identity)</Prop1>
</PropertyGroup>
<Target Name='1'>
<Message Text=""Prop1: $(Prop1)""/>
<Message Text=""Item2: @(item2)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed");
}
testLogger.CheckLoggedMessageHead ("Prop1: %(item0.Identity)", "A1");
testLogger.CheckLoggedMessageHead ("Item2: %(item3.Identity)", "A2");
Assert.AreEqual (0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
public void TestUnqualifiedMetadataReference ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<ResXFile Include=""Item1"">
<Culture>fr</Culture>
</ResXFile>
<ResXFile Include=""Item5"" />
<ResXFile Include=""Item6"">
<Culture>it</Culture>
</ResXFile>
</ItemGroup>
<Target Name=""ShowMessage"">
<Message
Text = ""Culture: %(Culture) -- ResXFile: @(ResXFile)"" />
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
//Fails as Culture is being referenced unqualified, and no Culture is
//specified for "Item5"
bool result = project.Build ("ShowMessage");
if (result)
Assert.Fail ("A1: Build should have failed");
CheckEngineEventCounts (testLogger, 1, 1, 0, 0);
}
public void TestEmptyPropertyValue ()
{
Engine engine;
Project project;
string documentString = @"
<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<PropertyGroup>
<A>1</A>
</PropertyGroup>
<Target Name='1'>
<Message Text='Before: $(A)'/>
<CreateProperty Value=''>
<Output
TaskParameter='Value'
PropertyName='A'
/>
</CreateProperty>
<Message Text='After: $(A)'/>
</Target>
</Project>
";
engine = new Engine (Consts.BinPath);
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project = engine.CreateNewProject ();
project.LoadXml (documentString);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed");
}
testLogger.CheckLoggedMessageHead ("Before: 1", "A1");
testLogger.CheckLoggedMessageHead ("After: ", "A2");
Assert.AreEqual (0, testLogger.NormalMessageCount, "Unexpected messages found");
}
// test for metadata refs via metadata refs
// batching should happen only on basis of the task attributes,
// and not the resolved expression values
public void TestConditionalBatching2 () {
string projectString = projectHeader + @"
<ItemGroup>
<item2 Include=""%(item3.Identity)""/>
<item4 Include=""%(item2.Identity);@(item3)""/>
</ItemGroup>
<Target Name='1'>
<Message Text=""Item3: %(item2.Identity)"" Condition="" '%(item5.Identity)' == '' ""/>
<Message Text=""Item4: %(item4.Identity)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed");
}
testLogger.CheckLoggedMessageHead ("Item3: %(item3.Identity)", "A1");
testLogger.CheckLoggedMessageHead ("Item4: %(item2.Identity)", "A2");
Assert.AreEqual (0, testLogger.NormalMessageCount, "Unexpected extra messages found");
}
public void TestMultipleMetadataReference2 ()
{
string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
<ItemGroup>
<GroupA Include=""file1.txt""/>
<GroupA Include=""file2.txt""/>
<GroupA Include=""file3.txt""/>
<GroupA Include=""file3.txt""/>
<GroupA Include=""file4.txt""/>
</ItemGroup>
<ItemGroup>
<GroupB Include=""file1.txt""/>
<GroupB Include=""file3.txt""/>
<GroupB Include=""file5.txt""/>
<GroupC Include=""PreExistingValue""/>
</ItemGroup>
<Target Name=""Build"">
<CreateItem Include=""@(GroupA)"" Condition=""'%(Identity)' != '' and '@(GroupA)' != '' and '@(GroupB)' != ''"" >
<Output TaskParameter=""Include"" ItemName=""GroupC""/>
</CreateItem>
<Message Text=""%(GroupC.Identity)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
Assert.IsTrue (project.Build ("Build"), "A1: Build failed");
BuildItemGroup include = project.GetEvaluatedItemsByName ("GroupC");
Assert.AreEqual (4, include.Count, "A2");
string [,] additional_metadata = new string [,] { { "Identity", "PreExistingValue" } };
CreateItemTest.CheckBuildItem (include [0], "GroupC", additional_metadata, "PreExistingValue", "A3");
additional_metadata = new string [,] { { "Identity", "file1.txt" } };
CreateItemTest.CheckBuildItem (include [1], "GroupC", additional_metadata, "file1.txt", "A4");
additional_metadata = new string [,] { { "Identity", "file3.txt" } };
CreateItemTest.CheckBuildItem (include [2], "GroupC", additional_metadata, "file3.txt", "A5");
CreateItemTest.CheckBuildItem (include [3], "GroupC", additional_metadata, "file3.txt", "A6");
CheckEngineEventCounts (testLogger, 1, 1, 5, 5);
}
public void TestPropertiesWithBatchedReferences () {
string projectString = projectHeader + @"
<ItemGroup>
<Item1 Include=""One""/>
<Item1 Include=""Two""/>
<Item1Ref Include=""@(Item1)""/>
</ItemGroup>
<PropertyGroup>
<Prop1>@(Item1)</Prop1>
<Prop2>@(Item1Ref)</Prop2>
</PropertyGroup>
<Target Name='1'>
<Message Text=""Item1: %(Item1.Identity) | Prop1: $(Prop1) | Prop2: $(Prop2)""/>
</Target>
</Project>";
Engine engine = new Engine (Consts.BinPath);
Project project = engine.CreateNewProject ();
TestMessageLogger testLogger = new TestMessageLogger ();
engine.RegisterLogger (testLogger);
project.LoadXml (projectString);
if (!project.Build ("1")) {
testLogger.DumpMessages ();
Assert.Fail ("Build failed");
}
try {
testLogger.CheckLoggedMessageHead ("Item1: One | Prop1: One | Prop2: One;Two", "A1");
testLogger.CheckLoggedMessageHead ("Item1: Two | Prop1: Two | Prop2: One;Two", "A2");
Assert.AreEqual (0, testLogger.NormalMessageCount, "Unexpected extra messages found");
} catch (AssertionException) {
testLogger.DumpMessages ();
throw;
}
}
