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

   1 //
   2 // BuildItemTest.cs
   3 //
   4 // Author:
   5 //   Marek Sieradzki (marek.sieradzki@gmail.com)
   6 //
   7 // (C) 2005 Marek Sieradzki
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 using System;
  29 using Microsoft.Build.BuildEngine;
  30 using Microsoft.Build.Framework;
  31 using Microsoft.Build.Utilities;
  32 using NUnit.Framework;
  33
  34 namespace MonoTests.Microsoft.Build.BuildEngine {
  35         [TestFixture]
  36         public class BuildItemTest {
  37
  38                 BuildItem item;
  39
  40                 [Test]
  41                 public void TestCtor1 ()
  42                 {
  43                         string itemName = "itemName";
  44                         string itemInclude = "a;b;c";
  45
  46                         item = new BuildItem (itemName, itemInclude);
  47
  48                         Assert.AreEqual (itemInclude, item.FinalItemSpec, "A1");
  49                         Assert.AreEqual (itemInclude, item.Include, "A2");
  50                         Assert.AreEqual (String.Empty, item.Exclude, "A3");
  51                         Assert.AreEqual (String.Empty, item.Condition, "A4");
  52                         Assert.AreEqual (false, item.IsImported, "A5");
  53                         Assert.AreEqual (itemName, item.Name, "A6");
  54                 }
  55
  56                 [Test]
  57                 public void TestCtor2 ()
  58                 {
  59                         string itemName = "itemName";
  60                         string itemSpec = "a;b;c";
  61                         // result of Utilities.Escape (itemSpec)
  62                         string escapedInclude = "a%3bb%3bc";
  63                         ITaskItem taskItem = new TaskItem (itemSpec);
  64
  65                         item = new BuildItem (itemName, taskItem);
  66
  67                         Assert.AreEqual (itemSpec, item.FinalItemSpec, "A1");
  68                         Assert.AreEqual (escapedInclude, item.Include, "A2");
  69                         Assert.AreEqual (String.Empty, item.Exclude, "A3");
  70                         Assert.AreEqual (String.Empty, item.Condition, "A4");
  71                         Assert.AreEqual (false, item.IsImported, "A5");
  72                         Assert.AreEqual (itemName, item.Name, "A6");
  73                 }
  74
  75                 [Test]
  76                 [ExpectedException (typeof (ArgumentNullException))]
  77                 public void TestCtor3 ()
  78                 {
  79                         new BuildItem (null, (string) null);
  80                 }
  81
  82                 [Test]
  83                 [ExpectedException (typeof (ArgumentNullException))]
  84                 [Category ("NotDotNet")]
  85                 public void TestCtor4 ()
  86                 {
  87                         new BuildItem (null, (ITaskItem) null);
  88                 }
  89
  90                 [Test]
  91                 public void TestCtor5 ()
  92                 {
  93                         new BuildItem (null, "something");
  94                 }
  95
  96                 // Parameter "itemInclude" cannot have zero length.
  97                 [Test]
  98                 [ExpectedException (typeof (ArgumentException))]
  99                 public void TestCtor6 ()
 100                 {
 101                         new BuildItem (null, String.Empty);
 102                 }
 103
 104                 [Test]
 105                 [Category ("NotDotNet")] //IndexOutOfRange throw by MS .NET 2.0
 106                 public void TestCtor7 ()
 107                 {
 108                         new BuildItem (String.Empty, "something");
 109                 }
 110
 111                 [Test]
 112                 public void TestClone1 ()
 113                 {
 114                         item = new BuildItem ("name", "1;2;3");
 115                         item.SetMetadata ("a", "b");
 116
 117                         BuildItem item2 = item.Clone ();
 118
 119                         Assert.AreEqual ("1;2;3", item2.FinalItemSpec, "A1");
 120                         Assert.AreEqual ("1;2;3", item2.Include, "A2");
 121                         Assert.AreEqual (String.Empty, item2.Exclude, "A3");
 122                         Assert.AreEqual (String.Empty, item2.Condition, "A4");
 123                         Assert.AreEqual (false, item2.IsImported, "A5");
 124                         Assert.AreEqual ("name", item2.Name, "A6");
 125                 }
 126
 127                 // Cannot set a condition on an object not represented by an XML element in the project file.
 128                 [Test]
 129                 [ExpectedException (typeof (InvalidOperationException))]
 130                 public void TestCondition1 ()
 131                 {
 132                         item = new BuildItem ("name", "1");
 133                         item.Condition = "true";
 134                 }
 135
 136                 [Test]
 137                 [Ignore ("weird test need to check how project.Xml looks")]
 138                 public void TestCondition2 ()
 139                 {
 140                         Engine engine;
 141                         Project project;
 142                         BuildItemGroup [] groups = new BuildItemGroup [1];
 143
 144                         string documentString = @"
 145                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 146                                         <ItemGroup>
 147                                                 <A Include='a;b' />
 148                                         </ItemGroup>
 149                                 </Project>
 150                         ";
 151
 152                         engine = new Engine (Consts.BinPath);
 153                         project = engine.CreateNewProject ();
 154                         project.LoadXml (documentString);
 155
 156                         project.EvaluatedItems [0].Condition = "true";
 157                         project.ItemGroups.CopyTo (groups, 0);
 158                         Assert.AreEqual (String.Empty, groups [0] [0].Condition, "A1");
 159                         Assert.AreEqual ("true", project.EvaluatedItems [0].Condition, "A2");
 160                 }
 161
 162                 [Test]
 163                 [Ignore ("weird test need to check how project.Xml looks")]
 164                 public void TestCondition3 ()
 165                 {
 166                         Engine engine;
 167                         Project project;
 168                         BuildItemGroup [] groups = new BuildItemGroup [1];
 169
 170                         string documentString = @"
 171                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 172                                         <ItemGroup>
 173                                                 <A Include='a;b' />
 174                                         </ItemGroup>
 175                                 </Project>
 176                         ";
 177
 178                         engine = new Engine (Consts.BinPath);
 179                         project = engine.CreateNewProject ();
 180                         project.LoadXml (documentString);
 181
 182                         project.ItemGroups.CopyTo (groups, 0);
 183                         groups [0] [0].Condition = "true";
 184                         Assert.AreEqual ("true", groups [0] [0].Condition, "A1");
 185                         Assert.AreEqual ("true", project.EvaluatedItems [0].Condition, "A2");
 186                 }
 187
 188                 [Test]
 189                 public void TestCopyCustomMetadataTo1 ()
 190                 {
 191                         BuildItem source, destination;
 192                         string itemName1 = "a";
 193                         string itemName2 = "b";
 194                         string itemInclude = "a;b;c";
 195                         string metadataName = "name";
 196                         string metadataValue = "value";
 197
 198                         source = new BuildItem (itemName1, itemInclude);
 199                         destination = new BuildItem (itemName2, itemInclude);
 200
 201                         source.SetMetadata (metadataName, metadataValue);
 202
 203                         source.CopyCustomMetadataTo (destination);
 204
 205                         Assert.AreEqual (metadataValue, destination.GetMetadata (metadataName), "A1");
 206                         Assert.AreEqual (metadataValue, destination.GetEvaluatedMetadata (metadataName), "A2");
 207                 }
 208
 209                 [Test]
 210                 [ExpectedException (typeof (ArgumentNullException))]
 211                 [Category ("NotDotNet")]
 212                 public void TestCopyCustomMetadataTo2 ()
 213                 {
 214                         BuildItem item = new BuildItem ("name", "include");
 215                         item.SetMetadata ("name", "value");
 216
 217                         item.CopyCustomMetadataTo (null);
 218                 }
 219
 220                 // Assigning the "Exclude" attribute of a virtual item is not allowed.
 221                 [Test]
 222                 [ExpectedException (typeof (InvalidOperationException))]
 223                 public void TestExclude1 ()
 224                 {
 225                         item = new BuildItem ("name", "1");
 226                         item.Exclude = "e";
 227                 }
 228
 229                 [Test]
 230                 public void TestExclude2 ()
 231                 {
 232                         Engine engine;
 233                         Project project;
 234                         BuildItemGroup [] groups = new BuildItemGroup [1];
 235
 236                         string documentString = @"
 237                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 238                                         <ItemGroup>
 239                                                 <A Include='a;b' />
 240                                         </ItemGroup>
 241                                 </Project>
 242                         ";
 243
 244                         engine = new Engine (Consts.BinPath);
 245                         project = engine.CreateNewProject ();
 246                         project.LoadXml (documentString);
 247                         project.ItemGroups.CopyTo (groups, 0);
 248
 249                         Assert.AreEqual (String.Empty, groups [0] [0].Exclude, "A1");
 250
 251                         groups [0] [0].Exclude = "b";
 252
 253                         Assert.AreEqual ("b", groups [0] [0].Exclude, "A2");
 254                         Assert.AreEqual ("a;b", groups [0] [0].Include, "A3");
 255                 }
 256
 257                 [Test]
 258                 public void TestGetMetadata1 ()
 259                 {
 260                         string itemName = "a";
 261                         string itemInclude = "a;b;c";
 262                         string metadataName = "name";
 263                         string metadataValue = "a;b;c";
 264
 265                         item = new BuildItem (itemName, itemInclude);
 266
 267                         Assert.AreEqual (String.Empty, item.GetMetadata (metadataName), "A1");
 268
 269                         item.SetMetadata (metadataName, metadataValue);
 270
 271                         Assert.AreEqual (metadataValue, item.GetMetadata (metadataName), "A2");
 272                         Assert.IsTrue (item.GetMetadata ("FullPath").EndsWith (Utilities.Escape (itemInclude)), "A3");
 273                         //Assert.IsTrue (String.Empty != item.GetMetadata ("RootDir"), "A4");
 274                         Assert.AreEqual (itemInclude, item.GetMetadata ("Filename"), "A5");
 275                         Assert.AreEqual (String.Empty, item.GetMetadata ("Extension"), "A6");
 276                         Assert.AreEqual (String.Empty, item.GetMetadata ("RelativeDir"), "A7");
 277                         Assert.IsTrue (String.Empty != item.GetMetadata ("Directory"), "A8");
 278                         Assert.AreEqual (String.Empty, item.GetMetadata ("RecursiveDir"), "A9");
 279                         Assert.AreEqual (itemInclude, item.GetMetadata ("Identity"), "A10");
 280                         // FIXME: test with CreatedTime
 281                         Assert.AreEqual (String.Empty, item.GetMetadata ("ModifiedTime"), "A11");
 282                         Assert.AreEqual (String.Empty, item.GetMetadata ("ModifiedTime"), "A12");
 283                         Assert.AreEqual (String.Empty, item.GetMetadata ("AccessedTime"), "A13");
 284                 }
 285
 286                 [Test]
 287                 [ExpectedException (typeof (ArgumentNullException))]
 288                 public void TestGetMetadata2 ()
 289                 {
 290                         item = new BuildItem ("name", "spec");
 291                         item.GetMetadata (null);
 292                 }
 293
 294                 [Test]
 295                 public void TestGetMetadata3 ()
 296                 {
 297                         Engine engine;
 298                         Project project;
 299                         BuildItemGroup [] groups = new BuildItemGroup [1];
 300
 301                         string documentString = @"
 302                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 303                                         <ItemGroup>
 304                                                 <A Include='a;b'>
 305                                                         <Meta>Value</Meta>
 306                                                 </A>
 307                                         </ItemGroup>
 308                                 </Project>
 309                         ";
 310
 311                         engine = new Engine (Consts.BinPath);
 312                         project = engine.CreateNewProject ();
 313                         project.LoadXml (documentString);
 314                         project.ItemGroups.CopyTo (groups, 0);
 315
 316                         Assert.AreEqual ("Value", groups [0] [0].GetMetadata ("Meta"), "A1");
 317                         Assert.AreEqual (String.Empty, groups [0] [0].GetMetadata ("Other"), "A2");
 318                 }
 319
 320                 [Test]
 321                 public void TestGetEvaluatedMetadata1 ()
 322                 {
 323                         string itemName = "a";
 324                         string itemInclude = "a";
 325                         string metadataName = "name";
 326                         string metadataValue = "a;b;c";
 327
 328                         item = new BuildItem (itemName, itemInclude);
 329
 330                         Assert.AreEqual (String.Empty, item.GetEvaluatedMetadata (metadataName), "A1");
 331
 332                         item.SetMetadata (metadataName, metadataValue);
 333
 334                         Assert.AreEqual (metadataValue, item.GetEvaluatedMetadata (metadataName), "A2");
 335                         Assert.AreEqual (itemInclude, item.GetEvaluatedMetadata ("Identity"), "A3");
 336                 }
 337
 338                 [Test]
 339                 public void TestGetEvaluatedMetadata2 ()
 340                 {
 341                         Engine engine;
 342                         Project project;
 343                         BuildItemGroup [] groups = new BuildItemGroup [1];
 344
 345                         string documentString = @"
 346                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 347                                         <PropertyGroup>
 348                                                 <A>A</A>
 349                                         </PropertyGroup>
 350                                         <ItemGroup>
 351                                                 <A Include='a;b'>
 352                                                         <Meta>Value</Meta>
 353                                                         <Meta2>$(A)</Meta2>
 354                                                 </A>
 355                                         </ItemGroup>
 356                                 </Project>
 357                         ";
 358
 359                         engine = new Engine (Consts.BinPath);
 360                         project = engine.CreateNewProject ();
 361                         project.LoadXml (documentString);
 362                         project.ItemGroups.CopyTo (groups, 0);
 363
 364                         Assert.AreEqual ("Value", groups [0] [0].GetEvaluatedMetadata ("Meta"), "A1");
 365                         Assert.AreEqual (String.Empty, groups [0] [0].GetEvaluatedMetadata ("Other"), "A2");
 366                         Assert.AreEqual ("A", groups [0] [0].GetEvaluatedMetadata ("Meta2"), "A3");
 367                 }
 368
 369                 [Test]
 370                 public void TestHasMetadata1 ()
 371                 {
 372                         string itemName = "a";
 373                         string itemInclude = "a";
 374                         string metadataName = "name";
 375
 376                         item = new BuildItem (itemName, itemInclude);
 377
 378                         Assert.AreEqual (false, item.HasMetadata (metadataName), "A1");
 379
 380                         item.SetMetadata (metadataName, "value");
 381
 382                         Assert.AreEqual (true, item.HasMetadata (metadataName), "A2");
 383                         Assert.IsTrue (item.HasMetadata ("FullPath"), "A3");
 384                         Assert.IsTrue (item.HasMetadata ("RootDir"), "A4");
 385                         Assert.IsTrue (item.HasMetadata ("Filename"), "A5");
 386                         Assert.IsTrue (item.HasMetadata ("Extension"), "A6");
 387                         Assert.IsTrue (item.HasMetadata ("RelativeDir"), "A7");
 388                         Assert.IsTrue (item.HasMetadata ("Directory"), "A8");
 389                         Assert.IsTrue (item.HasMetadata ("RecursiveDir"), "A9");
 390                         Assert.IsTrue (item.HasMetadata ("Identity"), "A10");
 391                         Assert.IsTrue (item.HasMetadata ("ModifiedTime"), "A11");
 392                         Assert.IsTrue (item.HasMetadata ("CreatedTime"), "A12");
 393                         Assert.IsTrue (item.HasMetadata ("AccessedTime"), "A13");
 394                 }
 395
 396                 [Test]
 397                 public void TestHasMetadata2 ()
 398                 {
 399                         Engine engine;
 400                         Project project;
 401                         BuildItemGroup [] groups = new BuildItemGroup [1];
 402
 403                         string documentString = @"
 404                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 405                                         <ItemGroup>
 406                                                 <A Include='a;b'>
 407                                                         <Meta>Value</Meta>
 408                                                 </A>
 409                                         </ItemGroup>
 410                                 </Project>
 411                         ";
 412
 413                         engine = new Engine (Consts.BinPath);
 414                         project = engine.CreateNewProject ();
 415                         project.LoadXml (documentString);
 416                         project.ItemGroups.CopyTo (groups, 0);
 417
 418                         BuildItem item = groups [0] [0];
 419
 420                         Assert.IsFalse (item.HasMetadata ("Other"), "A1");
 421                         Assert.IsTrue (item.HasMetadata ("Meta"), "A2");
 422                         Assert.IsTrue (item.HasMetadata ("FullPath"), "A3");
 423                         Assert.IsTrue (item.HasMetadata ("RootDir"), "A4");
 424                         Assert.IsTrue (item.HasMetadata ("Filename"), "A5");
 425                         Assert.IsTrue (item.HasMetadata ("Extension"), "A6");
 426                         Assert.IsTrue (item.HasMetadata ("RelativeDir"), "A7");
 427                         Assert.IsTrue (item.HasMetadata ("Directory"), "A8");
 428                         Assert.IsTrue (item.HasMetadata ("RecursiveDir"), "A9");
 429                         Assert.IsTrue (item.HasMetadata ("Identity"), "A10");
 430                         Assert.IsTrue (item.HasMetadata ("ModifiedTime"), "A11");
 431                         Assert.IsTrue (item.HasMetadata ("CreatedTime"), "A12");
 432                         Assert.IsTrue (item.HasMetadata ("AccessedTime"), "A13");
 433                 }
 434
 435                 [Test]
 436                 [ExpectedException (typeof (ArgumentNullException))]
 437                 public void TestHasMetadata3 ()
 438                 {
 439                         item = new BuildItem ("name", "spec");
 440                         item.HasMetadata (null);
 441                 }
 442
 443                 [Test]
 444                 [ExpectedException (typeof (InvalidProjectFileException))]
 445                 public void TestInclude1 ()
 446                 {
 447                         Engine engine;
 448                         Project project;
 449
 450                         string documentString = @"
 451                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 452                                         <ItemGroup>
 453                                                 <A Include='' />
 454                                         </ItemGroup>
 455                                 </Project>
 456                         ";
 457
 458                         engine = new Engine (Consts.BinPath);
 459                         project = engine.CreateNewProject ();
 460                         project.LoadXml (documentString);
 461                 }
 462
 463                 [Test]
 464                 public void TestInclude2 ()
 465                 {
 466                         Engine engine;
 467                         Project project;
 468
 469                         string documentString = @"
 470                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 471                                         <ItemGroup>
 472                                                 <A Include='a' />
 473                                         </ItemGroup>
 474                                 </Project>
 475                         ";
 476
 477                         engine = new Engine (Consts.BinPath);
 478                         project = engine.CreateNewProject ();
 479                         project.LoadXml (documentString);
 480
 481                         Assert.AreEqual ("a", project.EvaluatedItems [0].Include, "A1");
 482                 }
 483
 484                 [Test]
 485                 public void TestInclude3 ()
 486                 {
 487                         BuildItem item = new BuildItem ("name", "a");
 488                         item.Include = "b";
 489                         Assert.AreEqual ("b", item.Include, "A1");
 490                 }
 491
 492                 [Test]
 493                 public void TestName1 ()
 494                 {
 495                         Engine engine;
 496                         Project project;
 497                         BuildItemGroup [] groups = new BuildItemGroup [1];
 498
 499                         string documentString = @"
 500                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 501                                         <ItemGroup>
 502                                                 <A Include='a;b' />
 503                                         </ItemGroup>
 504                                 </Project>
 505                         ";
 506
 507                         engine = new Engine (Consts.BinPath);
 508                         project = engine.CreateNewProject ();
 509                         project.LoadXml (documentString);
 510
 511                         project.EvaluatedItems [0].Name = "C";
 512
 513                         Assert.AreEqual (2, project.EvaluatedItems.Count, "A1");
 514                         Assert.AreEqual ("C", project.EvaluatedItems [0].Name, "A2");
 515                         Assert.AreEqual ("A", project.EvaluatedItems [1].Name, "A3");
 516                         project.ItemGroups.CopyTo (groups, 0);
 517                         Assert.AreEqual (2, groups [0].Count, "A4");
 518                         Assert.AreEqual ("C", groups [0] [0].Name, "A5");
 519                         Assert.AreEqual ("A", groups [0] [1].Name, "A6");
 520                 }
 521
 522                 [Test]
 523                 public void TestName2 ()
 524                 {
 525                         BuildItem item = new BuildItem ("A", "V");
 526                         item.Name = "B";
 527                         Assert.AreEqual ("B", item.Name, "A1");
 528                 }
 529
 530                 [Test]
 531                 public void TestRemoveMetadata1 ()
 532                 {
 533                         string itemName = "a";
 534                         string itemInclude = "a";
 535                         string metadataName = "name";
 536                         string metadataValue = "a;b;c";
 537
 538                         item = new BuildItem (itemName, itemInclude);
 539
 540                         item.SetMetadata (metadataName, metadataValue);
 541
 542                         Assert.AreEqual (true, item.HasMetadata (metadataName), "A1");
 543
 544                         item.RemoveMetadata (metadataName);
 545
 546                         Assert.AreEqual (false, item.HasMetadata (metadataName), "A2");
 547                 }
 548
 549                 [Test]
 550                 [ExpectedException (typeof (ArgumentNullException))]
 551                 public void TestRemoveMetadata2 ()
 552                 {
 553                         item = new BuildItem ("name", "value");
 554                         item.RemoveMetadata (null);
 555                 }
 556
 557                 [Test]
 558                 public void TestRemoveMetadata3 ()
 559                 {
 560                         item = new BuildItem ("name", "value");
 561                         item.RemoveMetadata ("undefined_metadata");
 562                 }
 563
 564                 // "Filename" is a reserved item meta-data, and cannot be modified or deleted.
 565                 [Test]
 566                 [ExpectedException (typeof (ArgumentException))]
 567                 public void TestRemoveMetadata4 ()
 568                 {
 569                         item = new BuildItem ("name", "value");
 570                         item.RemoveMetadata ("Filename");
 571                 }
 572
 573                 [Test]
 574                 public void TestRemoveMetadata5 ()
 575                 {
 576                         Engine engine;
 577                         Project project;
 578                         BuildItemGroup [] groups = new BuildItemGroup [1];
 579
 580                         string documentString = @"
 581                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 582                                         <ItemGroup>
 583                                                 <A Include='a;b'>
 584                                                         <Meta>Value</Meta>
 585                                                         <Meta2>$(A)</Meta2>
 586                                                 </A>
 587                                                 <B Include='a'/>
 588                                         </ItemGroup>
 589                                 </Project>
 590                         ";
 591
 592                         engine = new Engine (Consts.BinPath);
 593                         project = engine.CreateNewProject ();
 594                         project.LoadXml (documentString);
 595                         project.ItemGroups.CopyTo (groups, 0);
 596
 597                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A1");
 598
 599                         groups [0] [0].RemoveMetadata ("Meta");
 600                         Assert.IsFalse (groups [0] [0].HasMetadata ("Meta"), "A2");
 601                         groups [0] [0].RemoveMetadata ("undefined_metadata");
 602
 603                         Assert.AreEqual (2, groups [0].Count, "A3");
 604                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A4");
 605                 }
 606
 607                 [Test]
 608                 public void TestRemoveMetadata6 ()
 609                 {
 610                         Engine engine;
 611                         Project project;
 612                         BuildItemGroup [] groups = new BuildItemGroup [1];
 613
 614                         string documentString = @"
 615                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 616                                         <ItemGroup>
 617                                                 <A Include='a;b;c'>
 618                                                         <Meta>Value</Meta>
 619                                                         <Meta2>$(A)</Meta2>
 620                                                 </A>
 621                                                 <B Include='a'/>
 622                                         </ItemGroup>
 623                                 </Project>
 624                         ";
 625
 626                         engine = new Engine (Consts.BinPath);
 627                         project = engine.CreateNewProject ();
 628                         project.LoadXml (documentString);
 629
 630                         Assert.AreEqual (4, project.EvaluatedItems.Count, "A1");
 631                         project.ItemGroups.CopyTo (groups, 0);
 632                         Assert.AreEqual (2, groups [0].Count, "A2");
 633
 634                         BuildItem b1 = project.EvaluatedItems [0];
 635
 636                         b1.RemoveMetadata ("Meta");
 637
 638                         Assert.AreEqual (4, project.EvaluatedItems.Count, "A3");
 639                         project.ItemGroups.CopyTo (groups, 0);
 640                         Assert.AreEqual (4, groups [0].Count, "A4");
 641                 }
 642
 643                 [Test]
 644                 [ExpectedException (typeof (ArgumentNullException))]
 645                 public void TestSetMetadata1 ()
 646                 {
 647                         item = new BuildItem ("name", "include");
 648                         item.SetMetadata (null, null);
 649                 }
 650
 651                 [Test]
 652                 [ExpectedException (typeof (ArgumentNullException))]
 653                 public void TestSetMetadata2 ()
 654                 {
 655                         item = new BuildItem ("name", "include");
 656                         item.SetMetadata ("name", null);
 657                 }
 658
 659                 [Test]
 660                 public void TestSetMetadata3 ()
 661                 {
 662                         item = new BuildItem ("name", "include");
 663                         item.SetMetadata ("a", "$(A)");
 664                         item.SetMetadata ("b", "$(A)", true);
 665                         item.SetMetadata ("c", "$(A)", false);
 666
 667                         Assert.AreEqual ("$(A)", item.GetEvaluatedMetadata ("a"), "A1");
 668                         Assert.AreEqual ("$(A)", item.GetEvaluatedMetadata ("b"), "A2");
 669                         Assert.AreEqual ("$(A)", item.GetEvaluatedMetadata ("c"), "A3");
 670                         Assert.AreEqual ("$(A)", item.GetMetadata ("a"), "A4");
 671                         Assert.AreEqual (Utilities.Escape ("$(A)"), item.GetMetadata ("b"), "A5");
 672                         Assert.AreEqual ("$(A)", item.GetMetadata ("c"), "A6");
 673                 }
 674
 675                 // "Filename" is a reserved item meta-data, and cannot be modified or deleted.
 676                 [Test]
 677                 [ExpectedException (typeof (ArgumentException))]
 678                 public void TestSetMetadata4 ()
 679                 {
 680                         item = new BuildItem ("name", "include");
 681                         item.SetMetadata ("Filename", "something");
 682                 }
 683
 684                 [Test]
 685                 public void TestSetMetadata5 ()
 686                 {
 687                         Engine engine;
 688                         Project project;
 689                         BuildItemGroup [] groups = new BuildItemGroup [1];
 690
 691                         string documentString = @"
 692                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 693                                         <PropertyGroup>
 694                                                 <A>A</A>
 695                                         </PropertyGroup>
 696                                         <ItemGroup>
 697                                                 <A Include='a;b'/>
 698                                         </ItemGroup>
 699                                 </Project>
 700                         ";
 701
 702                         engine = new Engine (Consts.BinPath);
 703                         project = engine.CreateNewProject ();
 704                         project.LoadXml (documentString);
 705
 706                         project.ItemGroups.CopyTo (groups, 0);
 707
 708                         groups [0] [0].SetMetadata ("Meta", "$(A)");
 709                         Assert.AreEqual (2, project.EvaluatedItems.Count, "A0");
 710
 711                         Assert.AreEqual (1, groups [0].Count, "A1");
 712                         Assert.AreEqual ("$(A)", groups [0] [0].GetMetadata ("Meta"), "A2");
 713                         Assert.AreEqual ("$(A)", project.EvaluatedItems [0].GetMetadata ("Meta"), "A3");
 714                         Assert.AreEqual ("$(A)", project.EvaluatedItems [1].GetMetadata ("Meta"), "A4");
 715                         Assert.AreEqual ("A", project.EvaluatedItems [0].GetEvaluatedMetadata ("Meta"), "A5");
 716                         Assert.AreEqual ("A", project.EvaluatedItems [1].GetEvaluatedMetadata ("Meta"), "A6");
 717                 }
 718
 719                 [Test]
 720                 public void TestSetMetadata5a () {
 721                         Engine engine;
 722                         Project project;
 723                         BuildItemGroup[] groups = new BuildItemGroup[1];
 724
 725                         string documentString = @"
 726                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 727                                         <PropertyGroup>
 728                                                 <A>A</A>
 729                                                 <C>@(D)</C>
 730                                         </PropertyGroup>
 731                                         <ItemGroup>
 732                                                 <D Include='D'/>
 733                                                 <C Include='$(C)'/>
 734                                                 <A Include='a;b'>
 735                                                         <Md>@(C)</Md>
 736                                                 </A>
 737                                                 <B Include='$(A)'/>
 738                                         </ItemGroup>
 739                                         <Target Name='main'>
 740                                                 <Message Text=""a.md: %(A.Md)""/>
 741                                                 <Message Text=""a.md: %(A.Meta)""/>
 742                                         </Target>
 743                                 </Project>
 744                         ";
 745
 746                         engine = new Engine (Consts.BinPath);
 747                         project = engine.CreateNewProject ();
 748                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger = new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
 749                         engine.RegisterLogger (logger);
 750                         project.LoadXml (documentString);
 751
 752                         CheckMetadata (project, "A", "Md", new string [] {"@(C)", "@(C)"}, "G1");
 753                         CheckEvaluatedMetadata (project, "A", "Md", new string[] { "D", "D" }, "G2");
 754
 755                         //@(B)
 756                         Assert.AreEqual ("A", project.GetEvaluatedItemsByName ("B")[0].FinalItemSpec, "B2");
 757
 758                         project.ItemGroups.CopyTo (groups, 0);
 759                         /*Broken right now:
 760                           CheckBuildItemGroup (groups[0], new string[] {
 761                                 "D", "D",
 762                                 "C", "$(C)",
 763                                 "A", "a;b",
 764                                 "B", "$(A)"
 765                         }, "H1");*/
 766
 767                         CheckBuildItemGroup (project.GetEvaluatedItemsByName ("C"), new string[] {
 768                                 "C", "D"
 769                         }, "H2");
 770
 771                         CheckBuildItemGroup (project.GetEvaluatedItemsByName ("C"), new string[] {
 772                                 "C", "D"
 773                         }, "I");
 774
 775                         project.GetEvaluatedItemsByName ("A")[0].SetMetadata ("Meta", "@(B)");
 776
 777                         Assert.AreEqual (5, project.EvaluatedItems.Count, "A0");
 778                         Assert.AreEqual (2, project.GetEvaluatedItemsByName ("A").Count, "A7");
 779
 780                         CheckMetadata (project, "A", "Meta", new string[] { "@(B)", "" }, "J");
 781
 782                         if (!project.Build ()) {
 783                                 logger.DumpMessages ();
 784                                 Assert.Fail ("Build failed");
 785                         }
 786
 787                         CheckMetadata (project, "A", "Meta", new string[] { "@(B)", "" }, "K1");
 788                         CheckEvaluatedMetadata (project, "A", "Meta", new string[] { "", "" }, "K2");
 789
 790                         logger.CheckLoggedMessageHead ("a.md: D", "E10");
 791                         logger.CheckLoggedMessageHead ("a.md: ", "E11");
 792                         Assert.AreEqual (0, logger.NormalMessageCount, "Unexpected messages left");
 793                 }
 794
 795                 [Test]
 796                 public void TestSetMetadata6 ()
 797                 {
 798                         Engine engine;
 799                         Project project;
 800                         BuildItemGroup [] groups = new BuildItemGroup [1];
 801
 802                         string documentString = @"
 803                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 804                                         <ItemGroup>
 805                                                 <A Include='a;b;c'/>
 806                                         </ItemGroup>
 807                                 </Project>
 808                         ";
 809
 810                         engine = new Engine (Consts.BinPath);
 811                         project = engine.CreateNewProject ();
 812                         project.LoadXml (documentString);
 813
 814                         project.EvaluatedItems [0].SetMetadata ("Meta", "Value");
 815                         //NOTE: this triggers reevaluation
 816                         Assert.AreEqual ("A", project.EvaluatedItems [0].Name, "A0");
 817                         project.ItemGroups.CopyTo (groups, 0);
 818
 819                         Assert.AreEqual (3, groups [0].Count, "A1");
 820                         Assert.AreEqual ("Value", groups [0] [0].GetMetadata ("Meta"), "A2");
 821                         Assert.AreEqual (String.Empty, groups [0] [1].GetMetadata ("Meta"), "A3");
 822                         Assert.AreEqual (String.Empty, groups [0] [2].GetMetadata ("Meta"), "A4");
 823                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A5");
 824                         Assert.AreEqual ("Value", project.EvaluatedItems [0].GetMetadata ("Meta"), "A6");
 825                         Assert.AreEqual (String.Empty, project.EvaluatedItems [1].GetMetadata ("Meta"), "A7");
 826                         Assert.AreEqual (String.Empty, project.EvaluatedItems [1].GetMetadata ("Meta"), "A8");
 827                 }
 828
 829                 [Test]
 830                 public void TestSetMetadata7 ()
 831                 {
 832                         Engine engine;
 833                         Project project;
 834                         BuildItemGroup [] groups = new BuildItemGroup [1];
 835
 836                         string documentString = @"
 837                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 838                                         <ItemGroup>
 839                                                 <A Include='a;b;c'>
 840                                                         <Meta>Value2</Meta>
 841                                                 </A>
 842                                         </ItemGroup>
 843                                 </Project>
 844                         ";
 845
 846                         engine = new Engine (Consts.BinPath);
 847                         project = engine.CreateNewProject ();
 848                         project.LoadXml (documentString);
 849
 850                         project.ItemGroups.CopyTo (groups, 0);
 851                         groups [0][0].SetMetadata ("Meta", "Value");
 852                         Assert.AreEqual ("Value", groups [0] [0].GetEvaluatedMetadata ("Meta"), "A1");
 853                         Assert.AreEqual ("Value", groups [0] [0].GetMetadata ("Meta"), "A2");
 854                 }
 855
 856                 [Test]
 857                 public void TestSetMetadata8 ()
 858                 {
 859                         Engine engine;
 860                         Project project;
 861                         BuildItemGroup [] groups = new BuildItemGroup [1];
 862
 863                         string documentString = @"
 864                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 865                                         <ItemGroup>
 866                                                 <A Include='a' />
 867                                         </ItemGroup>
 868                                 </Project>
 869                         ";
 870
 871                         engine = new Engine (Consts.BinPath);
 872                         project = engine.CreateNewProject ();
 873                         project.LoadXml (documentString);
 874
 875                         project.EvaluatedItems [0].SetMetadata ("Meta", "Value");
 876
 877                         Assert.AreEqual (1, project.EvaluatedItems.Count, "A1");
 878                         Assert.AreEqual ("Value", project.EvaluatedItems [0].GetMetadata ("Meta"), "A2");
 879                         project.ItemGroups.CopyTo (groups, 0);
 880                         Assert.AreEqual (1, groups [0].Count, "A3");
 881                 }
 882
 883                 [Test]
 884                 public void TestBuildItemTransform ()
 885                 {
 886                         string projectText = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 887                                 <UsingTask TaskName='BatchingTestTask' AssemblyFile='Test\resources\TestTasks.dll' />
 888
 889                                 <ItemGroup>
 890                                         <Foo Include='abc'/>
 891                                         <Foo Include='def'/>
 892                                 </ItemGroup>
 893                                 <PropertyGroup>
 894                                         <FooProp>PropValue/</FooProp>
 895                                 </PropertyGroup>
 896
 897                                 <Target Name=""main"">
 898                                         <CreateItem Include=""@(Foo)"">
 899                                                 <Output TaskParameter =""Include"" ItemName=""SyntheticFoo""/>
 900                                         </CreateItem>
 901
 902                                         <BatchingTestTask
 903                                                 TaskItemsOutput=""@(SyntheticFoo->'$(FooProp)%(Identity).txt')"">
 904                                                 <Output TaskParameter='TaskItemsOutput' ItemName='I0' />
 905                                         </BatchingTestTask>
 906                                 </Target>
 907                         </Project>";
 908
 909                         Engine engine = new Engine (Consts.BinPath);
 910                         MonoTests.Microsoft.Build.Tasks.TestMessageLogger logger =
 911                                 new MonoTests.Microsoft.Build.Tasks.TestMessageLogger ();
 912                         engine.RegisterLogger (logger);
 913                         Project project = engine.CreateNewProject ();
 914                         project.LoadXml (projectText);
 915
 916                         bool result = project.Build ("main");
 917                         if (!result) {
 918                                 logger.DumpMessages ();
 919                                 Assert.Fail ("Build failed");
 920                         }
 921
 922                         BuildItemGroup grp = project.GetEvaluatedItemsByName ("I0");
 923                         Assert.AreEqual (2, grp.Count, "A1");
 924                         Assert.AreEqual ("PropValue/abc.txt", grp [0].FinalItemSpec, "A2");
 925                         Assert.AreEqual ("PropValue/def.txt", grp [1].FinalItemSpec, "A3");
 926                 }
 927
 928                 void CheckMetadata (Project p, string itemname, string metadataname, string[] values, string prefix)
 929                 {
 930                         BuildItemGroup group = p.GetEvaluatedItemsByName (itemname);
 931
 932                         Assert.AreEqual (values.Length, group.Count, "Number of items for itemname " + itemname);
 933
 934                         for (int i = 0; i < values.Length; i++) {
 935                                 Assert.AreEqual (values[i], group [i].GetMetadata (metadataname), prefix + "#" + i.ToString ());
 936                         }
 937                 }
 938
 939                 void CheckEvaluatedMetadata (Project p, string itemname, string metadataname, string[] values, string prefix)
 940                 {
 941                         BuildItemGroup group = p.GetEvaluatedItemsByName (itemname);
 942
 943                         Assert.AreEqual (values.Length, group.Count, "Number of items for itemname " + itemname);
 944
 945                         for (int i = 0; i < values.Length; i++) {
 946                                 Assert.AreEqual (values[i], group [i].GetEvaluatedMetadata (metadataname), prefix + "#" + i.ToString ());
 947                         }
 948                 }
 949
 950                 void CheckBuildItemGroup (BuildItemGroup group, string[] names, string prefix)
 951                 {
 952                         try {
 953                                 Assert.AreEqual (group.Count, names.Length / 2, "Number of items in group");
 954                                 for (int i = 0; i < group.Count; i++) {
 955                                         Assert.AreEqual (names[i * 2], group[i].Name, String.Format ("{0}#{1} : item name", prefix, i));
 956                                         Assert.AreEqual (names[(i * 2) + 1], group[i].FinalItemSpec, String.Format ("{0}#{1} : FinalItemSpec", prefix, i));
 957                                 }
 958                         } catch (AssertionException) {
 959                                 for (int i = 0; i < group.Count; i++) {
 960                                         Console.WriteLine ("group[{0}] = {1}", i, group[i].Name);
 961                                         Console.WriteLine ("group[{0}] = {1}", i, group[i].FinalItemSpec);
 962                                 }
 963                                 throw;
 964                         }
 965                 }
 966         }
 967 }