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                 [Test]
  97                 [ExpectedException (typeof (ArgumentException),
  98                         "Parameter \"itemInclude\" cannot have zero length.")]
  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                 [Test]
 128                 [ExpectedException (typeof (InvalidOperationException),
 129                         "Cannot set a condition on an object not represented by an XML element in the project file.")]
 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                 [Test]
 221                 [ExpectedException (typeof (InvalidOperationException),
 222                         "Assigning the \"Exclude\" attribute of a virtual item is not allowed.")]
 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                 [Test]
 565                 [ExpectedException (typeof (ArgumentException),
 566                         "\"Filename\" is a reserved item meta-data, and cannot be modified or deleted.")]
 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                 [Test]
 675                 [ExpectedException (typeof (ArgumentException),
 676                         "\"Filename\" is a reserved item meta-data, and cannot be modified or deleted.")]
 677                 public void TestSetMetadata4 ()
 678                 {
 679                         item = new BuildItem ("name", "include");
 680                         item.SetMetadata ("Filename", "something");
 681                 }
 682
 683                 [Test]
 684                 public void TestSetMetadata5 ()
 685                 {
 686                         Engine engine;
 687                         Project project;
 688                         BuildItemGroup [] groups = new BuildItemGroup [1];
 689
 690                         string documentString = @"
 691                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 692                                         <PropertyGroup>
 693                                                 <A>A</A>
 694                                         </PropertyGroup>
 695                                         <ItemGroup>
 696                                                 <A Include='a;b'/>
 697                                         </ItemGroup>
 698                                 </Project>
 699                         ";
 700
 701                         engine = new Engine (Consts.BinPath);
 702                         project = engine.CreateNewProject ();
 703                         project.LoadXml (documentString);
 704
 705                         project.ItemGroups.CopyTo (groups, 0);
 706
 707                         groups [0] [0].SetMetadata ("Meta", "$(A)");
 708                         Assert.AreEqual (2, project.EvaluatedItems.Count, "A0");
 709
 710                         Assert.AreEqual (1, groups [0].Count, "A1");
 711                         Assert.AreEqual ("$(A)", groups [0] [0].GetMetadata ("Meta"), "A2");
 712                         Assert.AreEqual ("$(A)", project.EvaluatedItems [0].GetMetadata ("Meta"), "A3");
 713                         Assert.AreEqual ("$(A)", project.EvaluatedItems [1].GetMetadata ("Meta"), "A4");
 714                         Assert.AreEqual ("A", project.EvaluatedItems [0].GetEvaluatedMetadata ("Meta"), "A5");
 715                         Assert.AreEqual ("A", project.EvaluatedItems [1].GetEvaluatedMetadata ("Meta"), "A6");
 716                 }
 717
 718                 [Test]
 719                 public void TestSetMetadata6 ()
 720                 {
 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                                         <ItemGroup>
 728                                                 <A Include='a;b;c'/>
 729                                         </ItemGroup>
 730                                 </Project>
 731                         ";
 732
 733                         engine = new Engine (Consts.BinPath);
 734                         project = engine.CreateNewProject ();
 735                         project.LoadXml (documentString);
 736
 737                         project.EvaluatedItems [0].SetMetadata ("Meta", "Value");
 738                         //NOTE: this triggers reevaluation
 739                         Assert.AreEqual ("A", project.EvaluatedItems [0].Name, "A0");
 740                         project.ItemGroups.CopyTo (groups, 0);
 741
 742                         Assert.AreEqual (3, groups [0].Count, "A1");
 743                         Assert.AreEqual ("Value", groups [0] [0].GetMetadata ("Meta"), "A2");
 744                         Assert.AreEqual (String.Empty, groups [0] [1].GetMetadata ("Meta"), "A3");
 745                         Assert.AreEqual (String.Empty, groups [0] [2].GetMetadata ("Meta"), "A4");
 746                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A5");
 747                         Assert.AreEqual ("Value", project.EvaluatedItems [0].GetMetadata ("Meta"), "A6");
 748                         Assert.AreEqual (String.Empty, project.EvaluatedItems [1].GetMetadata ("Meta"), "A7");
 749                         Assert.AreEqual (String.Empty, project.EvaluatedItems [1].GetMetadata ("Meta"), "A8");
 750                 }
 751
 752                 [Test]
 753                 public void TestSetMetadata7 ()
 754                 {
 755                         Engine engine;
 756                         Project project;
 757                         BuildItemGroup [] groups = new BuildItemGroup [1];
 758
 759                         string documentString = @"
 760                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 761                                         <ItemGroup>
 762                                                 <A Include='a;b;c'>
 763                                                         <Meta>Value2</Meta>
 764                                                 </A>
 765                                         </ItemGroup>
 766                                 </Project>
 767                         ";
 768
 769                         engine = new Engine (Consts.BinPath);
 770                         project = engine.CreateNewProject ();
 771                         project.LoadXml (documentString);
 772
 773                         project.ItemGroups.CopyTo (groups, 0);
 774                         groups [0][0].SetMetadata ("Meta", "Value");
 775                         Assert.AreEqual ("Value", groups [0] [0].GetEvaluatedMetadata ("Meta"), "A1");
 776                         Assert.AreEqual ("Value", groups [0] [0].GetMetadata ("Meta"), "A2");
 777                 }
 778
 779                 [Test]
 780                 public void TestSetMetadata8 ()
 781                 {
 782                         Engine engine;
 783                         Project project;
 784                         BuildItemGroup [] groups = new BuildItemGroup [1];
 785
 786                         string documentString = @"
 787                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 788                                         <ItemGroup>
 789                                                 <A Include='a' />
 790                                         </ItemGroup>
 791                                 </Project>
 792                         ";
 793
 794                         engine = new Engine (Consts.BinPath);
 795                         project = engine.CreateNewProject ();
 796                         project.LoadXml (documentString);
 797
 798                         project.EvaluatedItems [0].SetMetadata ("Meta", "Value");
 799
 800                         Assert.AreEqual (1, project.EvaluatedItems.Count, "A1");
 801                         Assert.AreEqual ("Value", project.EvaluatedItems [0].GetMetadata ("Meta"), "A2");
 802                         project.ItemGroups.CopyTo (groups, 0);
 803                         Assert.AreEqual (1, groups [0].Count, "A3");
 804                 }
 805         }
 806 }