mcs/class/Microsoft.Build.Engine/Test/Microsoft.Build.BuildEngine/ProjectTest.cs

   1 //
   2 // ProjectTest.cs:
   3 //
   4 // Author:
   5 //   Marek Sieradzki (marek.sieradzki@gmail.com)
   6 //   Ankit Jain (jankit@novell.com)
   7 //
   8 // (C) 2005 Marek Sieradzki
   9 // Copyright 2009 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29
  30 using System;
  31 using System.Collections;
  32 using System.Collections.Generic;
  33 using System.IO;
  34 using System.Xml;
  35 using Microsoft.Build.BuildEngine;
  36 using Microsoft.Build.Framework;
  37 using Microsoft.Build.Utilities;
  38 using NUnit.Framework;
  39 using System.Text;
  40
  41 using MBT = MonoTests.Microsoft.Build.Tasks;
  42
  43 namespace MonoTests.Microsoft.Build.BuildEngine {
  44
  45         class TestLogger : Logger {
  46                 int target_started_events = 0;
  47                 int target_finished_events = 0;
  48
  49                 public override void Initialize (IEventSource eventSource)
  50                 {
  51                         eventSource.TargetStarted += new TargetStartedEventHandler(TargetStarted);
  52                         eventSource.TargetFinished += new TargetFinishedEventHandler(TargetFinished);
  53                         eventSource.MessageRaised += new BuildMessageEventHandler(Message);
  54                         eventSource.WarningRaised += new BuildWarningEventHandler(Warning);
  55                 }
  56
  57                 void TargetStarted (object sender, TargetStartedEventArgs args)
  58                 {
  59                         target_started_events++;
  60                 }
  61
  62                 void TargetFinished (object sender, TargetFinishedEventArgs args)
  63                 {
  64                         target_finished_events++;
  65                 }
  66
  67                 void Message (object sender, BuildMessageEventArgs args)
  68                 {
  69                 }
  70
  71                 void Warning (object sender, BuildWarningEventArgs args)
  72                 {
  73                 }
  74
  75                 public int TargetStartedEvents { get { return target_started_events; } }
  76
  77                 public int TargetFinishedEvents { get { return target_finished_events; } }
  78         }
  79
  80         [TestFixture]
  81         public class ProjectTest {
  82
  83                 /*
  84                 Import [] GetImports (ImportCollection ic)
  85                 {
  86                         List<Import> list = new List<Import> ();
  87                         foreach (Import i in ic)
  88                                 list.Add (i);
  89                         return list.ToArray ();
  90                 }
  91                 */
  92
  93                 [Test]
  94                 public void TestAssignment1 ()
  95                 {
  96                         Engine engine;
  97                         Project project;
  98                         string documentString =
  99                                 "<Project></Project>";
 100
 101                         engine = new Engine (Consts.BinPath);
 102
 103                         DateTime time = DateTime.Now;
 104                         project = engine.CreateNewProject ();
 105                         try {
 106                                 project.LoadXml (documentString);
 107                         } catch (InvalidProjectFileException) {
 108                                 Assert.AreEqual (true, project.BuildEnabled, "A1");
 109                                 Assert.AreEqual (String.Empty, project.DefaultTargets, "A2");
 110                                 Assert.AreEqual (String.Empty, project.FullFileName, "A3");
 111                                 Assert.AreEqual (false, project.IsDirty, "A4");
 112                                 Assert.AreEqual (false, project.IsValidated, "A5");
 113                                 Assert.AreEqual (engine, project.ParentEngine, "A6");
 114                                 //Console.WriteLine ("time: {0} p.t: {1}", time, project.TimeOfLastDirty);
 115                                 Assert.IsTrue (time <= project.TimeOfLastDirty, "A7");
 116                                 Assert.IsTrue (String.Empty != project.Xml, "A8");
 117                                 return;
 118                         }
 119
 120                         Assert.Fail ("Expected InvalidProjectFileException");
 121                 }
 122
 123                 [Test]
 124                 public void TestAssignment2 ()
 125                 {
 126                         Engine engine;
 127                         Project project;
 128                         string documentString =
 129                                 "<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\"></Project>";
 130
 131                         engine = new Engine (Consts.BinPath);
 132                         DateTime time = DateTime.Now;
 133                         project = engine.CreateNewProject ();
 134                         project.LoadXml (documentString);
 135
 136                         Assert.AreEqual (true, project.BuildEnabled, "A1");
 137                         Assert.AreEqual (String.Empty, project.DefaultTargets, "A2");
 138                         Assert.AreEqual (String.Empty, project.FullFileName, "A3");
 139                         Assert.AreEqual (true, project.IsDirty, "A4");
 140                         Assert.AreEqual (false, project.IsValidated, "A5");
 141                         Assert.AreEqual (engine, project.ParentEngine, "A6");
 142                         Assert.IsTrue (time <= project.TimeOfLastDirty, "A7");
 143                         Assert.IsTrue (String.Empty != project.Xml, "A8");
 144                 }
 145
 146                 [Test]
 147                 [Category ("NotWorking")]
 148                 public void TestAddNewImport1 ()
 149                 {
 150                         Engine engine;
 151                         Project project;
 152
 153                         string documentString = @"
 154                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 155                                         <PropertyGroup />
 156                                         <ItemGroup />
 157                                         <Target Name='a' />
 158                                         <Import Project='Test/resources/Import.csproj' />
 159                                 </Project>
 160                         ";
 161
 162                         engine = new Engine (Consts.BinPath);
 163                         project = engine.CreateNewProject ();
 164                         project.LoadXml (documentString);
 165
 166                         project.AddNewImport ("a", "true");
 167                         // reevaluation wasn't caused by anything so it has only old import
 168                         Assert.AreEqual (1, project.Imports.Count, "A1");
 169                 }
 170
 171                 [Test]
 172                 [Ignore ("Too detailed probably (implementation specific)")]
 173                 public void TestAddNewItem1 ()
 174                 {
 175                         Engine engine;
 176                         Project project;
 177                         BuildItemGroup [] groups = new BuildItemGroup [1];
 178
 179                         string documentString = @"
 180                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 181                                 </Project>
 182                         ";
 183
 184                         engine = new Engine (Consts.BinPath);
 185                         project = engine.CreateNewProject ();
 186                         project.LoadXml (documentString);
 187
 188                         BuildItem item = project.AddNewItem ("A", "B");
 189
 190                         Assert.AreEqual (1, project.ItemGroups.Count, "A1");
 191                         project.ItemGroups.CopyTo (groups, 0);
 192                         Assert.AreEqual (1, groups [0].Count, "A2");
 193                         Assert.AreEqual ("B", groups [0] [0].Include, "A3");
 194                         Assert.AreEqual ("B", groups [0] [0].FinalItemSpec, "A4");
 195                         Assert.AreEqual ("A", groups [0] [0].Name, "A5");
 196                         //Assert.AreNotSame (item, groups [0] [0], "A6");
 197                         Assert.IsFalse (object.ReferenceEquals (item, groups [0] [0]), "A6");
 198
 199                         Assert.AreEqual (1, project.EvaluatedItems.Count, "A7");
 200                         Assert.AreEqual ("B", project.EvaluatedItems [0].Include, "A8");
 201                         Assert.AreEqual ("B", project.EvaluatedItems [0].FinalItemSpec, "A9");
 202                         Assert.AreEqual ("A", project.EvaluatedItems [0].Name, "A10");
 203                         //Assert.AreNotSame (item, project.EvaluatedItems [0], "A11");
 204                         Assert.IsFalse (object.ReferenceEquals (item, project.EvaluatedItems [0]), "A11");
 205                 }
 206
 207                 [Test]
 208                 [Category ("NotWorking")]
 209                 public void TestAddNewItem2 ()
 210                 {
 211                         Engine engine;
 212                         Project project;
 213
 214                         engine = new Engine (Consts.BinPath);
 215                         project = engine.CreateNewProject ();
 216
 217                         BuildItem item = project.AddNewItem ("A", "a;b;c");
 218                         Assert.AreEqual ("a;b;c", item.Include, "A1");
 219                         Assert.AreEqual ("a", item.FinalItemSpec, "A2");
 220
 221                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A3");
 222                 }
 223
 224                 [Test]
 225                 public void TestAddNewItem3 ()
 226                 {
 227                         Engine engine;
 228                         Project project;
 229                         BuildItemGroup [] groups = new BuildItemGroup [4];
 230
 231                         string documentString = @"
 232                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 233                                         <ItemGroup />
 234                                         <ItemGroup>
 235                                                 <A Include='a'/>
 236                                         </ItemGroup>
 237                                         <ItemGroup>
 238                                                 <B Include='a'/>
 239                                         </ItemGroup>
 240                                         <ItemGroup>
 241                                                 <B Include='a'/>
 242                                         </ItemGroup>
 243                                 </Project>
 244                         ";
 245
 246                         engine = new Engine (Consts.BinPath);
 247                         project = engine.CreateNewProject ();
 248                         project.LoadXml (documentString);
 249
 250                         project.AddNewItem ("B", "b");
 251
 252                         project.ItemGroups.CopyTo (groups, 0);
 253                         Assert.AreEqual (0, groups [0].Count, "A1");
 254                         Assert.AreEqual (1, groups [1].Count, "A2");
 255                         Assert.AreEqual (1, groups [2].Count, "A3");
 256                         Assert.AreEqual (2, groups [3].Count, "A4");
 257                 }
 258                 [Test]
 259                 public void TestAddNewItemGroup ()
 260                 {
 261                         Engine engine;
 262                         Project project;
 263
 264                         string documentString = @"
 265                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 266                                 </Project>
 267                         ";
 268
 269                         engine = new Engine (Consts.BinPath);
 270                         project = engine.CreateNewProject ();
 271                         project.LoadXml (documentString);
 272
 273                         BuildItemGroup big = project.AddNewItemGroup ();
 274                         Assert.IsNotNull (big, "A1");
 275                         Assert.AreEqual (String.Empty, big.Condition, "A2");
 276                         Assert.AreEqual (0, big.Count, "A3");
 277                         Assert.AreEqual (false, big.IsImported, "A4");
 278                         Assert.IsTrue (project.IsDirty, "A5");
 279                 }
 280
 281                 [Test]
 282                 public void TestAddNewPropertyGroup ()
 283                 {
 284                         Engine engine;
 285                         Project project;
 286
 287                         string documentString = @"
 288                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 289                                 </Project>
 290                         ";
 291
 292                         engine = new Engine (Consts.BinPath);
 293                         project = engine.CreateNewProject ();
 294                         project.LoadXml (documentString);
 295
 296                         BuildPropertyGroup bpg = project.AddNewPropertyGroup (false);
 297                         Assert.IsNotNull (bpg, "A1");
 298                         Assert.AreEqual (String.Empty, bpg.Condition, "A2");
 299                         Assert.AreEqual (0, bpg.Count, "A3");
 300                         Assert.AreEqual (false, bpg.IsImported, "A4");
 301                         Assert.IsTrue (project.IsDirty, "A5");
 302                 }
 303
 304                 [Test]
 305                 public void TestBuild0 ()
 306                 {
 307                         Engine engine;
 308                         Project project;
 309                         IDictionary hashtable = new Hashtable ();
 310
 311                         string documentString = @"
 312                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 313                                         <Target
 314                                                 Name='Main'
 315                                                 Inputs='a;b;c'
 316                                                 Outputs='d;e;f'
 317                                         >
 318                                         </Target>
 319                                 </Project>
 320                         ";
 321
 322                         engine = new Engine (Consts.BinPath);
 323                         project = engine.CreateNewProject ();
 324                         project.LoadXml (documentString);
 325
 326                         Assert.AreEqual (true, project.Build (new string [] { "Main" }, hashtable), "A1");
 327                         Assert.AreEqual (1, hashtable.Count, "A2");
 328
 329                         IDictionaryEnumerator e = hashtable.GetEnumerator ();
 330                         e.MoveNext ();
 331
 332                         string name = (string) e.Key;
 333                         Assert.AreEqual ("Main", name, "A3");
 334                         ITaskItem [] arr = (ITaskItem []) e.Value;
 335
 336                         Assert.AreEqual (3, arr.Length, "A4");
 337                         Assert.AreEqual ("d", arr [0].ItemSpec, "A5");
 338                         Assert.AreEqual ("e", arr [1].ItemSpec, "A6");
 339                         Assert.AreEqual ("f", arr [2].ItemSpec, "A7");
 340                 }
 341
 342                 [Test]
 343                 public void TestBuild1 ()
 344                 {
 345                         Engine engine;
 346                         Project project;
 347                         IDictionary hashtable = new Hashtable ();
 348
 349                         string documentString = @"
 350                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 351                                         <Target Name='Main'>
 352                                                 <Microsoft.Build.Tasks.Message Text='Text' />
 353                                         </Target>
 354                                 </Project>
 355                         ";
 356
 357                         engine = new Engine (Consts.BinPath);
 358                         project = engine.CreateNewProject ();
 359                         project.LoadXml (documentString);
 360
 361                         Assert.AreEqual (true, project.Build (new string[] { "Main" }, hashtable), "A1");
 362                         Assert.AreEqual (1, hashtable.Count, "A2");
 363
 364                         IDictionaryEnumerator e = hashtable.GetEnumerator ();
 365                         e.MoveNext ();
 366
 367                         string name = (string) e.Key;
 368                         Assert.AreEqual ("Main", name, "A3");
 369                         Assert.IsNotNull ((ITaskItem []) e.Value, "A4");
 370                 }
 371
 372                 [Test]
 373                 public void TestBuild2 ()
 374                 {
 375                         Engine engine;
 376                         Project project;
 377
 378                         string documentString = @"
 379                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 380                                         <Target Name='T'>
 381                                                 <Message Text='text' />
 382                                         </Target>
 383                                 </Project>
 384                         ";
 385
 386                         engine = new Engine (Consts.BinPath);
 387                         MBT.TestMessageLogger tl = new MBT.TestMessageLogger();
 388                         engine.RegisterLogger (tl);
 389                         project = engine.CreateNewProject ();
 390                         project.LoadXml (documentString);
 391
 392                         project.Build ("T");
 393                         project.Build ("T");
 394
 395                         Assert.AreEqual (2, tl.TargetStarted, "A1");
 396                         Assert.AreEqual (2, tl.TargetFinished, "A2");
 397                         Assert.AreEqual (2, tl.TaskStarted, "A3");
 398                         Assert.AreEqual (2, tl.TaskFinished, "A4");
 399                 }
 400
 401                 [Test]
 402                 public void TestBuild3 ()
 403                 {
 404                         Engine engine;
 405                         Project project;
 406
 407                         string documentString = @"
 408                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 409                                         <Target Name='T'>
 410                                                 <Message Text='text' />
 411                                         </Target>
 412                                 </Project>
 413                         ";
 414
 415                         engine = new Engine (Consts.BinPath);
 416                         MBT.TestMessageLogger tl = new MBT.TestMessageLogger ();
 417                         engine.RegisterLogger (tl);
 418                         project = engine.CreateNewProject ();
 419                         project.LoadXml (documentString);
 420
 421                         project.Build (new string [1] { "T" }, null, BuildSettings.None);
 422                         project.Build (new string [1] { "T" }, null, BuildSettings.None);
 423
 424                         Assert.AreEqual (2, tl.TargetStarted, "A1");
 425                         Assert.AreEqual (2, tl.TargetFinished, "A2");
 426                         Assert.AreEqual (2, tl.TaskStarted, "A3");
 427                         Assert.AreEqual (2, tl.TaskFinished, "A4");
 428                 }
 429
 430                 [Test]
 431                 public void TestBuild4 ()
 432                 {
 433                         Engine engine;
 434                         Project project;
 435
 436                         string documentString = @"
 437                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 438                                         <Target Name='T'>
 439                                                 <Message Text='text' />
 440                                         </Target>
 441                                 </Project>
 442                         ";
 443
 444                         engine = new Engine (Consts.BinPath);
 445                         MBT.TestMessageLogger tl = new MBT.TestMessageLogger ();
 446                         engine.RegisterLogger (tl);
 447                         project = engine.CreateNewProject ();
 448                         project.LoadXml (documentString);
 449
 450                         project.Build (new string [1] { "T" }, null, BuildSettings.DoNotResetPreviouslyBuiltTargets);
 451                         project.Build (new string [1] { "T" }, null, BuildSettings.DoNotResetPreviouslyBuiltTargets);
 452
 453                         Assert.AreEqual (1, tl.TargetStarted, "A1");
 454                         Assert.AreEqual (1, tl.TargetFinished, "A2");
 455                         Assert.AreEqual (1, tl.TaskStarted, "A3");
 456                         Assert.AreEqual (1, tl.TaskFinished, "A4");
 457                 }
 458
 459                 [Test]
 460                 public void TestBuild5 ()
 461                 {
 462                         Engine engine;
 463                         Project project;
 464
 465                         string documentString = @"
 466                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 467                                 </Project>
 468                         ";
 469
 470                         engine = new Engine (Consts.BinPath);
 471                         project = engine.CreateNewProject ();
 472                         project.LoadXml (documentString);
 473
 474                         Assert.IsFalse (project.Build ("target_that_doesnt_exist"));
 475                 }
 476
 477                 [Test]
 478                 public void TestEvaluatedItems1 ()
 479                 {
 480                         Engine engine;
 481                         Project project;
 482
 483                         string documentString = @"
 484                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 485                                         <ItemGroup>
 486                                                 <A Include='a' />
 487                                                 <B Include='b' Condition='false' />
 488                                         </ItemGroup>
 489                                 </Project>
 490                         ";
 491
 492                         engine = new Engine (Consts.BinPath);
 493                         project = engine.CreateNewProject ();
 494                         project.LoadXml (documentString);
 495
 496                         Assert.AreEqual (1, project.EvaluatedItems.Count, "A1");
 497
 498                         BuildItem bi = project.EvaluatedItems [0];
 499
 500                         bi.Name = "C";
 501                         bi.Include = "c";
 502
 503                         BuildItemGroup [] big = new BuildItemGroup [1];
 504                         project.ItemGroups.CopyTo (big, 0);
 505                         Assert.AreEqual ("C", big [0] [0].Name, "A2");
 506                         Assert.AreEqual ("c", big [0] [0].Include, "A3");
 507                 }
 508
 509                 [Test]
 510                 public void TestEvaluatedItems2 ()
 511                 {
 512                         Engine engine;
 513                         Project project;
 514
 515                         string documentString = @"
 516                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 517                                         <ItemGroup>
 518                                                 <A Include='a;b;c' />
 519                                         </ItemGroup>
 520                                 </Project>
 521                         ";
 522
 523                         engine = new Engine (Consts.BinPath);
 524                         project = engine.CreateNewProject ();
 525                         project.LoadXml (documentString);
 526
 527                         BuildItemGroup [] big = new BuildItemGroup [1];
 528                         project.ItemGroups.CopyTo (big, 0);
 529
 530                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A1");
 531                         Assert.AreEqual ("a;b;c", big [0] [0].Include, "A2");
 532                         Assert.AreEqual (1, big [0].Count, "A3");
 533
 534                         BuildItem bi = project.EvaluatedItems [0];
 535
 536                         bi.Include = "d";
 537
 538                         Assert.AreEqual (3, big [0].Count, "A4");
 539                         Assert.AreEqual ("d", big [0] [0].Include, "A5");
 540                         Assert.AreEqual ("b", big [0] [1].Include, "A6");
 541                         Assert.AreEqual ("c", big [0] [2].Include, "A7");
 542                 }
 543
 544                 [Test]
 545                 [Category ("NotWorking")]
 546                 public void TestGetConditionedPropertyValues ()
 547                 {
 548                         Engine engine;
 549                         Project project;
 550
 551                         string documentString = @"
 552                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 553                                         <PropertyGroup Condition='true'>
 554                                                 <A>A</A>
 555                                                 <B Condition='true'>A</B>
 556                                         </PropertyGroup>
 557                                         <PropertyGroup>
 558                                                 <C Condition='true'>A</C>
 559                                                 <C Condition='false'>B</C>
 560                                                 <C Condition='!false'>C</C>
 561                                                 <D>A</D>
 562                                                 <E Condition="" '$(C)' == 'A' "">E</E>
 563                                         </PropertyGroup>
 564                                 </Project>
 565                         ";
 566
 567                         engine = new Engine (Consts.BinPath);
 568                         project = engine.CreateNewProject ();
 569                         project.LoadXml (documentString);
 570
 571                         Assert.AreEqual (0, project.GetConditionedPropertyValues ("A").Length, "A1");
 572                         Assert.AreEqual (0, project.GetConditionedPropertyValues ("B").Length, "A2");
 573                         Assert.AreEqual (1, project.GetConditionedPropertyValues ("C").Length, "A3");
 574                         Assert.AreEqual (0, project.GetConditionedPropertyValues ("D").Length, "A4");
 575                         Assert.AreEqual (0, project.GetConditionedPropertyValues ("E").Length, "A5");
 576                         Assert.AreEqual ("A", project.GetConditionedPropertyValues ("C") [0], "A6");
 577                 }
 578
 579                 [Test]
 580                 [ExpectedException (typeof (ArgumentNullException))]
 581                 public void TestGetEvaluatedItemsByName1 ()
 582                 {
 583                         Engine engine;
 584                         Project project;
 585
 586                         string documentString = @"
 587                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 588                                 </Project>
 589                         ";
 590
 591                         engine = new Engine (Consts.BinPath);
 592                         project = engine.CreateNewProject ();
 593                         project.LoadXml (documentString);
 594
 595                         project.GetEvaluatedItemsByName (null);
 596                 }
 597
 598                 [Test]
 599                 public void TestGetEvaluatedItemsByName2 ()
 600                 {
 601                         Engine engine;
 602                         Project project;
 603
 604                         string documentString = @"
 605                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 606                                         <ItemGroup>
 607                                                 <A Include='1' />
 608                                                 <B Include='2' Condition='true' />
 609                                                 <C Include='3' Condition='false' />
 610                                         </ItemGroup>
 611                                 </Project>
 612                         ";
 613
 614                         engine = new Engine (Consts.BinPath);
 615                         project = engine.CreateNewProject ();
 616                         project.LoadXml (documentString);
 617
 618                         BuildItemGroup big;
 619
 620                         big = project.GetEvaluatedItemsByName (String.Empty);
 621
 622                         Assert.AreEqual (0, big.Count, "A1");
 623
 624                         big = project.GetEvaluatedItemsByName ("A");
 625
 626                         Assert.AreEqual (1, big.Count, "A2");
 627                         Assert.AreEqual ("1", big [0].FinalItemSpec, "A3");
 628
 629                         big = project.GetEvaluatedItemsByName ("B");
 630
 631                         Assert.AreEqual (1, big.Count, "A4");
 632                         Assert.AreEqual ("2", big [0].FinalItemSpec, "A5");
 633
 634                         big = project.GetEvaluatedItemsByName ("C");
 635
 636                         Assert.AreEqual (0, big.Count, "A6");
 637                 }
 638
 639                 [Test]
 640                 [ExpectedException (typeof (ArgumentNullException))]
 641                 public void TestGetEvaluatedItemsByNameIgnoringCondition1 ()
 642                 {
 643                         Engine engine;
 644                         Project project;
 645
 646                         string documentString = @"
 647                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 648                                 </Project>
 649                         ";
 650
 651                         engine = new Engine (Consts.BinPath);
 652                         project = engine.CreateNewProject ();
 653                         project.LoadXml (documentString);
 654
 655                         project.GetEvaluatedItemsByNameIgnoringCondition (null);
 656                 }
 657
 658                 [Test]
 659                 public void TestGetEvaluatedItemsByNameIgnoringCondition2 ()
 660                 {
 661                         Engine engine;
 662                         Project project;
 663
 664                         string documentString = @"
 665                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 666                                         <ItemGroup>
 667                                                 <A Include='1' />
 668                                                 <B Include='2' Condition='true' />
 669                                                 <C Include='3' Condition='false' />
 670                                         </ItemGroup>
 671                                 </Project>
 672                         ";
 673
 674                         engine = new Engine (Consts.BinPath);
 675                         project = engine.CreateNewProject ();
 676                         project.LoadXml (documentString);
 677
 678                         BuildItemGroup big;
 679
 680                         big = project.GetEvaluatedItemsByNameIgnoringCondition (String.Empty);
 681
 682                         Assert.AreEqual (0, big.Count, "A1");
 683
 684                         big = project.GetEvaluatedItemsByNameIgnoringCondition ("A");
 685
 686                         Assert.AreEqual (1, big.Count, "A2");
 687                         Assert.AreEqual ("1", big [0].FinalItemSpec, "A3");
 688
 689                         big = project.GetEvaluatedItemsByNameIgnoringCondition ("B");
 690
 691                         Assert.AreEqual (1, big.Count, "A4");
 692                         Assert.AreEqual ("2", big [0].FinalItemSpec, "A5");
 693
 694                         big = project.GetEvaluatedItemsByNameIgnoringCondition ("C");
 695
 696                         Assert.AreEqual (1, big.Count, "A6");
 697                         Assert.AreEqual ("3", big [0].FinalItemSpec, "A7");
 698                 }
 699
 700                 [Test]
 701                 [ExpectedException (typeof (ArgumentNullException))]
 702                 public void TestGetEvaluatedProperty1 ()
 703                 {
 704                         Engine engine;
 705                         Project project;
 706
 707                         string documentString = @"
 708                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 709                                 </Project>
 710                         ";
 711
 712                         engine = new Engine (Consts.BinPath);
 713                         project = engine.CreateNewProject ();
 714                         project.LoadXml (documentString);
 715
 716                         project.GetEvaluatedProperty (null);
 717                 }
 718                 [Test]
 719                 public void TestGetEvaluatedProperty2 ()
 720                 {
 721                         Engine engine;
 722                         Project project;
 723
 724                         string documentString = @"
 725                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 726                                         <PropertyGroup>
 727                                                 <A>1</A>
 728                                                 <B Condition='true'>2</B>
 729                                                 <C Condition='false'>3</C>
 730                                         </PropertyGroup>
 731                                 </Project>
 732                         ";
 733
 734                         engine = new Engine (Consts.BinPath);
 735                         project = engine.CreateNewProject ();
 736                         project.LoadXml (documentString);
 737
 738                         Assert.AreEqual ("1", project.GetEvaluatedProperty ("A"), "A1");
 739                         Assert.AreEqual ("2", project.GetEvaluatedProperty ("B"), "A2");
 740                         Assert.IsNull (project.GetEvaluatedProperty ("C"), "A3");
 741                 }
 742
 743                 [Test]
 744                 public void TestGetProjectExtensions ()
 745                 {
 746                         Engine engine;
 747                         Project project;
 748
 749                         string documentString = @"
 750                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 751                                         <ProjectExtensions>
 752                                                 <Node>Text</Node>
 753                                         </ProjectExtensions>
 754                                 </Project>
 755                         ";
 756
 757                         engine = new Engine (Consts.BinPath);
 758                         project = engine.CreateNewProject ();
 759                         project.LoadXml (documentString);
 760
 761                         Assert.AreEqual (String.Empty, project.GetProjectExtensions (null), "A1");
 762                         Assert.AreEqual (String.Empty, project.GetProjectExtensions (String.Empty), "A2");
 763                         Assert.AreEqual (String.Empty, project.GetProjectExtensions ("something"), "A3");
 764                         Assert.AreEqual ("Text", project.GetProjectExtensions ("Node"), "A4");
 765                 }
 766
 767                 [Test]
 768                 public void TestGlobalProperties1 ()
 769                 {
 770                         Engine engine;
 771                         Project project;
 772
 773                         string documentString = @"
 774                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 775                                 </Project>
 776                         ";
 777
 778                         engine = new Engine (Consts.BinPath);
 779                         project = engine.CreateNewProject ();
 780                         project.LoadXml (documentString);
 781
 782                         Assert.AreEqual (0, project.GlobalProperties.Count, "A1");
 783                 }
 784
 785                 [Test]
 786                 public void TestGlobalProperties2 ()
 787                 {
 788                         Engine engine;
 789                         Project project;
 790
 791                         string documentString = @"
 792                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 793                                 </Project>
 794                         ";
 795
 796                         engine = new Engine (Consts.BinPath);
 797                         engine.GlobalProperties.SetProperty ("Property", "Value");
 798
 799                         project = engine.CreateNewProject ();
 800                         project.LoadXml (documentString);
 801
 802                         Assert.AreEqual (1, project.GlobalProperties.Count, "A1");
 803                         Assert.AreEqual ("Property", project.GlobalProperties ["Property"].Name, "A2");
 804                         Assert.AreEqual ("Value", project.GlobalProperties ["Property"].Value, "A3");
 805                         Assert.AreEqual ("Value", project.GlobalProperties ["Property"].FinalValue, "A4");
 806                         Assert.AreEqual ("Property", project.EvaluatedProperties ["Property"].Name, "A2");
 807                         Assert.AreEqual ("Value", project.EvaluatedProperties ["Property"].Value, "A3");
 808                         Assert.AreEqual ("Value", project.EvaluatedProperties ["Property"].FinalValue, "A4");
 809                 }
 810
 811                 [Test]
 812                 [Category ("NotDotNet")]
 813                 [ExpectedException (typeof (ArgumentNullException))]
 814                 public void TestGlobalProperties3 ()
 815                 {
 816                         Engine engine;
 817                         Project project;
 818
 819                         string documentString = @"
 820                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 821                                 </Project>
 822                         ";
 823
 824                         engine = new Engine (Consts.BinPath);
 825                         project = engine.CreateNewProject ();
 826                         project.LoadXml (documentString);
 827
 828                         project.GlobalProperties = null;
 829                 }
 830
 831                 [Test]
 832                 [Ignore ("needs rewriting")]
 833                 public void TestGlobalProperties4 ()
 834                 {
 835                         Engine engine;
 836                         Project project;
 837
 838                         string documentString = @"
 839                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 840                                         <PropertyGroup>
 841                                                 <Property>a</Property>
 842                                         </PropertyGroup>
 843                                 </Project>
 844                         ";
 845
 846                         engine = new Engine (Consts.BinPath);
 847                         project = engine.CreateNewProject ();
 848                         project.LoadXml (documentString);
 849
 850                         BuildPropertyGroup[] groups = new BuildPropertyGroup [1];
 851                         project.PropertyGroups.CopyTo (groups, 0);
 852
 853                         project.GlobalProperties = groups [0];
 854                         project.GlobalProperties = project.EvaluatedProperties;
 855                 }
 856
 857                 [Test]
 858                 [Category ("NotDotNet")]
 859                 [ExpectedException (typeof (InvalidOperationException))]
 860                 public void TestGlobalProperties5 ()
 861                 {
 862                         Engine engine;
 863                         Project project;
 864
 865                         string documentString = @"
 866                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 867                                         <PropertyGroup>
 868                                                 <Property>a</Property>
 869                                         </PropertyGroup>
 870                                 </Project>
 871                         ";
 872
 873                         engine = new Engine (Consts.BinPath);
 874                         project = engine.CreateNewProject ();
 875                         project.LoadXml (documentString);
 876
 877                         BuildPropertyGroup[] groups = new BuildPropertyGroup [1];
 878                         project.PropertyGroups.CopyTo (groups, 0);
 879                         project.GlobalProperties = groups [0];
 880                 }
 881
 882                 [Test]
 883                 [ExpectedException (typeof (InvalidProjectFileException))]
 884                 public void TestLoad1 ()
 885                 {
 886                         Engine engine;
 887                         Project project;
 888
 889                         string documentString = @"
 890                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 891                                         <PropertyGroup>
 892                                 </Project>
 893                         ";
 894
 895                         engine = new Engine (Consts.BinPath);
 896                         project = engine.CreateNewProject ();
 897                         project.LoadXml (documentString);
 898                 }
 899
 900                 [Test]
 901                 [ExpectedException (typeof (InvalidProjectFileException))]
 902                 public void TestLoad2 ()
 903                 {
 904                         Engine engine;
 905                         Project project;
 906
 907                         engine = new Engine (Consts.BinPath);
 908                         project = engine.CreateNewProject ();
 909                         project.LoadXml ("project_file_that_doesnt_exist");
 910                 }
 911
 912                 [Test]
 913                 public void TestParentEngine ()
 914                 {
 915                         Engine engine;
 916                         Project project;
 917
 918                         engine = new Engine (Consts.BinPath);
 919                         project = engine.CreateNewProject ();
 920
 921                         Assert.AreEqual (engine, project.ParentEngine, "A1");
 922                 }
 923
 924                 [Test]
 925                 [Category ("NotDotNet")]
 926                 [ExpectedException (typeof (ArgumentNullException))]
 927                 public void TestRemoveItemGroup1 ()
 928                 {
 929                         Engine engine;
 930                         Project p1;
 931
 932                         engine = new Engine (Consts.BinPath);
 933                         p1 = engine.CreateNewProject ();
 934
 935                         p1.RemoveItemGroup (null);
 936                 }
 937
 938                 // The "BuildItemGroup" object specified does not belong to the correct "Project" object.
 939                 [Test]
 940                 [ExpectedException (typeof (InvalidOperationException))]
 941                 [Category ("NotWorking")]
 942                 public void TestRemoveItemGroup2 ()
 943                 {
 944                         Engine engine;
 945                         Project p1;
 946                         Project p2;
 947                         BuildItemGroup [] groups  = new BuildItemGroup [1];
 948
 949                         engine = new Engine (Consts.BinPath);
 950                         p1 = engine.CreateNewProject ();
 951                         p2 = engine.CreateNewProject ();
 952
 953                         p1.AddNewItem ("A", "B");
 954                         p1.ItemGroups.CopyTo (groups, 0);
 955
 956                         p2.RemoveItemGroup (groups [0]);
 957                 }
 958
 959                 [Test]
 960                 [Category ("NotDotNet")]
 961                 [ExpectedException (typeof (ArgumentNullException))]
 962                 public void TestRemoveItem1 ()
 963                 {
 964                         Engine engine;
 965                         Project project;
 966
 967                         engine = new Engine (Consts.BinPath);
 968                         project = engine.CreateNewProject ();
 969
 970                         project.RemoveItem (null);
 971                 }
 972
 973                 // The object passed in is not part of the project.
 974                 [Test]
 975                 [ExpectedException (typeof (InvalidOperationException))]
 976                 public void TestRemoveItem2 ()
 977                 {
 978                         Engine engine;
 979                         Project project;
 980
 981                         engine = new Engine (Consts.BinPath);
 982                         project = engine.CreateNewProject ();
 983
 984                         project.RemoveItem (new BuildItem ("name", "include"));
 985                 }
 986
 987                 // The "BuildItemGroup" object specified does not belong to the correct "Project" object.
 988                 [Test]
 989                 [ExpectedException (typeof (InvalidOperationException))]
 990                 public void TestRemoveItem3 ()
 991                 {
 992                         Engine engine;
 993                         Project p1;
 994                         Project p2;
 995
 996                         engine = new Engine (Consts.BinPath);
 997                         p1 = engine.CreateNewProject ();
 998                         p2 = engine.CreateNewProject ();
 999
1000                         p1.AddNewItem ("A", "B");
1001
1002                         p2.RemoveItem (p1.EvaluatedItems [0]);
1003                 }
1004
1005                 [Test]
1006                 [Category ("NotDotNet")]
1007                 [ExpectedException (typeof (InvalidOperationException))]
1008                 public void TestRemoveItem4 ()
1009                 {
1010                         Engine engine;
1011                         Project p1;
1012                         Project p2;
1013
1014                         engine = new Engine (Consts.BinPath);
1015                         p1 = engine.CreateNewProject ();
1016                         p2 = engine.CreateNewProject ();
1017
1018                         p1.AddNewItem ("A", "B");
1019                         p1.AddNewItem ("A", "C");
1020
1021                         p2.RemoveItem (p1.EvaluatedItems [0]);
1022                 }
1023
1024                 [Test]
1025                 public void TestRemoveItem5 ()
1026                 {
1027                         Engine engine;
1028                         Project project;
1029                         BuildItemGroup [] groups = new BuildItemGroup [1];
1030
1031                         string documentString = @"
1032                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
1033                                         <ItemGroup>
1034                                                 <A Include='a'/>
1035                                         </ItemGroup>
1036                                 </Project>
1037                         ";
1038
1039                         engine = new Engine (Consts.BinPath);
1040                         project = engine.CreateNewProject ();
1041                         project.LoadXml (documentString);
1042
1043                         project.RemoveItem (project.EvaluatedItems [0]);
1044                         Assert.AreEqual (0, project.EvaluatedItems.Count, "A1");
1045                         project.ItemGroups.CopyTo (groups, 0);
1046                         Assert.IsNull (groups [0], "A2");
1047                         Assert.AreEqual (0, project.ItemGroups.Count, "A3");
1048                 }
1049
1050                 [Test]
1051                 public void TestResetBuildStatus ()
1052                 {
1053                         Engine engine;
1054                         Project project;
1055
1056                         string documentString = @"
1057                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
1058                                         <Target Name='T' Inputs='Test\resources\TestTasks.cs' Outputs='Test\resources\TestTasks.dll'>
1059                                                 <Message Text='text' />
1060                                         </Target>
1061                                 </Project>
1062                         ";
1063
1064                         engine = new Engine (Consts.BinPath);
1065                         TestLogger tl = new TestLogger ();
1066                         engine.RegisterLogger (tl);
1067                         project = engine.CreateNewProject ();
1068                         project.LoadXml (documentString);
1069
1070                         project.Build ("T");
1071                         project.ResetBuildStatus ();
1072                         project.Build (new string [1] { "T" }, null, BuildSettings.DoNotResetPreviouslyBuiltTargets);
1073                         project.ResetBuildStatus ();
1074                         project.Build (new string [1] { "T" }, null, BuildSettings.DoNotResetPreviouslyBuiltTargets);
1075
1076                         Assert.AreEqual (3, tl.TargetStartedEvents, "A1");
1077                         Assert.AreEqual (3, tl.TargetFinishedEvents, "A1");
1078                 }
1079
1080                 [Test]
1081                 public void TestSchemaFile ()
1082                 {
1083                         Engine engine;
1084                         Project project;
1085
1086                         string documentString = @"
1087                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
1088                                 </Project>
1089                         ";
1090
1091                         engine = new Engine (Consts.BinPath);
1092                         project = engine.CreateNewProject ();
1093                         project.LoadXml (documentString);
1094
1095                         Assert.IsNull (project.SchemaFile, "A1");
1096                 }
1097                 [Test]
1098                 [Category ("NotDotNet")]
1099                 [ExpectedException (typeof (ArgumentNullException))]
1100                 public void TestSetProjectExtensions1 ()
1101                 {
1102                         Engine engine;
1103                         Project project;
1104
1105                         string documentString = @"
1106                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
1107                                 </Project>
1108                         ";
1109
1110                         engine = new Engine (Consts.BinPath);
1111                         project = engine.CreateNewProject ();
1112                         project.LoadXml (documentString);
1113
1114                         project.SetProjectExtensions (null, null);
1115                 }
1116
1117                 [Test]
1118                 public void TestSetProjectExtensions2 ()
1119                 {
1120                         Engine engine;
1121                         Project project;
1122
1123                         string documentString = @"
1124                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
1125                                 </Project>
1126                         ";
1127
1128                         engine = new Engine (Consts.BinPath);
1129                         project = engine.CreateNewProject ();
1130                         project.LoadXml (documentString);
1131
1132                         project.SetProjectExtensions ("name", "1");
1133                         Assert.AreEqual ("1", project.GetProjectExtensions ("name"), "A1");
1134                         project.SetProjectExtensions ("name", "2");
1135                         Assert.AreEqual ("2", project.GetProjectExtensions ("name"), "A2");
1136                         Assert.IsTrue (project.IsDirty, "A3");
1137                 }
1138
1139                 [Test]
1140                 public void TestSetProjectExtensions3 ()
1141                 {
1142                         Engine engine;
1143                         Project project;
1144
1145                         string documentString = @"
1146                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
1147                                         <ProjectExtensions>
1148                                         </ProjectExtensions>
1149                                 </Project>
1150                         ";
1151
1152                         engine = new Engine (Consts.BinPath);
1153                         project = engine.CreateNewProject ();
1154                         project.LoadXml (documentString);
1155
1156                         project.SetProjectExtensions ("name", "1");
1157                         Assert.AreEqual ("1", project.GetProjectExtensions ("name"), "A1");
1158                         Assert.IsTrue (project.IsDirty, "A2");
1159                 }
1160
1161                 [Test]
1162                 public void TestBuildProjectError1 ()
1163                 {
1164                         Engine engine = new Engine (Consts.BinPath);
1165                         Project project = engine.CreateNewProject ();
1166
1167                         Assert.IsFalse (project.Build ((string) null), "A1");
1168                         Assert.IsFalse (project.Build ((string[]) null), "A2");
1169                         Assert.IsFalse (project.Build ((string []) null, null), "A3");
1170                         Assert.IsFalse (project.Build ((string []) null, null, BuildSettings.None), "A4");
1171                 }
1172
1173                 [Test]
1174                 public void TestBuildProjectError2 ()
1175                 {
1176                         Engine engine = new Engine (Consts.BinPath);
1177                         Project project = engine.CreateNewProject ();
1178
1179                         try {
1180                                 project.Build (new string [] { null });
1181                         } catch {
1182                                 return;
1183                         }
1184                         Assert.Fail ("Expected exception for project.Build, null string in targetNames []");
1185                 }
1186
1187                 [Test]
1188                 public void TestBuildProjectFile1 ()
1189                 {
1190                         Project project = CreateAndLoadProject ("foo.proj", false, new string [] { "1", "2" }, new bool [] { true, true }, "TBPF1");
1191                         CheckProjectBuild (project, new string [] { "main" }, true, new string [] { "main" }, "TBPF1");
1192                 }
1193
1194                 [Test]
1195                 public void TestBuildProjectFileXml1 ()
1196                 {
1197                         Project project = CreateAndLoadProject (null, false, new string [] { "1", "2" }, new bool [] { true, true }, "TBPFX1");
1198                         CheckProjectBuild (project, new string [] { "main" }, true, new string [] { "main" }, "TBPFX1");
1199                 }
1200
1201                 [Test]
1202                 public void TestBuildProjectFile2 ()
1203                 {
1204                         Project project = CreateAndLoadProject ("foo.proj", false, new string [] { "1", "2", "3" }, new bool [] { true, false, true }, "TBPF2");
1205                         CheckProjectBuild (project, new string [] { "main" }, false, new string [0], "TBPF2");
1206                 }
1207
1208                 [Test]
1209                 public void TestBuildProjectFileXml2 ()
1210                 {
1211                         Project project = CreateAndLoadProject (null, false, new string [] { "1", "2", "3" }, new bool [] { true, false, true }, "TBPFX2");
1212                         CheckProjectBuild (project, new string [] { "main" }, false, new string [0], "TBPFX2");
1213                 }
1214
1215                 [Test]
1216                 public void TestBuildProjectFile3 ()
1217                 {
1218                         Project project = CreateAndLoadProject ("foo.proj", false, new string [] { "1", "2", "3" }, new bool [] { true, true, true }, "TBPF3");
1219                         CheckProjectBuild (project, new string [] { "1", "2" }, true, new string [] { "1", "2" }, "TBPF3");
1220                 }
1221
1222                 [Test]
1223                 public void TestBuildProjectFileXml3 ()
1224                 {
1225                         Project project = CreateAndLoadProject (null, false, new string [] { "1", "2", "3" }, new bool [] { true, true, true }, "TBPFX3");
1226                         CheckProjectBuild (project, new string [] { "1", "2" }, true, new string [] { "1", "2" }, "TBPFX3");
1227                 }
1228
1229                 [Test]
1230                 public void TestBuildProjectFile4 ()
1231                 {
1232                         Project project = CreateAndLoadProject ("foo.proj", false, new string [] { "1", "2", "3" }, new bool [] { true, false, true }, "TBPF4");
1233                         CheckProjectBuild (project, new string [] { "main" }, false, new string [0], "TBPF4");
1234                 }
1235
1236                 [Test]
1237                 public void TestBuildProjectFileXml4 ()
1238                 {
1239                         Project project = CreateAndLoadProject (null, false, new string [] { "1", "2", "3" }, new bool [] { true, false, true }, "TBPFX4");
1240                         CheckProjectBuild (project, new string [] { "main" }, false, new string [0], "TBPFX4");
1241                 }
1242
1243                 //Run separate tests
1244
1245                 //Run single target
1246                 [Test]
1247                 public void TestBuildProjectFile5 ()
1248                 {
1249                         Project project = CreateAndLoadProject ("foo.proj", true, new string [] { "1", "2", "3" }, new bool [] { true, false, true }, "TBPF5");
1250                         CheckProjectBuild (project, new string [] { "main" }, false, new string [0], "TBPF5");
1251                 }
1252
1253                 [Test]
1254                 public void TestBuildProjectFileXml5 ()
1255                 {
1256                         Project project = CreateAndLoadProject (null, true, new string [] { "1", "2", "3" }, new bool [] { true, false, true }, "TBPFX5");
1257                         CheckProjectBuild (project, new string [] { "main" }, false, new string [0], "TBPFX5");
1258                 }
1259
1260                 [Test]
1261                 public void TestBuildProjectFile6 ()
1262                 {
1263                         Project project = CreateAndLoadProject ("foo.proj", true, new string [] { "1", "2", "3" }, new bool [] { true, true, true }, "TBPF6");
1264                         CheckProjectBuild (project, new string [] { "main" }, true, new string [] { "main" }, "TBPF6");
1265                 }
1266
1267                 [Test]
1268                 public void TestBuildProjectFileXml6 ()
1269                 {
1270                         Project project = CreateAndLoadProject (null, true, new string [] { "1", "2", "3" }, new bool [] { true, true, true }, "TBPFX6");
1271                         CheckProjectBuild (project, new string [] { "main" }, true, new string [] { "main" }, "TBPFX6");
1272                 }
1273
1274                 // run multiple targets
1275                 [Test]
1276                 public void TestBuildProjectFile7 ()
1277                 {
1278                         Project project = CreateAndLoadProject ("foo.proj", true, new string [] { "1", "2", "3" }, new bool [] { true, true, true }, "TBPF7");
1279                         CheckProjectBuild (project, new string [] { "1", "2", "3" }, true, new string [] { "1", "2", "3" }, "TBPF7");
1280                 }
1281
1282                 [Test]
1283                 public void TestBuildProjectFileXml7 ()
1284                 {
1285                         Project project = CreateAndLoadProject (null, true, new string [] { "1", "2", "3" }, new bool [] { true, true, true }, "TBPFX7");
1286                         CheckProjectBuild (project, new string [] { "1", "2", "3" }, true, new string [] { "1", "2", "3" }, "TBPFX7");
1287                 }
1288
1289                 [Test]
1290                 public void TestBuildProjectFile8 ()
1291                 {
1292                         Project project = CreateAndLoadProject ("foo.proj", true, new string [] { "1", "2", "3" }, new bool [] { true, true, false }, "TBPF8");
1293                         CheckProjectBuild (project, new string [] { "1", "2", "3" }, false, new string [] { "1", "2"}, "TBPF8");
1294                 }
1295
1296                 [Test]
1297                 public void TestBuildProjectFileXml8 ()
1298                 {
1299                         Project project = CreateAndLoadProject (null, true, new string [] { "1", "2", "3" }, new bool [] { true, true, false }, "TBPFX8");
1300                         CheckProjectBuild (project, new string [] { "1", "2", "3" }, false, new string [] { "1", "2"}, "TBPFX8");
1301                 }
1302
1303                 [Test]
1304                 public void TestBatchedMetadataRef1 ()
1305                 {
1306                         //test for multiple items with same metadata also
1307                          string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1308                         <UsingTask TaskName=""BatchingTestTask"" AssemblyFile=""Test/resources/TestTasks.dll"" />
1309                         <ItemGroup>
1310                                 <Coll1 Include=""A1""><Name>Abc</Name></Coll1>
1311                                 <Coll1 Include=""A2""><Name>Def</Name></Coll1>
1312                                 <Coll1 Include=""A3""><Name>Xyz</Name></Coll1>
1313                                 <Coll1 Include=""A4""><Name>Xyz</Name></Coll1>
1314                                 <Coll2 Include=""B1""></Coll2>
1315                         </ItemGroup>
1316                                 <Target Name=""ShowMessage"">
1317                                         <BatchingTestTask Sources=""%(Coll1.Name)"">
1318                                                 <Output TaskParameter=""Output"" ItemName=""FinalList"" />
1319                                         </BatchingTestTask>
1320                                         <Message Text=""Msg: %(Coll1.Name)"" />
1321                                 </Target>
1322                  </Project>";
1323
1324                         Engine engine = new Engine (Consts.BinPath);
1325                         Project project = engine.CreateNewProject ();
1326
1327                         project.LoadXml (projectString);
1328                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
1329
1330                         BuildItemGroup include = project.GetEvaluatedItemsByName ("FinalList");
1331                         Assert.AreEqual (3, include.Count, "A2");
1332
1333                         Assert.AreEqual ("FinalList", include [0].Name, "A3");
1334                         Assert.AreEqual ("Abc", include [0].FinalItemSpec, "A4");
1335
1336                         Assert.AreEqual ("FinalList", include [1].Name, "A5");
1337                         Assert.AreEqual ("Def", include [1].FinalItemSpec, "A6");
1338
1339                         Assert.AreEqual ("FinalList", include [2].Name, "A7");
1340                         Assert.AreEqual ("Xyz", include [2].FinalItemSpec, "A8");
1341                 }
1342
1343                 [Test]
1344                 public void TestBatchedMetadataRef2 ()
1345                 {
1346                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1347                         <UsingTask TaskName=""BatchingTestTask"" AssemblyFile=""Test/resources/TestTasks.dll"" />
1348                         <ItemGroup>
1349                                 <Coll1 Include=""A1""><Name>Abc</Name></Coll1>
1350                                 <Coll1 Include=""A2""><Name>Def</Name></Coll1>
1351                                 <Coll1 Include=""A3""><Name>Xyz</Name></Coll1>
1352                                 <Coll1 Include=""A4""><Name>Abc</Name></Coll1>
1353                                 <Coll2 Include=""B1""><Name>Bar</Name></Coll2>
1354                                 <Coll2 Include=""B2""><Name>Bar</Name></Coll2>
1355                         </ItemGroup>
1356                                 <Target Name=""ShowMessage"">
1357                                         <BatchingTestTask Sources=""%(Name)"" Strings=""@(Coll2)"">
1358                                                 <Output TaskParameter=""Output"" ItemName=""FinalList"" />
1359                                         </BatchingTestTask>
1360                                         <Message Text=""Msg: %(Coll1.Name)"" />
1361                                 </Target>
1362                                 <Target Name=""ShowMessage2"">
1363                                         <BatchingTestTask Sources=""%(Name)"" Strings=""@(Coll1)"">
1364                                                 <Output TaskParameter=""Output"" ItemName=""FinalList2"" />
1365                                         </BatchingTestTask>
1366                                         <Message Text=""Msg: %(Coll1.Name)"" />
1367                                 </Target>
1368                  </Project>";
1369
1370                         Engine engine = new Engine (Consts.BinPath);
1371                         Project project = engine.CreateNewProject ();
1372
1373                         project.LoadXml (projectString);
1374                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
1375
1376                         BuildItemGroup include = project.GetEvaluatedItemsByName ("FinalList");
1377                         Assert.AreEqual (1, include.Count, "A2");
1378
1379                         Assert.AreEqual ("FinalList", include [0].Name, "A3");
1380                         Assert.AreEqual ("Bar", include [0].FinalItemSpec, "A4");
1381
1382                         Assert.IsTrue (project.Build ("ShowMessage2"), "A1: Build failed");
1383                         include = project.GetEvaluatedItemsByName ("FinalList2");
1384                         Assert.AreEqual (3, include.Count, "A5");
1385
1386                         Assert.AreEqual ("FinalList2", include [0].Name, "A6");
1387                         Assert.AreEqual ("Abc", include [0].FinalItemSpec, "A7");
1388
1389                         Assert.AreEqual ("FinalList2", include [1].Name, "A8");
1390                         Assert.AreEqual ("Def", include [1].FinalItemSpec, "A9");
1391
1392                         Assert.AreEqual ("FinalList2", include [2].Name, "A10");
1393                         Assert.AreEqual ("Xyz", include [2].FinalItemSpec, "A11");
1394                 }
1395
1396                 [Test]
1397                 public void TestBatchedMetadataRef3 ()
1398                 {
1399                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1400                         <UsingTask TaskName=""BatchingTestTask"" AssemblyFile=""Test/resources/TestTasks.dll"" />
1401                         <ItemGroup>
1402                                 <Coll1 Include=""A1""><Name>Abc</Name></Coll1>
1403                                 <Coll1 Include=""A2""><Name>Def</Name></Coll1>
1404                                 <Coll1 Include=""A3""><Name>Xyz</Name></Coll1>
1405                                 <Coll1 Include=""A4""><Name>Abc</Name></Coll1>
1406                                 <Coll2 Include=""B1""><Name>Bar</Name></Coll2>
1407                                 <Coll2 Include=""B2""><Name>Bar</Name></Coll2>
1408                         </ItemGroup>
1409                                 <Target Name=""ShowMessage"">
1410                                         <BatchingTestTask SingleTaskItem=""%(Coll2.Name)"" >
1411                                                 <Output TaskParameter=""SingleStringOutput"" ItemName=""FinalList"" />
1412                                         </BatchingTestTask>
1413                                         <Message Text=""Msg: %(Coll1.Name)"" />
1414                                 </Target>
1415                  </Project>";
1416
1417                         Engine engine = new Engine (Consts.BinPath);
1418                         Project project = engine.CreateNewProject ();
1419
1420                         project.LoadXml (projectString);
1421                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
1422
1423                         BuildItemGroup include = project.GetEvaluatedItemsByName ("FinalList");
1424                         Assert.AreEqual (1, include.Count, "A2");
1425
1426                         Assert.AreEqual ("FinalList", include [0].Name, "A3");
1427                         Assert.AreEqual ("Bar", include [0].FinalItemSpec, "A4");
1428
1429                 }
1430
1431                 [Test]
1432                 public void TestBatchedMetadataRef4 ()
1433                 {
1434                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1435                         <UsingTask TaskName=""BatchingTestTask"" AssemblyFile=""Test/resources/TestTasks.dll"" />
1436                         <ItemGroup>
1437                                 <Coll1 Include=""A1""><Name>Abc</Name></Coll1>
1438                                 <Coll1 Include=""A2""><Name>Def</Name></Coll1>
1439                                 <Coll1 Include=""A3""><Name>Xyz</Name></Coll1>
1440                                 <Coll2 Include=""B1""><Name>Bar</Name></Coll2>
1441                         </ItemGroup>
1442                                 <Target Name=""ShowMessage"">
1443                                         <BatchingTestTask SingleTaskItem=""%(Coll3.Name)"" >
1444                                                 <Output TaskParameter=""SingleStringOutput"" ItemName=""FinalList"" />
1445                                         </BatchingTestTask>
1446                                 </Target>
1447                  </Project>";
1448
1449                         Engine engine = new Engine (Consts.BinPath);
1450                         Project project = engine.CreateNewProject ();
1451
1452                         project.LoadXml (projectString);
1453                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
1454
1455                         BuildItemGroup include = project.GetEvaluatedItemsByName ("FinalList");
1456                         Assert.AreEqual (0, include.Count, "A2");
1457                 }
1458
1459                 [Test]
1460                 public void TestBatchedMetadataRef5 ()
1461                 {
1462                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1463                         <UsingTask TaskName=""BatchingTestTask"" AssemblyFile=""Test/resources/TestTasks.dll"" />
1464                         <ItemGroup>
1465                                 <Coll1 Include=""A1""><Name>Abc</Name></Coll1>
1466                                 <Coll1 Include=""A2""><Name>Def</Name></Coll1>
1467                                 <Coll1 Include=""A3""><Name>Xyz</Name></Coll1>
1468                                 <Coll2 Include=""B1""><Name>Bar</Name></Coll2>
1469                         </ItemGroup>
1470                                 <Target Name=""ShowMessage"">
1471                                         <Message Text=""Coll1: @(Coll1->'Foo%(Name)Bar')"" />
1472                                         <BatchingTestTask Sources=""@(Coll1->'Foo%(Name)Bar')"" >
1473                                                 <Output TaskParameter=""Output"" ItemName=""FinalList"" />
1474                                         </BatchingTestTask>
1475                                 </Target>
1476                  </Project>";
1477
1478                         Engine engine = new Engine (Consts.BinPath);
1479                         Project project = engine.CreateNewProject ();
1480                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1481                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1482                         engine.RegisterLogger (logger);
1483
1484                         project.LoadXml (projectString);
1485                         bool result = project.Build ("ShowMessage");
1486                         if (!result) {
1487                                 logger.DumpMessages ();
1488                                 Assert.Fail ("A1: Build failed");
1489                         }
1490                         BuildItemGroup include = project.GetEvaluatedItemsByName ("FinalList");
1491                         Assert.AreEqual (3, include.Count, "A2");
1492                 }
1493
1494                 [Test]
1495                 public void TestBatchedMetadataRefInOutput () {
1496                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1497                         <UsingTask TaskName=""BatchingTestTask"" AssemblyFile=""Test/resources/TestTasks.dll"" />
1498                         <ItemGroup>
1499                                 <Coll1 Include=""A1""><Name>Abc</Name></Coll1>
1500                                 <Coll1 Include=""A2""><Name>Def</Name></Coll1>
1501                                 <Coll1 Include=""A3""><Name>Abc</Name></Coll1>
1502                                 <Coll1 Include=""B1""><Name>Bar</Name></Coll1>
1503                         </ItemGroup>
1504                                 <Target Name=""ShowMessage"">
1505                                         <BatchingTestTask Sources=""@(Coll1)"" >
1506                                                 <Output TaskParameter=""Output"" ItemName=""AbcItems"" Condition=""'%(Coll1.Name)' == 'Abc'""/>
1507                                                 <Output TaskParameter=""Output"" ItemName=""NonAbcItems"" Condition=""'%(Coll1.Name)' != 'Abc'""/>
1508                                         </BatchingTestTask>
1509                                         <Message Text='AbcItems: @(AbcItems)' />
1510                                         <Message Text='NonAbcItems: @(NonAbcItems)' />
1511                                 </Target>
1512                  </Project>";
1513
1514                         Engine engine = new Engine (Consts.BinPath);
1515                         Project project = engine.CreateNewProject ();
1516                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1517                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1518                         engine.RegisterLogger (logger);
1519
1520                         project.LoadXml (projectString);
1521                         bool result = project.Build ("ShowMessage");
1522                         if (!result) {
1523                                 logger.DumpMessages ();
1524                                 Assert.Fail ("A1: Build failed");
1525                         }
1526
1527                         logger.CheckLoggedMessageHead ("AbcItems: A1;A3", "A2");
1528                         logger.CheckLoggedMessageHead ("NonAbcItems: A2;B1", "A2");
1529
1530                         if (logger.NormalMessageCount != 0) {
1531                                 logger.DumpMessages ();
1532                                 Assert.Fail ("Unexpected extra messages found");
1533                         }
1534                 }
1535
1536                 [Test]
1537                 public void TestInitialTargets ()
1538                 {
1539                         Engine engine = new Engine (Consts.BinPath);
1540                         Project project = engine.CreateNewProject ();
1541
1542                         project.LoadXml (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" InitialTargets=""pre  "">
1543                                 <Target Name=""boo"">
1544                                         <Message Text=""Executing boo target""/>
1545                                 </Target>
1546                                 <Target Name=""pre"">
1547                                         <Message Text=""Executing pre target""/>
1548                                 </Target>
1549                         </Project>");
1550
1551                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1552                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1553                         engine.RegisterLogger (logger);
1554
1555                         try {
1556                                 Assert.IsTrue (project.Build (), "Build failed");
1557
1558                                 logger.CheckLoggedMessageHead ("Executing pre target", "A1");
1559                                 logger.CheckLoggedMessageHead ("Executing boo target", "A2");
1560
1561                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1562                         } catch {
1563                                 logger.DumpMessages ();
1564                                 throw;
1565                         }
1566                 }
1567
1568                 [Test]
1569                 public void TestInitialTargetsWithImports () {
1570                         Engine engine = new Engine (Consts.BinPath);
1571                         Project project = engine.CreateNewProject ();
1572
1573                         string second = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" InitialTargets=""One  "">
1574                                 <Target Name=""One"">
1575                                         <Message Text='Executing Second::One target'/>
1576                                 </Target>
1577                                 <Import Project='third.proj'/>
1578                         </Project>
1579 ";
1580                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
1581                                 sw.Write (second);
1582                         }
1583
1584                         string third = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" InitialTargets=""Two"">
1585                                 <Target Name=""Two"">
1586                                         <Message Text='Executing Third::Two target'/>
1587                                 </Target>
1588                         </Project>
1589 ";
1590                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "third.proj")))) {
1591                                 sw.Write (third);
1592                         }
1593
1594                         project.LoadXml (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" InitialTargets=""pre"">
1595                                 <Target Name=""boo"">
1596                                         <Message Text=""Executing boo target""/>
1597                                 </Target>
1598                                 <Target Name=""pre"">
1599                                         <Message Text=""Executing pre target""/>
1600                                 </Target>
1601                                 <Import Project='Test/resources/second.proj'/>
1602                         </Project>");
1603
1604                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1605                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1606                         engine.RegisterLogger (logger);
1607
1608                         try {
1609                                 Assert.IsTrue (project.Build (), "Build failed");
1610
1611                                 logger.CheckLoggedMessageHead ("Executing pre target", "A1");
1612                                 logger.CheckLoggedMessageHead ("Executing Second::One target", "A2");
1613                                 logger.CheckLoggedMessageHead ("Executing Third::Two target", "A3");
1614                                 logger.CheckLoggedMessageHead ("Executing boo target", "A4");
1615                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1616
1617                                 Assert.AreEqual ("pre; One; Two", project.InitialTargets, "List of initial targets");
1618                         } catch {
1619                                 logger.DumpMessages ();
1620                                 throw;
1621                         }
1622                 }
1623
1624                 [Test]
1625                 public void TestDefaultTargets () {
1626                         Engine engine = new Engine (Consts.BinPath);
1627                         Project project = engine.CreateNewProject ();
1628
1629                         project.LoadXml (@"<Project DefaultTargets='pre' xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" >
1630                                 <Target Name=""boo"">
1631                                         <Message Text=""Executing boo target""/>
1632                                 </Target>
1633                                 <Target Name=""pre"">
1634                                         <Message Text=""Executing pre target""/>
1635                                 </Target>
1636                         </Project>");
1637
1638                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1639                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1640                         engine.RegisterLogger (logger);
1641
1642                         try {
1643                                 Assert.IsTrue (project.Build (), "Build failed");
1644
1645                                 logger.CheckLoggedMessageHead ("Executing pre target", "A1");
1646                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1647
1648                                 Assert.AreEqual ("pre", project.DefaultTargets, "Default targets");
1649                         } catch {
1650                                 logger.DumpMessages ();
1651                                 throw;
1652                         }
1653                 }
1654
1655
1656                 [Test]
1657                 public void TestDefaultTargetsWithImports () {
1658                         Engine engine = new Engine (Consts.BinPath);
1659                         Project project = engine.CreateNewProject ();
1660
1661                         string second = @"<Project DefaultTargets='One' xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1662                                 <Target Name=""One"">
1663                                         <Message Text='Executing Second::One target'/>
1664                                 </Target>
1665                         </Project>";
1666                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
1667                                 sw.Write (second);
1668                         }
1669
1670                         project.LoadXml (@"<Project DefaultTargets='pre' xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" >
1671                                 <Target Name=""boo"">
1672                                         <Message Text=""Executing boo target""/>
1673                                 </Target>
1674                                 <Target Name=""pre"">
1675                                         <Message Text=""Executing pre target""/>
1676                                 </Target>
1677                                 <Import Project='Test/resources/second.proj'/>
1678                         </Project>");
1679
1680                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1681                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1682                         engine.RegisterLogger (logger);
1683
1684                         try {
1685                                 Assert.IsTrue (project.Build (), "Build failed");
1686
1687                                 logger.CheckLoggedMessageHead ("Executing pre target", "A1");
1688                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1689
1690                                 Assert.AreEqual ("pre", project.DefaultTargets, "Default targets");
1691                         } catch {
1692                                 logger.DumpMessages ();
1693                                 throw;
1694                         }
1695                 }
1696
1697                 [Test]
1698                 public void TestNoDefaultTargetsWithImports () {
1699                         Engine engine = new Engine (Consts.BinPath);
1700                         Project project = engine.CreateNewProject ();
1701
1702
1703                         string second = @"<Project DefaultTargets='; One  ; Two' xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1704                                 <Target Name=""One"">
1705                                         <Message Text='Executing Second::One target'/>
1706                                 </Target>
1707                                 <Target Name=""Two"">
1708                                         <Message Text='Executing Second::Two target'/>
1709                                 </Target>
1710
1711                         </Project>";
1712                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
1713                                 sw.Write (second);
1714                         }
1715
1716                         project.LoadXml (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" >
1717                                 <Target Name=""boo"">
1718                                         <Message Text=""Executing boo target""/>
1719                                 </Target>
1720                                 <Target Name=""pre"">
1721                                         <Message Text=""Executing pre target""/>
1722                                 </Target>
1723                                 <Import Project='Test/resources/second.proj'/>
1724                         </Project>");
1725
1726                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1727                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1728                         engine.RegisterLogger (logger);
1729
1730                         try {
1731                                 Assert.IsTrue (project.Build (), "Build failed");
1732
1733                                 logger.CheckLoggedMessageHead ("Executing Second::One target", "A1");
1734                                 logger.CheckLoggedMessageHead ("Executing Second::Two target", "A2");
1735                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1736
1737                                 Assert.AreEqual ("One; Two", project.DefaultTargets, "Default targets");
1738                         } catch {
1739                                 logger.DumpMessages ();
1740                                 throw;
1741                         }
1742                 }
1743
1744                 [Test]
1745                 public void TestNoDefaultTargets () {
1746                         Engine engine = new Engine (Consts.BinPath);
1747                         Project project = engine.CreateNewProject ();
1748
1749                         project.LoadXml (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" >
1750                                 <Target Name=""boo"">
1751                                         <Message Text=""Executing boo target""/>
1752                                 </Target>
1753                                 <Target Name=""pre"">
1754                                         <Message Text=""Executing pre target""/>
1755                                 </Target>
1756                         </Project>");
1757
1758                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1759                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1760                         engine.RegisterLogger (logger);
1761
1762                         try {
1763                                 Assert.IsTrue (project.Build (), "Build failed");
1764
1765                                 logger.CheckLoggedMessageHead ("Executing boo target", "A1");
1766                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1767
1768                                 Assert.AreEqual ("", project.DefaultTargets, "Default targets");
1769                         } catch {
1770                                 logger.DumpMessages ();
1771                                 throw;
1772                         }
1773                 }
1774
1775                 [Test]
1776                 public void TestPropertiesFromImportedProjects ()
1777                 {
1778                         Engine engine = new Engine (Consts.BinPath);
1779                         Project project = engine.CreateNewProject ();
1780
1781                         string second = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
1782         <PropertyGroup>
1783           <Prop1>InitialVal</Prop1>
1784         </PropertyGroup>
1785         <ItemGroup>
1786                 <Second Include=""$(ThirdProp):Third""/>
1787         </ItemGroup>
1788
1789         <Target Name=""Main"">
1790                 <Message Text=""Prop1: $(Prop1) FooItem: @(FooItem)""/>
1791                 <Message Text=""Second: @(Second) ThirdProp: $(ThirdProp)""/>
1792         </Target>
1793         <Import Project=""third.proj""/>
1794 </Project>";
1795                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
1796                                 sw.Write (second);
1797                         }
1798
1799                         string third = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
1800         <PropertyGroup>
1801           <ThirdProp>Third Value</ThirdProp>
1802         </PropertyGroup>
1803 </Project>";
1804                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "third.proj")))) {
1805                                 sw.Write (third);
1806                         }
1807
1808                         project.LoadXml (@"<Project InitialTargets=""Main"" xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1809         <ItemGroup>
1810                 <FooItem Include=""$(Prop1):Something""/>
1811         </ItemGroup>
1812
1813         <Import Project=""Test/resources/second.proj""/>
1814 </Project>");
1815
1816                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1817                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1818                         engine.RegisterLogger (logger);
1819
1820                         try {
1821                                 Assert.IsTrue (project.Build (), "Build failed");
1822
1823                                 logger.CheckLoggedMessageHead ("Prop1: InitialVal FooItem: InitialVal:Something", "A1");
1824                                 logger.CheckLoggedMessageHead ("Second: Third Value:Third ThirdProp: Third Value", "A2");
1825
1826                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1827                         } catch {
1828                                 logger.DumpMessages ();
1829                                 throw;
1830                         }
1831                 }
1832
1833                 [Test]
1834                 public void TestMSBuildThisProperties ()
1835                 {
1836                         Engine engine = new Engine (Consts.BinPath);
1837                         Project project = engine.CreateNewProject ();
1838
1839                         string base_dir = Path.GetFullPath (Path.Combine ("Test", "resources")) + Path.DirectorySeparatorChar;
1840                         string tmp_dir = Path.GetFullPath (Path.Combine (base_dir, "tmp")) + Path.DirectorySeparatorChar;
1841
1842                         string first_project = Path.Combine (base_dir, "first.proj");
1843                         string second_project = Path.Combine (tmp_dir, "second.proj");
1844                         string third_project = Path.Combine (tmp_dir, "third.proj");
1845
1846                         string first = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
1847                                 <PropertyGroup>
1848                                         <FooInMain>$(MSBuildThisFileDirectory)</FooInMain>
1849                                 </PropertyGroup>
1850                                 <ItemGroup>
1851                                         <ItemInMain Include=""$(MSBuildThisFileFullPath)"" />
1852                                 </ItemGroup>
1853                                 <Import Project=""tmp\second.proj""/>
1854                         </Project>";
1855
1856                         string second = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
1857                                 <PropertyGroup>
1858                                         <FooInImport1>$(MSBuildThisFileDirectory)</FooInImport1>
1859                                 </PropertyGroup>
1860                                 <PropertyGroup>
1861                                         <FooInImport2>$(MSBuildThisFileDirectory)</FooInImport2>
1862                                 </PropertyGroup>
1863                                 <ItemGroup>
1864                                         <ItemInImport1 Include=""$(MSBuildThisFileFullPath)"" />
1865                                 </ItemGroup>
1866
1867                                 <Import Project=""third.proj""/>
1868                         </Project>";
1869
1870                         string third = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
1871                                 <PropertyGroup>
1872                                         <FooInTwo>$(MSBuildThisFileFullPath)</FooInTwo>
1873                                 </PropertyGroup>
1874                                 <ItemGroup>
1875                                         <ItemInTwo Include=""$(MSBuildThisFileFullPath)"" />
1876                                 </ItemGroup>
1877
1878                                 <Target Name=""TargetInTwo"">
1879                                         <Message Text=""FooInMain: $(FooInMain)""/>
1880                                         <Message Text=""FooInImport1: $(FooInImport1)""/>
1881                                         <Message Text=""FooInImport2: $(FooInImport2)""/>
1882                                         <Message Text=""FooInTwo: $(FooInTwo)""/>
1883
1884                                         <Message Text=""ItemInMain: %(ItemInMain.Identity)""/>
1885                                         <Message Text=""ItemInImport1: %(ItemInImport1.Identity)""/>
1886                                         <Message Text=""ItemInTwo: %(ItemInTwo.Identity)""/>
1887                                         <Message Text=""Full path: $(MSBuildThisFileFullPath)""/>
1888                                 </Target>
1889                         </Project>";
1890
1891                         File.WriteAllText (first_project, first);
1892
1893                         Directory.CreateDirectory (Path.Combine (base_dir, "tmp"));
1894                         File.WriteAllText (second_project, second);
1895                         File.WriteAllText (third_project, third);
1896
1897                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1898                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1899                         engine.RegisterLogger (logger);
1900
1901                         project.Load (first_project);
1902                         try {
1903                                 Assert.IsTrue (project.Build (), "Build failed");
1904
1905                                 logger.CheckLoggedMessageHead ("FooInMain: " + base_dir, "A1");
1906                                 logger.CheckLoggedMessageHead ("FooInImport1: " + tmp_dir, "A2");
1907                                 logger.CheckLoggedMessageHead ("FooInImport2: " + tmp_dir, "A3");
1908                                 logger.CheckLoggedMessageHead ("FooInTwo: " + third_project, "A4");
1909                                 logger.CheckLoggedMessageHead ("ItemInMain: " + first_project, "A5");
1910                                 logger.CheckLoggedMessageHead ("ItemInImport1: " + second_project, "A6");
1911                                 logger.CheckLoggedMessageHead ("ItemInTwo: " + third_project, "A7");
1912                                 logger.CheckLoggedMessageHead ("Full path: " + third_project, "A8");
1913
1914                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1915                         } catch {
1916                                 logger.DumpMessages ();
1917                                 throw;
1918                         } finally {
1919                                 File.Delete (first_project);
1920                                 File.Delete (second_project);
1921                                 File.Delete (third_project);
1922                         }
1923                 }
1924
1925                 [Test]
1926                 public void TestRequiredTask_String1 ()
1927                 {
1928                         CheckProjectForRequiredTests ("RequiredTestTask_String", "@(NonExistant)",
1929                                 false, "Should've failed: No value specified for required field - 'Property' of RequiredTestTask_String", null);
1930                 }
1931
1932                 [Test]
1933                 public void TestRequiredTask_String2 ()
1934                 {
1935                         CheckProjectForRequiredTests ("RequiredTestTask_String", "$(NonExistant)",
1936                                 false, "Should've failed: No value specified for required field - 'Property' of RequiredTestTask_String", null);
1937                 }
1938
1939                 [Test]
1940                 public void TestRequiredTask_Strings1 () {
1941                         CheckProjectForRequiredTests ("RequiredTestTask_Strings", "@(NonExistant)",
1942                                 true, "Build failed", "0");
1943                 }
1944
1945                 [Test]
1946                 public void TestRequiredTask_Strings2 () {
1947                         CheckProjectForRequiredTests ("RequiredTestTask_Strings", "$(NonExistant)",
1948                                 true, "Build failed", "0");
1949                 }
1950
1951                 [Test]
1952                 public void TestRequiredTask_Strings3 () {
1953                         CheckProjectForRequiredTests ("RequiredTestTask_Strings", "%(NonExistant.Md)",
1954                                 true, "Build failed", "0");
1955                 }
1956
1957                 [Test]
1958                 public void TestRequiredTask_Strings4 () {
1959                         CheckProjectForRequiredTests ("RequiredTestTask_Strings", "  %(NonExistant.Md)",
1960                                 true, "Build failed", "0");
1961                 }
1962
1963                 [Test]
1964                 public void TestRequiredTask_Ints1 () {
1965                         CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "@(NonExistant)",
1966                                 true, "Build failed", "count: 0");
1967                 }
1968
1969                 [Test]
1970                 public void TestRequiredTask_Ints2 () {
1971                         CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "$(NonExistant)",
1972                                 true, "Build failed", "count: 0");
1973                 }
1974
1975                 [Test]
1976                 public void TestRequiredTask_OtherObjectsArray () {
1977                         CheckProjectForRequiredTests ("RequiredTestTask_OtherObjectArray", "@(NonExistant)",
1978                                 false, "Should've failed: ObjectArray type not supported as a property type", null);
1979                 }
1980
1981                 [Test]
1982                 public void TestRequiredTask_OtherObject () {
1983                         CheckProjectForRequiredTests ("RequiredTestTask_OtherObjectArray", "@(NonExistant)",
1984                                 false, "Should've failed: ObjectArray type not supported as a property type", null);
1985                 }
1986
1987                 [Test]
1988                 public void TestRequiredTask_MyTaskItems1 () {
1989                         CheckProjectForRequiredTests ("RequiredTestTask_MyTaskItemArray", "@(NonExistant)",
1990                                 false, "Should've failed: ObjectArray type not supported as a property type", null);
1991                 }
1992
1993                 [Test]
1994                 public void TestRequiredTask_TaskItem1 ()
1995                 {
1996                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_TaskItem", "@(NonExistant)",
1997                                 false, "Should've failed: No value specified for required field - 'Property' of RequiredTestTask_TaskItem", null);
1998                 }
1999
2000                 [Test]
2001                 public void TestRequiredTask_TaskItem2 ()
2002                 {
2003                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_TaskItem", "$(NonExistant)",
2004                                 false, "Should've failed: No value specified for required field - 'Property' of RequiredTestTask_TaskItem", null);
2005                 }
2006
2007                 [Test]
2008                 public void TestRequiredTask_TaskItemArray1 ()
2009                 {
2010                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_TaskItems", "@(NonExistant)",
2011                                 true, "Build failed", "count: 0");
2012
2013                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
2014                         Assert.AreEqual (1, group.Count, "A2");
2015                         Assert.AreEqual ("count: 0", group [0].FinalItemSpec, "A3");
2016                 }
2017
2018                 [Test]
2019                 public void TestRequiredTask_TaskItemArray2 ()
2020                 {
2021                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_TaskItems", "$(NonExistant)",
2022                                 true, "Build failed", "count: 0");
2023
2024                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
2025                         Assert.AreEqual (1, group.Count, "A2");
2026                         Assert.AreEqual ("count: 0", group [0].FinalItemSpec, "A3");
2027                 }
2028
2029                 [Test]
2030                 public void TestRequiredTask_TaskItemArray3 ()
2031                 {
2032                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "$(NonExistant)",
2033                                 true, "Build failed", "count: 0");
2034
2035                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
2036                         Assert.AreEqual (1, group.Count, "A2");
2037                         Assert.AreEqual ("count: 0", group [0].FinalItemSpec, "A3");
2038                 }
2039
2040                 [Test]
2041                 public void TestRequiredTask_TaskItemArray4 () {
2042                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "%(NonExistant.Md)",
2043                                 true, "Build failed", "count: 0");
2044
2045                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
2046                         Assert.AreEqual (1, group.Count, "A2");
2047                         Assert.AreEqual ("count: 0", group[0].FinalItemSpec, "A3");
2048                 }
2049
2050                 [Test]
2051                 public void TestRequiredTask_TaskItemArray5 () {
2052                         // with extra space in prop value
2053                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "  %(NonExistant.Md)",
2054                                 true, "Build failed", "count: 0");
2055
2056                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
2057                         Assert.AreEqual (1, group.Count, "A2");
2058                         Assert.AreEqual ("count: 0", group[0].FinalItemSpec, "A3");
2059                 }
2060
2061
2062                 [Test]
2063                 public void TestCaseSensitivityOfProjectElements ()
2064                 {
2065                         string projectXml = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
2066         <ItemGroup>
2067                 <Abc Include=""foo"">
2068                         <MetaDaTA1>md1</MetaDaTA1>
2069                         <METadata2>md2</METadata2>
2070                 </Abc>
2071                 <Abc Include=""FOO"">
2072                         <MetaDaTA1>MD1 caps</MetaDaTA1>
2073                         <METadata2>MD2 caps</METadata2>
2074                 </Abc>
2075                 <Abc Include=""hmm"">
2076                         <MetaDaTA1>Md1 CAPS</MetaDaTA1>
2077                         <METadata2>MD2 CAPS</METadata2>
2078                 </Abc>
2079                 <Abc Include=""bar"">
2080                         <MeTAdata1>md3</MeTAdata1>
2081                         <Metadata2>md4</Metadata2>
2082                 </Abc>
2083         </ItemGroup>
2084         <PropertyGroup><ProP1>ValueProp</ProP1></PropertyGroup>
2085         <Target Name=""Main"">
2086                 <MesSAGE Text=""Full item: @(ABC)""/>
2087                 <MEssaGE Text=""metadata1 :%(AbC.MetaDATA1) metadata2: %(ABC.MetaDaTa2)""/>
2088                 <MEssaGE Text=""metadata2 : %(AbC.MetaDAta2)""/>
2089                 <MEssaGE Text=""Abc identity: %(ABC.IDENTitY)""/>
2090                 <MEssaGE Text=""prop1 : $(pROp1)""/>
2091         </Target>
2092 </Project>
2093 ";
2094                         Engine engine = new Engine (Consts.BinPath);
2095                         Project project = engine.CreateNewProject ();
2096                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
2097                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
2098                         engine.RegisterLogger (logger);
2099
2100                         project.LoadXml (projectXml);
2101                         bool result = project.Build ("Main");
2102                         if (!result) {
2103                                 logger.DumpMessages ();
2104                                 Assert.Fail ("A1: Build failed");
2105                         }
2106
2107                         logger.CheckLoggedMessageHead ("Full item: foo;FOO;hmm;bar", "#A2");
2108                         logger.CheckLoggedMessageHead ("metadata1 :md1 metadata2: md2", "#A3");
2109                         logger.CheckLoggedMessageHead ("metadata1 :MD1 caps metadata2: MD2 caps", "#A4");
2110                         logger.CheckLoggedMessageHead ("metadata1 :md3 metadata2: md4", "#A5");
2111                         logger.CheckLoggedMessageHead ("metadata2 : md2", "#A6");
2112                         logger.CheckLoggedMessageHead ("metadata2 : MD2 caps", "#A7");
2113                         logger.CheckLoggedMessageHead ("metadata2 : md4", "#A8");
2114                         logger.CheckLoggedMessageHead ("Abc identity: foo", "#A9");
2115                         logger.CheckLoggedMessageHead ("Abc identity: hmm", "#A10");
2116                         logger.CheckLoggedMessageHead ("Abc identity: bar", "#A11");
2117                         logger.CheckLoggedMessageHead ("prop1 : ValueProp", "#A12");
2118
2119                         Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
2120
2121                 }
2122
2123                 // full solution test
2124                 //[Test]
2125                 public void TestBuildSolutionProject ()
2126                 {
2127                         string basepath = Path.Combine ("Test", Path.Combine ("resources", "Project01"));
2128                         string [] project_dirs = new string [] {
2129                                 Path.Combine (basepath, "Lib4"),
2130                                 Path.Combine (basepath, "Lib3"),
2131                                 Path.Combine (basepath, "Lib2"),
2132                                 Path.Combine (basepath, "Lib1"),
2133                                 Path.Combine (basepath, "Project01")
2134                         };
2135                         string debug_extn = Consts.RunningOnMono () ? ".dll.mdb" : ".pdb";
2136
2137                         // List of expected output files
2138                         // Lib3
2139                         string [] [] project_files = new string [5][] {
2140                                 new string [] { "Lib4.dll", "Lib4" + debug_extn },
2141                                 new string [] { "Lib3.dll" , "Lib3" + debug_extn },
2142                                 // Lib2
2143                                 new string [] {
2144                                         "Lib2.dll", "Lib2" + debug_extn,
2145                                         "lib2_folder/Lib2.deploy.txt",
2146                                         Path.Combine ("fr-CA", "Lib2.resources.dll"),
2147                                         Path.Combine ("fr-FR", "Lib2.resources.dll"),
2148                                         "Lib4.dll", "Lib4" + debug_extn
2149                                 },
2150
2151                                 // lib1
2152                                 new string [] {
2153                                         // lib1 files
2154                                         "Lib1.dll", "Lib2" + debug_extn,
2155                                         "Lib1.deploy.txt",
2156                                         Path.Combine ("fr-CA", "Lib1.resources.dll"),
2157                                         Path.Combine ("fr-FR", "Lib1.resources.dll"),
2158                                         Path.Combine ("en-US", "Lib1.resources.dll"),
2159                                         // lib2 files
2160                                         "Lib2.dll", "Lib2" + debug_extn,
2161                                         "lib2_folder/Lib2.deploy.txt",
2162                                         Path.Combine ("fr-CA", "Lib2.resources.dll"),
2163                                         Path.Combine ("fr-FR", "Lib2.resources.dll"),
2164                                         // lib3 files
2165                                         "Lib3.dll", "Lib3" + debug_extn,
2166                                         "Lib4.dll", "Lib4" + debug_extn
2167                                         },
2168
2169                                 new string [] {
2170                                         "Project01.exe",
2171                                         "Project01" + (Consts.RunningOnMono () ? ".exe.mdb" : ".pdb"),
2172                                         // lib1 files
2173                                         "Lib1.dll", "Lib1" + debug_extn,
2174                                         "Lib1.deploy.txt",
2175                                         Path.Combine ("fr-CA", "Lib1.resources.dll"),
2176                                         Path.Combine ("fr-FR", "Lib1.resources.dll"),
2177                                         Path.Combine ("en-US", "Lib1.resources.dll"),
2178                                         // lib2 files
2179                                         "Lib2.dll", "Lib2" + debug_extn,
2180                                         "lib2_folder/Lib2.deploy.txt",
2181                                         Path.Combine ("fr-CA", "Lib2.resources.dll"),
2182                                         Path.Combine ("fr-FR", "Lib2.resources.dll"),
2183                                         "Lib4.dll", "Lib4" + debug_extn,
2184                                         }
2185                         };
2186
2187                         // Cleanup
2188                         for (int i = 0; i < project_dirs.Length; i ++) {
2189                                 string bin_path = Path.Combine (project_dirs [i], Path.Combine ("bin", "Debug"));
2190                                 string obj_path = Path.Combine (project_dirs [i], Path.Combine ("obj", "Debug"));
2191
2192                                 DeleteAllInDir (bin_path);
2193
2194                                 DeleteAllInDir (obj_path);
2195                         }
2196
2197                         Engine engine = new Engine (Consts.BinPath);
2198                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
2199                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
2200                         engine.RegisterLogger (logger);
2201
2202                         engine.GlobalProperties = new BuildPropertyGroup ();
2203                         engine.GlobalProperties.SetProperty ("TreatWarningsAsErrors", "false");
2204
2205                         Project project = engine.CreateNewProject ();
2206                         project.Load (Path.Combine (basepath, "Project01.sln.proj"));
2207
2208                         bool result = project.Build ();
2209                         if (!result) {
2210                                 logger.DumpMessages ();
2211                                 Assert.Fail ("Build failed");
2212                         }
2213
2214                         // We check only the output dir, not the 'obj'
2215                         string debug = Path.Combine ("bin", "Debug");
2216                         for (int i = 0; i < project_dirs.Length; i++) {
2217                                 CheckFilesExistInDir (Path.Combine (project_dirs [i], debug),
2218                                         project_files [i]);
2219                         }
2220                 }
2221
2222                 void DeleteAllInDir (string path)
2223                 {
2224                         if (!Directory.Exists (path))
2225                                 return;
2226
2227                         foreach (string file in Directory.GetFiles (path))
2228                                 File.Delete (file);
2229                         Directory.Delete (path, true);
2230                 }
2231
2232                 void CheckFilesExistInDir (string dir, params string [] files)
2233                 {
2234                         foreach (string file in files) {
2235                                 string path = Path.Combine (dir, file);
2236                                 Assert.IsTrue (File.Exists (path),
2237                                         String.Format ("Expected to find file {0}", path));
2238                         }
2239                 }
2240
2241                 Project CheckProjectForRequiredTests (string taskname, string property_arg, bool expected_result, string error_msg,
2242                         string expected_output_msg)
2243                 {
2244                         string projectString = String.Format (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
2245                                 <UsingTask TaskName=""{0}"" AssemblyFile=""Test/resources/TestTasks.dll"" />
2246                                 <Target Name=""foo"">
2247                                         <{0} Property=""{1}"">
2248                                                 <Output TaskParameter=""Output"" ItemName=""OutItem""/>
2249                                         </{0}>
2250                                         <Message Text='@(OutItem)'/>
2251                                 </Target>
2252                         </Project>", taskname, property_arg);
2253
2254                         Engine engine = new Engine (Consts.BinPath);
2255                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
2256                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
2257                         engine.RegisterLogger (logger);
2258                         Project project = engine.CreateNewProject ();
2259                         project.LoadXml (projectString);
2260                         try {
2261                                 Assert.AreEqual (expected_result, project.Build (), error_msg);
2262                                 if (expected_result) {
2263                                         logger.CheckLoggedMessageHead (expected_output_msg, "A");
2264                                         Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected messages found");
2265                                 }
2266                         } catch {
2267                                 logger.DumpMessages ();
2268                         }
2269                         return project;
2270                 }
2271
2272                 static void CheckBuildItem (BuildItem item, string name, string [,] metadata, string finalItemSpec, string prefix)
2273                 {
2274                         Assert.AreEqual (name, item.Name, prefix + "#1");
2275                         for (int i = 0; i < metadata.GetLength (0); i++) {
2276                                 string key = metadata [i, 0];
2277                                 string val = metadata [i, 1];
2278                                 Assert.IsTrue (item.HasMetadata (key), String.Format ("{0}#2: Expected metadata '{1}' not found", prefix, key));
2279                                 Assert.AreEqual (val, item.GetMetadata (key), String.Format ("{0}#3: Value for metadata {1}", prefix, key));
2280                                 Assert.AreEqual (val, item.GetEvaluatedMetadata (key), String.Format ("{0}#4: Value for evaluated metadata {1}", prefix, key));
2281                         }
2282                         Assert.AreEqual (finalItemSpec, item.FinalItemSpec, prefix + "#5");
2283                 }
2284
2285                 void CheckProjectBuild (Project project, string [] targetNames, bool result, string [] outputNames, string prefix)
2286                 {
2287                         IDictionary targetOutputs = new Hashtable ();
2288
2289                         Assert.AreEqual (result, project.Build (targetNames, targetOutputs), prefix + "A1");
2290                         Assert.AreEqual (outputNames.Length, targetOutputs.Keys.Count, prefix + "A2");
2291
2292                         foreach (string outputName in outputNames) {
2293                                 Assert.IsTrue (targetOutputs.Contains (outputName), prefix + " A3: target " + outputName);
2294
2295                                 object o = targetOutputs [outputName];
2296                                 Assert.IsTrue (typeof (ITaskItem []).IsAssignableFrom (o.GetType ()), prefix + " A4: target " + outputName);
2297
2298                                 ITaskItem [] items = (ITaskItem [])o;
2299                                 Assert.AreEqual (0, items.Length, prefix + "A5: target " + outputName);
2300                         }
2301                 }
2302
2303                 string CreateProjectString (bool run_separate, string [] targets, bool [] results, string prefix)
2304                 {
2305                         StringBuilder sb = new StringBuilder ();
2306                         sb.Append (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">");
2307                         sb.AppendFormat ("<Target Name = \"{0}\"><Message Text = \"#Target {1}:{0} called\" />", "main", prefix);
2308
2309                         sb.AppendFormat ("<CallTarget Targets=\"");
2310                         for (int i = 0; i < targets.Length; i++)
2311                                 sb.AppendFormat ("{0};", targets [i]);
2312                         sb.AppendFormat ("\" ");
2313
2314                         if (run_separate)
2315                                 sb.AppendFormat (" RunEachTargetSeparately=\"true\" ");
2316                         sb.AppendFormat ("/></Target>\n");
2317
2318                         for (int i = 0; i < targets.Length; i++) {
2319                                 sb.AppendFormat ("<Target Name = \"{0}\"><Message Text = \"#Target {1}:{0} called\" />", targets [i], prefix);
2320                                 if (!results [i])
2321                                         sb.AppendFormat ("<Error Text = \"#Error message for target {0}:{1}\"/>", prefix, targets [i]);
2322                                 sb.Append ("</Target>\n");
2323                         }
2324
2325                         sb.Append ("</Project>");
2326
2327                         return sb.ToString ();
2328                 }
2329
2330                 void CreateProjectFile (string fname, bool run_separate, string [] targets, bool [] results, string prefix)
2331                 {
2332                         using (StreamWriter sw = new StreamWriter (fname))
2333                                 sw.Write (CreateProjectString (run_separate, targets, results, prefix));
2334                 }
2335
2336                 Project CreateAndLoadProject (string fname, bool run_separate, string [] targets, bool [] results, string prefix)
2337                 {
2338                         Engine engine = new Engine (Consts.BinPath);
2339                         Project project = engine.CreateNewProject ();
2340
2341                         string projectXml = CreateProjectString (run_separate, targets, results, prefix);
2342                         if (fname == null) {
2343                                 project.LoadXml (projectXml);
2344                         } else {
2345                                 using (StreamWriter sw = new StreamWriter (fname))
2346                                         sw.Write (projectXml);
2347                                 project.Load (fname);
2348                                 File.Delete (fname);
2349                         }
2350
2351                         return project;
2352                 }
2353         }
2354 }