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                         logger.DumpMessages ();
1491                         BuildItemGroup include = project.GetEvaluatedItemsByName ("FinalList");
1492                         Assert.AreEqual (3, include.Count, "A2");
1493                 }
1494
1495                 [Test]
1496                 public void TestBatchedMetadataRefInOutput () {
1497                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1498                         <UsingTask TaskName=""BatchingTestTask"" AssemblyFile=""Test/resources/TestTasks.dll"" />
1499                         <ItemGroup>
1500                                 <Coll1 Include=""A1""><Name>Abc</Name></Coll1>
1501                                 <Coll1 Include=""A2""><Name>Def</Name></Coll1>
1502                                 <Coll1 Include=""A3""><Name>Abc</Name></Coll1>
1503                                 <Coll1 Include=""B1""><Name>Bar</Name></Coll1>
1504                         </ItemGroup>
1505                                 <Target Name=""ShowMessage"">
1506                                         <BatchingTestTask Sources=""@(Coll1)"" >
1507                                                 <Output TaskParameter=""Output"" ItemName=""AbcItems"" Condition=""'%(Coll1.Name)' == 'Abc'""/>
1508                                                 <Output TaskParameter=""Output"" ItemName=""NonAbcItems"" Condition=""'%(Coll1.Name)' != 'Abc'""/>
1509                                         </BatchingTestTask>
1510                                         <Message Text='AbcItems: @(AbcItems)' />
1511                                         <Message Text='NonAbcItems: @(NonAbcItems)' />
1512                                 </Target>
1513                  </Project>";
1514
1515                         Engine engine = new Engine (Consts.BinPath);
1516                         Project project = engine.CreateNewProject ();
1517                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1518                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1519                         engine.RegisterLogger (logger);
1520
1521                         project.LoadXml (projectString);
1522                         bool result = project.Build ("ShowMessage");
1523                         if (!result) {
1524                                 logger.DumpMessages ();
1525                                 Assert.Fail ("A1: Build failed");
1526                         }
1527
1528                         logger.CheckLoggedMessageHead ("AbcItems: A1;A3", "A2");
1529                         logger.CheckLoggedMessageHead ("NonAbcItems: A2;B1", "A2");
1530
1531                         if (logger.NormalMessageCount != 0) {
1532                                 logger.DumpMessages ();
1533                                 Assert.Fail ("Unexpected extra messages found");
1534                         }
1535                 }
1536
1537                 [Test]
1538                 public void TestInitialTargets ()
1539                 {
1540                         Engine engine = new Engine (Consts.BinPath);
1541                         Project project = engine.CreateNewProject ();
1542
1543                         project.LoadXml (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" InitialTargets=""pre  "">
1544                                 <Target Name=""boo"">
1545                                         <Message Text=""Executing boo target""/>
1546                                 </Target>
1547                                 <Target Name=""pre"">
1548                                         <Message Text=""Executing pre target""/>
1549                                 </Target>
1550                         </Project>");
1551
1552                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1553                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1554                         engine.RegisterLogger (logger);
1555
1556                         try {
1557                                 Assert.IsTrue (project.Build (), "Build failed");
1558
1559                                 logger.CheckLoggedMessageHead ("Executing pre target", "A1");
1560                                 logger.CheckLoggedMessageHead ("Executing boo target", "A2");
1561
1562                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1563                         } catch {
1564                                 logger.DumpMessages ();
1565                                 throw;
1566                         }
1567                 }
1568
1569                 [Test]
1570                 public void TestInitialTargetsWithImports () {
1571                         Engine engine = new Engine (Consts.BinPath);
1572                         Project project = engine.CreateNewProject ();
1573
1574                         string second = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" InitialTargets=""One  "">
1575                                 <Target Name=""One"">
1576                                         <Message Text='Executing Second::One target'/>
1577                                 </Target>
1578                                 <Import Project='third.proj'/>
1579                         </Project>
1580 ";
1581                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
1582                                 sw.Write (second);
1583                         }
1584
1585                         string third = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" InitialTargets=""Two"">
1586                                 <Target Name=""Two"">
1587                                         <Message Text='Executing Third::Two target'/>
1588                                 </Target>
1589                         </Project>
1590 ";
1591                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "third.proj")))) {
1592                                 sw.Write (third);
1593                         }
1594
1595                         project.LoadXml (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" InitialTargets=""pre"">
1596                                 <Target Name=""boo"">
1597                                         <Message Text=""Executing boo target""/>
1598                                 </Target>
1599                                 <Target Name=""pre"">
1600                                         <Message Text=""Executing pre target""/>
1601                                 </Target>
1602                                 <Import Project='Test/resources/second.proj'/>
1603                         </Project>");
1604
1605                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1606                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1607                         engine.RegisterLogger (logger);
1608
1609                         try {
1610                                 Assert.IsTrue (project.Build (), "Build failed");
1611
1612                                 logger.CheckLoggedMessageHead ("Executing pre target", "A1");
1613                                 logger.CheckLoggedMessageHead ("Executing Second::One target", "A2");
1614                                 logger.CheckLoggedMessageHead ("Executing Third::Two target", "A3");
1615                                 logger.CheckLoggedMessageHead ("Executing boo target", "A4");
1616                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1617
1618                                 Assert.AreEqual ("pre; One; Two", project.InitialTargets, "List of initial targets");
1619                         } catch {
1620                                 logger.DumpMessages ();
1621                                 throw;
1622                         }
1623                 }
1624
1625                 [Test]
1626                 public void TestDefaultTargets () {
1627                         Engine engine = new Engine (Consts.BinPath);
1628                         Project project = engine.CreateNewProject ();
1629
1630                         project.LoadXml (@"<Project DefaultTargets='pre' xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" >
1631                                 <Target Name=""boo"">
1632                                         <Message Text=""Executing boo target""/>
1633                                 </Target>
1634                                 <Target Name=""pre"">
1635                                         <Message Text=""Executing pre target""/>
1636                                 </Target>
1637                         </Project>");
1638
1639                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1640                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1641                         engine.RegisterLogger (logger);
1642
1643                         try {
1644                                 Assert.IsTrue (project.Build (), "Build failed");
1645
1646                                 logger.CheckLoggedMessageHead ("Executing pre target", "A1");
1647                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1648
1649                                 Assert.AreEqual ("pre", project.DefaultTargets, "Default targets");
1650                         } catch {
1651                                 logger.DumpMessages ();
1652                                 throw;
1653                         }
1654                 }
1655
1656
1657                 [Test]
1658                 public void TestDefaultTargetsWithImports () {
1659                         Engine engine = new Engine (Consts.BinPath);
1660                         Project project = engine.CreateNewProject ();
1661
1662                         string second = @"<Project DefaultTargets='One' xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1663                                 <Target Name=""One"">
1664                                         <Message Text='Executing Second::One target'/>
1665                                 </Target>
1666                         </Project>";
1667                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
1668                                 sw.Write (second);
1669                         }
1670
1671                         project.LoadXml (@"<Project DefaultTargets='pre' xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" >
1672                                 <Target Name=""boo"">
1673                                         <Message Text=""Executing boo target""/>
1674                                 </Target>
1675                                 <Target Name=""pre"">
1676                                         <Message Text=""Executing pre target""/>
1677                                 </Target>
1678                                 <Import Project='Test/resources/second.proj'/>
1679                         </Project>");
1680
1681                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1682                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1683                         engine.RegisterLogger (logger);
1684
1685                         try {
1686                                 Assert.IsTrue (project.Build (), "Build failed");
1687
1688                                 logger.CheckLoggedMessageHead ("Executing pre target", "A1");
1689                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1690
1691                                 Assert.AreEqual ("pre", project.DefaultTargets, "Default targets");
1692                         } catch {
1693                                 logger.DumpMessages ();
1694                                 throw;
1695                         }
1696                 }
1697
1698                 [Test]
1699                 public void TestNoDefaultTargetsWithImports () {
1700                         Engine engine = new Engine (Consts.BinPath);
1701                         Project project = engine.CreateNewProject ();
1702
1703
1704                         string second = @"<Project DefaultTargets='; One  ; Two' xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1705                                 <Target Name=""One"">
1706                                         <Message Text='Executing Second::One target'/>
1707                                 </Target>
1708                                 <Target Name=""Two"">
1709                                         <Message Text='Executing Second::Two target'/>
1710                                 </Target>
1711
1712                         </Project>";
1713                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
1714                                 sw.Write (second);
1715                         }
1716
1717                         project.LoadXml (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" >
1718                                 <Target Name=""boo"">
1719                                         <Message Text=""Executing boo target""/>
1720                                 </Target>
1721                                 <Target Name=""pre"">
1722                                         <Message Text=""Executing pre target""/>
1723                                 </Target>
1724                                 <Import Project='Test/resources/second.proj'/>
1725                         </Project>");
1726
1727                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1728                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1729                         engine.RegisterLogger (logger);
1730
1731                         try {
1732                                 Assert.IsTrue (project.Build (), "Build failed");
1733
1734                                 logger.CheckLoggedMessageHead ("Executing Second::One target", "A1");
1735                                 logger.CheckLoggedMessageHead ("Executing Second::Two target", "A2");
1736                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1737
1738                                 Assert.AreEqual ("One; Two", project.DefaultTargets, "Default targets");
1739                         } catch {
1740                                 logger.DumpMessages ();
1741                                 throw;
1742                         }
1743                 }
1744
1745                 [Test]
1746                 public void TestNoDefaultTargets () {
1747                         Engine engine = new Engine (Consts.BinPath);
1748                         Project project = engine.CreateNewProject ();
1749
1750                         project.LoadXml (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" >
1751                                 <Target Name=""boo"">
1752                                         <Message Text=""Executing boo target""/>
1753                                 </Target>
1754                                 <Target Name=""pre"">
1755                                         <Message Text=""Executing pre target""/>
1756                                 </Target>
1757                         </Project>");
1758
1759                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1760                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1761                         engine.RegisterLogger (logger);
1762
1763                         try {
1764                                 Assert.IsTrue (project.Build (), "Build failed");
1765
1766                                 logger.CheckLoggedMessageHead ("Executing boo target", "A1");
1767                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1768
1769                                 Assert.AreEqual ("", project.DefaultTargets, "Default targets");
1770                         } catch {
1771                                 logger.DumpMessages ();
1772                                 throw;
1773                         }
1774                 }
1775
1776                 [Test]
1777                 public void TestPropertiesFromImportedProjects ()
1778                 {
1779                         Engine engine = new Engine (Consts.BinPath);
1780                         Project project = engine.CreateNewProject ();
1781
1782                         string second = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
1783         <PropertyGroup>
1784           <Prop1>InitialVal</Prop1>
1785         </PropertyGroup>
1786         <ItemGroup>
1787                 <Second Include=""$(ThirdProp):Third""/>
1788         </ItemGroup>
1789
1790         <Target Name=""Main"">
1791                 <Message Text=""Prop1: $(Prop1) FooItem: @(FooItem)""/>
1792                 <Message Text=""Second: @(Second) ThirdProp: $(ThirdProp)""/>
1793         </Target>
1794         <Import Project=""third.proj""/>
1795 </Project>";
1796                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "second.proj")))) {
1797                                 sw.Write (second);
1798                         }
1799
1800                         string third = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
1801         <PropertyGroup>
1802           <ThirdProp>Third Value</ThirdProp>
1803         </PropertyGroup>
1804 </Project>";
1805                         using (StreamWriter sw = new StreamWriter (Path.Combine ("Test", Path.Combine ("resources", "third.proj")))) {
1806                                 sw.Write (third);
1807                         }
1808
1809                         project.LoadXml (@"<Project InitialTargets=""Main"" xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
1810         <ItemGroup>
1811                 <FooItem Include=""$(Prop1):Something""/>
1812         </ItemGroup>
1813
1814         <Import Project=""Test/resources/second.proj""/>
1815 </Project>");
1816
1817                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
1818                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
1819                         engine.RegisterLogger (logger);
1820
1821                         try {
1822                                 Assert.IsTrue (project.Build (), "Build failed");
1823
1824                                 logger.CheckLoggedMessageHead ("Prop1: InitialVal FooItem: InitialVal:Something", "A1");
1825                                 logger.CheckLoggedMessageHead ("Second: Third Value:Third ThirdProp: Third Value", "A2");
1826
1827                                 Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
1828                         } catch {
1829                                 logger.DumpMessages ();
1830                                 throw;
1831                         }
1832                 }
1833
1834
1835                 [Test]
1836                 public void TestRequiredTask_String1 ()
1837                 {
1838                         CheckProjectForRequiredTests ("RequiredTestTask_String", "@(NonExistant)",
1839                                 false, "Should've failed: No value specified for required field - 'Property' of RequiredTestTask_String", null);
1840                 }
1841
1842                 [Test]
1843                 public void TestRequiredTask_String2 ()
1844                 {
1845                         CheckProjectForRequiredTests ("RequiredTestTask_String", "$(NonExistant)",
1846                                 false, "Should've failed: No value specified for required field - 'Property' of RequiredTestTask_String", null);
1847                 }
1848
1849                 [Test]
1850                 public void TestRequiredTask_Strings1 () {
1851                         CheckProjectForRequiredTests ("RequiredTestTask_Strings", "@(NonExistant)",
1852                                 true, "Build failed", "0");
1853                 }
1854
1855                 [Test]
1856                 public void TestRequiredTask_Strings2 () {
1857                         CheckProjectForRequiredTests ("RequiredTestTask_Strings", "$(NonExistant)",
1858                                 true, "Build failed", "0");
1859                 }
1860
1861                 [Test]
1862                 public void TestRequiredTask_Strings3 () {
1863                         CheckProjectForRequiredTests ("RequiredTestTask_Strings", "%(NonExistant.Md)",
1864                                 true, "Build failed", "0");
1865                 }
1866
1867                 [Test]
1868                 public void TestRequiredTask_Strings4 () {
1869                         CheckProjectForRequiredTests ("RequiredTestTask_Strings", "  %(NonExistant.Md)",
1870                                 true, "Build failed", "0");
1871                 }
1872
1873                 [Test]
1874                 public void TestRequiredTask_Ints1 () {
1875                         CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "@(NonExistant)",
1876                                 true, "Build failed", "count: 0");
1877                 }
1878
1879                 [Test]
1880                 public void TestRequiredTask_Ints2 () {
1881                         CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "$(NonExistant)",
1882                                 true, "Build failed", "count: 0");
1883                 }
1884
1885                 [Test]
1886                 public void TestRequiredTask_OtherObjectsArray () {
1887                         CheckProjectForRequiredTests ("RequiredTestTask_OtherObjectArray", "@(NonExistant)",
1888                                 false, "Should've failed: ObjectArray type not supported as a property type", null);
1889                 }
1890
1891                 [Test]
1892                 public void TestRequiredTask_OtherObject () {
1893                         CheckProjectForRequiredTests ("RequiredTestTask_OtherObjectArray", "@(NonExistant)",
1894                                 false, "Should've failed: ObjectArray type not supported as a property type", null);
1895                 }
1896
1897                 [Test]
1898                 public void TestRequiredTask_MyTaskItems1 () {
1899                         CheckProjectForRequiredTests ("RequiredTestTask_MyTaskItemArray", "@(NonExistant)",
1900                                 false, "Should've failed: ObjectArray type not supported as a property type", null);
1901                 }
1902
1903                 [Test]
1904                 public void TestRequiredTask_TaskItem1 ()
1905                 {
1906                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_TaskItem", "@(NonExistant)",
1907                                 false, "Should've failed: No value specified for required field - 'Property' of RequiredTestTask_TaskItem", null);
1908                 }
1909
1910                 [Test]
1911                 public void TestRequiredTask_TaskItem2 ()
1912                 {
1913                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_TaskItem", "$(NonExistant)",
1914                                 false, "Should've failed: No value specified for required field - 'Property' of RequiredTestTask_TaskItem", null);
1915                 }
1916
1917                 [Test]
1918                 public void TestRequiredTask_TaskItemArray1 ()
1919                 {
1920                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_TaskItems", "@(NonExistant)",
1921                                 true, "Build failed", "count: 0");
1922
1923                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
1924                         Assert.AreEqual (1, group.Count, "A2");
1925                         Assert.AreEqual ("count: 0", group [0].FinalItemSpec, "A3");
1926                 }
1927
1928                 [Test]
1929                 public void TestRequiredTask_TaskItemArray2 ()
1930                 {
1931                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_TaskItems", "$(NonExistant)",
1932                                 true, "Build failed", "count: 0");
1933
1934                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
1935                         Assert.AreEqual (1, group.Count, "A2");
1936                         Assert.AreEqual ("count: 0", group [0].FinalItemSpec, "A3");
1937                 }
1938
1939                 [Test]
1940                 public void TestRequiredTask_TaskItemArray3 ()
1941                 {
1942                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "$(NonExistant)",
1943                                 true, "Build failed", "count: 0");
1944
1945                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
1946                         Assert.AreEqual (1, group.Count, "A2");
1947                         Assert.AreEqual ("count: 0", group [0].FinalItemSpec, "A3");
1948                 }
1949
1950                 [Test]
1951                 public void TestRequiredTask_TaskItemArray4 () {
1952                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "%(NonExistant.Md)",
1953                                 true, "Build failed", "count: 0");
1954
1955                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
1956                         Assert.AreEqual (1, group.Count, "A2");
1957                         Assert.AreEqual ("count: 0", group[0].FinalItemSpec, "A3");
1958                 }
1959
1960                 [Test]
1961                 public void TestRequiredTask_TaskItemArray5 () {
1962                         // with extra space in prop value
1963                         Project p = CheckProjectForRequiredTests ("RequiredTestTask_IntArray", "  %(NonExistant.Md)",
1964                                 true, "Build failed", "count: 0");
1965
1966                         BuildItemGroup group = p.GetEvaluatedItemsByName ("OutItem");
1967                         Assert.AreEqual (1, group.Count, "A2");
1968                         Assert.AreEqual ("count: 0", group[0].FinalItemSpec, "A3");
1969                 }
1970
1971
1972                 [Test]
1973                 public void TestCaseSensitivityOfProjectElements ()
1974                 {
1975                         string projectXml = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"" " + Consts.ToolsVersionString + @">
1976         <ItemGroup>
1977                 <Abc Include=""foo"">
1978                         <MetaDaTA1>md1</MetaDaTA1>
1979                         <METadata2>md2</METadata2>
1980                 </Abc>
1981                 <Abc Include=""FOO"">
1982                         <MetaDaTA1>MD1 caps</MetaDaTA1>
1983                         <METadata2>MD2 caps</METadata2>
1984                 </Abc>
1985                 <Abc Include=""hmm"">
1986                         <MetaDaTA1>Md1 CAPS</MetaDaTA1>
1987                         <METadata2>MD2 CAPS</METadata2>
1988                 </Abc>
1989                 <Abc Include=""bar"">
1990                         <MeTAdata1>md3</MeTAdata1>
1991                         <Metadata2>md4</Metadata2>
1992                 </Abc>
1993         </ItemGroup>
1994         <PropertyGroup><ProP1>ValueProp</ProP1></PropertyGroup>
1995         <Target Name=""Main"">
1996                 <MesSAGE Text=""Full item: @(ABC)""/>
1997                 <MEssaGE Text=""metadata1 :%(AbC.MetaDATA1) metadata2: %(ABC.MetaDaTa2)""/>
1998                 <MEssaGE Text=""metadata2 : %(AbC.MetaDAta2)""/>
1999                 <MEssaGE Text=""Abc identity: %(ABC.IDENTitY)""/>
2000                 <MEssaGE Text=""prop1 : $(pROp1)""/>
2001         </Target>
2002 </Project>
2003 ";
2004                         Engine engine = new Engine (Consts.BinPath);
2005                         Project project = engine.CreateNewProject ();
2006                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
2007                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
2008                         engine.RegisterLogger (logger);
2009
2010                         project.LoadXml (projectXml);
2011                         bool result = project.Build ("Main");
2012                         if (!result) {
2013                                 logger.DumpMessages ();
2014                                 Assert.Fail ("A1: Build failed");
2015                         }
2016                         logger.DumpMessages ();
2017
2018                         logger.CheckLoggedMessageHead ("Full item: foo;FOO;hmm;bar", "#A2");
2019                         logger.CheckLoggedMessageHead ("metadata1 :md1 metadata2: md2", "#A3");
2020                         logger.CheckLoggedMessageHead ("metadata1 :MD1 caps metadata2: MD2 caps", "#A4");
2021                         logger.CheckLoggedMessageHead ("metadata1 :md3 metadata2: md4", "#A5");
2022                         logger.CheckLoggedMessageHead ("metadata2 : md2", "#A6");
2023                         logger.CheckLoggedMessageHead ("metadata2 : MD2 caps", "#A7");
2024                         logger.CheckLoggedMessageHead ("metadata2 : md4", "#A8");
2025                         logger.CheckLoggedMessageHead ("Abc identity: foo", "#A9");
2026                         logger.CheckLoggedMessageHead ("Abc identity: hmm", "#A10");
2027                         logger.CheckLoggedMessageHead ("Abc identity: bar", "#A11");
2028                         logger.CheckLoggedMessageHead ("prop1 : ValueProp", "#A12");
2029
2030                         Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected extra messages found");
2031
2032                 }
2033
2034                 // full solution test
2035                 //[Test]
2036                 public void TestBuildSolutionProject ()
2037                 {
2038                         string basepath = Path.Combine ("Test", Path.Combine ("resources", "Project01"));
2039                         string [] project_dirs = new string [] {
2040                                 Path.Combine (basepath, "Lib4"),
2041                                 Path.Combine (basepath, "Lib3"),
2042                                 Path.Combine (basepath, "Lib2"),
2043                                 Path.Combine (basepath, "Lib1"),
2044                                 Path.Combine (basepath, "Project01")
2045                         };
2046                         string debug_extn = Consts.RunningOnMono () ? ".dll.mdb" : ".pdb";
2047
2048                         // List of expected output files
2049                         // Lib3
2050                         string [] [] project_files = new string [5][] {
2051                                 new string [] { "Lib4.dll", "Lib4" + debug_extn },
2052                                 new string [] { "Lib3.dll" , "Lib3" + debug_extn },
2053                                 // Lib2
2054                                 new string [] {
2055                                         "Lib2.dll", "Lib2" + debug_extn,
2056                                         "lib2_folder/Lib2.deploy.txt",
2057                                         Path.Combine ("fr-CA", "Lib2.resources.dll"),
2058                                         Path.Combine ("fr-FR", "Lib2.resources.dll"),
2059                                         "Lib4.dll", "Lib4" + debug_extn
2060                                 },
2061
2062                                 // lib1
2063                                 new string [] {
2064                                         // lib1 files
2065                                         "Lib1.dll", "Lib2" + debug_extn,
2066                                         "Lib1.deploy.txt",
2067                                         Path.Combine ("fr-CA", "Lib1.resources.dll"),
2068                                         Path.Combine ("fr-FR", "Lib1.resources.dll"),
2069                                         Path.Combine ("en-US", "Lib1.resources.dll"),
2070                                         // lib2 files
2071                                         "Lib2.dll", "Lib2" + debug_extn,
2072                                         "lib2_folder/Lib2.deploy.txt",
2073                                         Path.Combine ("fr-CA", "Lib2.resources.dll"),
2074                                         Path.Combine ("fr-FR", "Lib2.resources.dll"),
2075                                         // lib3 files
2076                                         "Lib3.dll", "Lib3" + debug_extn,
2077                                         "Lib4.dll", "Lib4" + debug_extn
2078                                         },
2079
2080                                 new string [] {
2081                                         "Project01.exe",
2082                                         "Project01" + (Consts.RunningOnMono () ? ".exe.mdb" : ".pdb"),
2083                                         // lib1 files
2084                                         "Lib1.dll", "Lib1" + debug_extn,
2085                                         "Lib1.deploy.txt",
2086                                         Path.Combine ("fr-CA", "Lib1.resources.dll"),
2087                                         Path.Combine ("fr-FR", "Lib1.resources.dll"),
2088                                         Path.Combine ("en-US", "Lib1.resources.dll"),
2089                                         // lib2 files
2090                                         "Lib2.dll", "Lib2" + debug_extn,
2091                                         "lib2_folder/Lib2.deploy.txt",
2092                                         Path.Combine ("fr-CA", "Lib2.resources.dll"),
2093                                         Path.Combine ("fr-FR", "Lib2.resources.dll"),
2094                                         "Lib4.dll", "Lib4" + debug_extn,
2095                                         }
2096                         };
2097
2098                         // Cleanup
2099                         for (int i = 0; i < project_dirs.Length; i ++) {
2100                                 string bin_path = Path.Combine (project_dirs [i], Path.Combine ("bin", "Debug"));
2101                                 string obj_path = Path.Combine (project_dirs [i], Path.Combine ("obj", "Debug"));
2102
2103                                 DeleteAllInDir (bin_path);
2104
2105                                 DeleteAllInDir (obj_path);
2106                         }
2107
2108                         Engine engine = new Engine (Consts.BinPath);
2109                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
2110                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
2111                         engine.RegisterLogger (logger);
2112
2113                         engine.GlobalProperties = new BuildPropertyGroup ();
2114                         engine.GlobalProperties.SetProperty ("TreatWarningsAsErrors", "false");
2115
2116                         Project project = engine.CreateNewProject ();
2117                         project.Load (Path.Combine (basepath, "Project01.sln.proj"));
2118
2119                         bool result = project.Build ();
2120                         if (!result) {
2121                                 logger.DumpMessages ();
2122                                 Assert.Fail ("Build failed");
2123                         }
2124
2125                         // We check only the output dir, not the 'obj'
2126                         string debug = Path.Combine ("bin", "Debug");
2127                         for (int i = 0; i < project_dirs.Length; i++) {
2128                                 CheckFilesExistInDir (Path.Combine (project_dirs [i], debug),
2129                                         project_files [i]);
2130                         }
2131                 }
2132
2133                 void DeleteAllInDir (string path)
2134                 {
2135                         if (!Directory.Exists (path))
2136                                 return;
2137
2138                         foreach (string file in Directory.GetFiles (path))
2139                                 File.Delete (file);
2140                         Directory.Delete (path, true);
2141                 }
2142
2143                 void CheckFilesExistInDir (string dir, params string [] files)
2144                 {
2145                         foreach (string file in files) {
2146                                 string path = Path.Combine (dir, file);
2147                                 Assert.IsTrue (File.Exists (path),
2148                                         String.Format ("Expected to find file {0}", path));
2149                         }
2150                 }
2151
2152                 Project CheckProjectForRequiredTests (string taskname, string property_arg, bool expected_result, string error_msg,
2153                         string expected_output_msg)
2154                 {
2155                         string projectString = String.Format (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
2156                                 <UsingTask TaskName=""{0}"" AssemblyFile=""Test/resources/TestTasks.dll"" />
2157                                 <Target Name=""foo"">
2158                                         <{0} Property=""{1}"">
2159                                                 <Output TaskParameter=""Output"" ItemName=""OutItem""/>
2160                                         </{0}>
2161                                         <Message Text='@(OutItem)'/>
2162                                 </Target>
2163                         </Project>", taskname, property_arg);
2164
2165                         Engine engine = new Engine (Consts.BinPath);
2166                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
2167                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
2168                         engine.RegisterLogger (logger);
2169                         Project project = engine.CreateNewProject ();
2170                         project.LoadXml (projectString);
2171                         try {
2172                                 Assert.AreEqual (expected_result, project.Build (), error_msg);
2173                                 if (expected_result) {
2174                                         logger.CheckLoggedMessageHead (expected_output_msg, "A");
2175                                         Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected messages found");
2176                                 }
2177                         } finally {
2178                                 logger.DumpMessages ();
2179                         }
2180                         return project;
2181                 }
2182
2183                 static void CheckBuildItem (BuildItem item, string name, string [,] metadata, string finalItemSpec, string prefix)
2184                 {
2185                         Assert.AreEqual (name, item.Name, prefix + "#1");
2186                         for (int i = 0; i < metadata.GetLength (0); i++) {
2187                                 string key = metadata [i, 0];
2188                                 string val = metadata [i, 1];
2189                                 Assert.IsTrue (item.HasMetadata (key), String.Format ("{0}#2: Expected metadata '{1}' not found", prefix, key));
2190                                 Assert.AreEqual (val, item.GetMetadata (key), String.Format ("{0}#3: Value for metadata {1}", prefix, key));
2191                                 Assert.AreEqual (val, item.GetEvaluatedMetadata (key), String.Format ("{0}#4: Value for evaluated metadata {1}", prefix, key));
2192                         }
2193                         Assert.AreEqual (finalItemSpec, item.FinalItemSpec, prefix + "#5");
2194                 }
2195
2196                 void CheckProjectBuild (Project project, string [] targetNames, bool result, string [] outputNames, string prefix)
2197                 {
2198                         IDictionary targetOutputs = new Hashtable ();
2199
2200                         Assert.AreEqual (result, project.Build (targetNames, targetOutputs), prefix + "A1");
2201                         Assert.AreEqual (outputNames.Length, targetOutputs.Keys.Count, prefix + "A2");
2202
2203                         foreach (string outputName in outputNames) {
2204                                 Assert.IsTrue (targetOutputs.Contains (outputName), prefix + " A3: target " + outputName);
2205
2206                                 object o = targetOutputs [outputName];
2207                                 Assert.IsTrue (typeof (ITaskItem []).IsAssignableFrom (o.GetType ()), prefix + " A4: target " + outputName);
2208
2209                                 ITaskItem [] items = (ITaskItem [])o;
2210                                 Assert.AreEqual (0, items.Length, prefix + "A5: target " + outputName);
2211                         }
2212                 }
2213
2214                 string CreateProjectString (bool run_separate, string [] targets, bool [] results, string prefix)
2215                 {
2216                         StringBuilder sb = new StringBuilder ();
2217                         sb.Append (@"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">");
2218                         sb.AppendFormat ("<Target Name = \"{0}\"><Message Text = \"#Target {1}:{0} called\" />", "main", prefix);
2219
2220                         sb.AppendFormat ("<CallTarget Targets=\"");
2221                         for (int i = 0; i < targets.Length; i++)
2222                                 sb.AppendFormat ("{0};", targets [i]);
2223                         sb.AppendFormat ("\" ");
2224
2225                         if (run_separate)
2226                                 sb.AppendFormat (" RunEachTargetSeparately=\"true\" ");
2227                         sb.AppendFormat ("/></Target>\n");
2228
2229                         for (int i = 0; i < targets.Length; i++) {
2230                                 sb.AppendFormat ("<Target Name = \"{0}\"><Message Text = \"#Target {1}:{0} called\" />", targets [i], prefix);
2231                                 if (!results [i])
2232                                         sb.AppendFormat ("<Error Text = \"#Error message for target {0}:{1}\"/>", prefix, targets [i]);
2233                                 sb.Append ("</Target>\n");
2234                         }
2235
2236                         sb.Append ("</Project>");
2237
2238                         return sb.ToString ();
2239                 }
2240
2241                 void CreateProjectFile (string fname, bool run_separate, string [] targets, bool [] results, string prefix)
2242                 {
2243                         using (StreamWriter sw = new StreamWriter (fname))
2244                                 sw.Write (CreateProjectString (run_separate, targets, results, prefix));
2245                 }
2246
2247                 Project CreateAndLoadProject (string fname, bool run_separate, string [] targets, bool [] results, string prefix)
2248                 {
2249                         Engine engine = new Engine (Consts.BinPath);
2250                         Project project = engine.CreateNewProject ();
2251
2252                         string projectXml = CreateProjectString (run_separate, targets, results, prefix);
2253                         if (fname == null) {
2254                                 project.LoadXml (projectXml);
2255                         } else {
2256                                 using (StreamWriter sw = new StreamWriter (fname))
2257                                         sw.Write (projectXml);
2258                                 project.Load (fname);
2259                                 File.Delete (fname);
2260                         }
2261
2262                         return project;
2263                 }
2264         }
2265 }