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                 }
 336
 337                 [Test]
 338                 public void TestGetEvaluatedMetadata2 ()
 339                 {
 340                         Engine engine;
 341                         Project project;
 342                         BuildItemGroup [] groups = new BuildItemGroup [1];
 343
 344                         string documentString = @"
 345                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 346                                         <PropertyGroup>
 347                                                 <A>A</A>
 348                                         </PropertyGroup>
 349                                         <ItemGroup>
 350                                                 <A Include='a;b'>
 351                                                         <Meta>Value</Meta>
 352                                                         <Meta2>$(A)</Meta2>
 353                                                 </A>
 354                                         </ItemGroup>
 355                                 </Project>
 356                         ";
 357
 358                         engine = new Engine (Consts.BinPath);
 359                         project = engine.CreateNewProject ();
 360                         project.LoadXml (documentString);
 361                         project.ItemGroups.CopyTo (groups, 0);
 362
 363                         Assert.AreEqual ("Value", groups [0] [0].GetEvaluatedMetadata ("Meta"), "A1");
 364                         Assert.AreEqual (String.Empty, groups [0] [0].GetEvaluatedMetadata ("Other"), "A2");
 365                         Assert.AreEqual ("A", groups [0] [0].GetEvaluatedMetadata ("Meta2"), "A3");
 366                 }
 367
 368                 [Test]
 369                 public void TestHasMetadata1 ()
 370                 {
 371                         string itemName = "a";
 372                         string itemInclude = "a";
 373                         string metadataName = "name";
 374
 375                         item = new BuildItem (itemName, itemInclude);
 376
 377                         Assert.AreEqual (false, item.HasMetadata (metadataName), "A1");
 378
 379                         item.SetMetadata (metadataName, "value");
 380
 381                         Assert.AreEqual (true, item.HasMetadata (metadataName), "A2");
 382                         Assert.IsTrue (item.HasMetadata ("FullPath"), "A3");
 383                         Assert.IsTrue (item.HasMetadata ("RootDir"), "A4");
 384                         Assert.IsTrue (item.HasMetadata ("Filename"), "A5");
 385                         Assert.IsTrue (item.HasMetadata ("Extension"), "A6");
 386                         Assert.IsTrue (item.HasMetadata ("RelativeDir"), "A7");
 387                         Assert.IsTrue (item.HasMetadata ("Directory"), "A8");
 388                         Assert.IsTrue (item.HasMetadata ("RecursiveDir"), "A9");
 389                         Assert.IsTrue (item.HasMetadata ("Identity"), "A10");
 390                         Assert.IsTrue (item.HasMetadata ("ModifiedTime"), "A11");
 391                         Assert.IsTrue (item.HasMetadata ("CreatedTime"), "A12");
 392                         Assert.IsTrue (item.HasMetadata ("AccessedTime"), "A13");
 393                 }
 394
 395                 [Test]
 396                 public void TestHasMetadata2 ()
 397                 {
 398                         Engine engine;
 399                         Project project;
 400                         BuildItemGroup [] groups = new BuildItemGroup [1];
 401
 402                         string documentString = @"
 403                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 404                                         <ItemGroup>
 405                                                 <A Include='a;b'>
 406                                                         <Meta>Value</Meta>
 407                                                 </A>
 408                                         </ItemGroup>
 409                                 </Project>
 410                         ";
 411
 412                         engine = new Engine (Consts.BinPath);
 413                         project = engine.CreateNewProject ();
 414                         project.LoadXml (documentString);
 415                         project.ItemGroups.CopyTo (groups, 0);
 416
 417                         BuildItem item = groups [0] [0];
 418
 419                         Assert.IsFalse (item.HasMetadata ("Other"), "A1");
 420                         Assert.IsTrue (item.HasMetadata ("Meta"), "A2");
 421                         Assert.IsTrue (item.HasMetadata ("FullPath"), "A3");
 422                         Assert.IsTrue (item.HasMetadata ("RootDir"), "A4");
 423                         Assert.IsTrue (item.HasMetadata ("Filename"), "A5");
 424                         Assert.IsTrue (item.HasMetadata ("Extension"), "A6");
 425                         Assert.IsTrue (item.HasMetadata ("RelativeDir"), "A7");
 426                         Assert.IsTrue (item.HasMetadata ("Directory"), "A8");
 427                         Assert.IsTrue (item.HasMetadata ("RecursiveDir"), "A9");
 428                         Assert.IsTrue (item.HasMetadata ("Identity"), "A10");
 429                         Assert.IsTrue (item.HasMetadata ("ModifiedTime"), "A11");
 430                         Assert.IsTrue (item.HasMetadata ("CreatedTime"), "A12");
 431                         Assert.IsTrue (item.HasMetadata ("AccessedTime"), "A13");
 432                 }
 433
 434                 [Test]
 435                 [ExpectedException (typeof (ArgumentNullException))]
 436                 public void TestHasMetadata3 ()
 437                 {
 438                         item = new BuildItem ("name", "spec");
 439                         item.HasMetadata (null);
 440                 }
 441
 442                 [Test]
 443                 [ExpectedException (typeof (InvalidProjectFileException))]
 444                 public void TestInclude1 ()
 445                 {
 446                         Engine engine;
 447                         Project project;
 448
 449                         string documentString = @"
 450                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 451                                         <ItemGroup>
 452                                                 <A Include='' />
 453                                         </ItemGroup>
 454                                 </Project>
 455                         ";
 456
 457                         engine = new Engine (Consts.BinPath);
 458                         project = engine.CreateNewProject ();
 459                         project.LoadXml (documentString);
 460                 }
 461
 462                 [Test]
 463                 public void TestInclude2 ()
 464                 {
 465                         Engine engine;
 466                         Project project;
 467
 468                         string documentString = @"
 469                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 470                                         <ItemGroup>
 471                                                 <A Include='a' />
 472                                         </ItemGroup>
 473                                 </Project>
 474                         ";
 475
 476                         engine = new Engine (Consts.BinPath);
 477                         project = engine.CreateNewProject ();
 478                         project.LoadXml (documentString);
 479
 480                         Assert.AreEqual ("a", project.EvaluatedItems [0].Include, "A1");
 481                 }
 482
 483                 [Test]
 484                 public void TestInclude3 ()
 485                 {
 486                         BuildItem item = new BuildItem ("name", "a");
 487                         item.Include = "b";
 488                         Assert.AreEqual ("b", item.Include, "A1");
 489                 }
 490
 491                 [Test]
 492                 public void TestName1 ()
 493                 {
 494                         Engine engine;
 495                         Project project;
 496                         BuildItemGroup [] groups = new BuildItemGroup [1];
 497
 498                         string documentString = @"
 499                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 500                                         <ItemGroup>
 501                                                 <A Include='a;b' />
 502                                         </ItemGroup>
 503                                 </Project>
 504                         ";
 505
 506                         engine = new Engine (Consts.BinPath);
 507                         project = engine.CreateNewProject ();
 508                         project.LoadXml (documentString);
 509
 510                         project.EvaluatedItems [0].Name = "C";
 511
 512                         Assert.AreEqual (2, project.EvaluatedItems.Count, "A1");
 513                         Assert.AreEqual ("C", project.EvaluatedItems [0].Name, "A2");
 514                         Assert.AreEqual ("A", project.EvaluatedItems [1].Name, "A3");
 515                         project.ItemGroups.CopyTo (groups, 0);
 516                         Assert.AreEqual (2, groups [0].Count, "A4");
 517                         Assert.AreEqual ("C", groups [0] [0].Name, "A5");
 518                         Assert.AreEqual ("A", groups [0] [1].Name, "A6");
 519                 }
 520
 521                 [Test]
 522                 public void TestName2 ()
 523                 {
 524                         BuildItem item = new BuildItem ("A", "V");
 525                         item.Name = "B";
 526                         Assert.AreEqual ("B", item.Name, "A1");
 527                 }
 528
 529                 [Test]
 530                 public void TestRemoveMetadata1 ()
 531                 {
 532                         string itemName = "a";
 533                         string itemInclude = "a";
 534                         string metadataName = "name";
 535                         string metadataValue = "a;b;c";
 536
 537                         item = new BuildItem (itemName, itemInclude);
 538
 539                         item.SetMetadata (metadataName, metadataValue);
 540
 541                         Assert.AreEqual (true, item.HasMetadata (metadataName), "A1");
 542
 543                         item.RemoveMetadata (metadataName);
 544
 545                         Assert.AreEqual (false, item.HasMetadata (metadataName), "A2");
 546                 }
 547
 548                 [Test]
 549                 [ExpectedException (typeof (ArgumentNullException))]
 550                 public void TestRemoveMetadata2 ()
 551                 {
 552                         item = new BuildItem ("name", "value");
 553                         item.RemoveMetadata (null);
 554                 }
 555
 556                 [Test]
 557                 public void TestRemoveMetadata3 ()
 558                 {
 559                         item = new BuildItem ("name", "value");
 560                         item.RemoveMetadata ("undefined_metadata");
 561                 }
 562
 563                 [Test]
 564                 [ExpectedException (typeof (ArgumentException),
 565                         "\"Filename\" is a reserved item meta-data, and cannot be modified or deleted.")]
 566                 public void TestRemoveMetadata4 ()
 567                 {
 568                         item = new BuildItem ("name", "value");
 569                         item.RemoveMetadata ("Filename");
 570                 }
 571
 572                 [Test]
 573                 public void TestRemoveMetadata5 ()
 574                 {
 575                         Engine engine;
 576                         Project project;
 577                         BuildItemGroup [] groups = new BuildItemGroup [1];
 578
 579                         string documentString = @"
 580                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 581                                         <ItemGroup>
 582                                                 <A Include='a;b'>
 583                                                         <Meta>Value</Meta>
 584                                                         <Meta2>$(A)</Meta2>
 585                                                 </A>
 586                                                 <B Include='a'/>
 587                                         </ItemGroup>
 588                                 </Project>
 589                         ";
 590
 591                         engine = new Engine (Consts.BinPath);
 592                         project = engine.CreateNewProject ();
 593                         project.LoadXml (documentString);
 594                         project.ItemGroups.CopyTo (groups, 0);
 595
 596                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A1");
 597
 598                         groups [0] [0].RemoveMetadata ("Meta");
 599                         Assert.IsFalse (groups [0] [0].HasMetadata ("Meta"), "A2");
 600                         groups [0] [0].RemoveMetadata ("undefined_metadata");
 601
 602                         Assert.AreEqual (2, groups [0].Count, "A3");
 603                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A4");
 604                 }
 605
 606                 [Test]
 607                 public void TestRemoveMetadata6 ()
 608                 {
 609                         Engine engine;
 610                         Project project;
 611                         BuildItemGroup [] groups = new BuildItemGroup [1];
 612
 613                         string documentString = @"
 614                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 615                                         <ItemGroup>
 616                                                 <A Include='a;b;c'>
 617                                                         <Meta>Value</Meta>
 618                                                         <Meta2>$(A)</Meta2>
 619                                                 </A>
 620                                                 <B Include='a'/>
 621                                         </ItemGroup>
 622                                 </Project>
 623                         ";
 624
 625                         engine = new Engine (Consts.BinPath);
 626                         project = engine.CreateNewProject ();
 627                         project.LoadXml (documentString);
 628
 629                         Assert.AreEqual (4, project.EvaluatedItems.Count, "A1");
 630                         project.ItemGroups.CopyTo (groups, 0);
 631                         Assert.AreEqual (2, groups [0].Count, "A2");
 632
 633                         BuildItem b1 = project.EvaluatedItems [0];
 634
 635                         b1.RemoveMetadata ("Meta");
 636
 637                         Assert.AreEqual (4, project.EvaluatedItems.Count, "A3");
 638                         project.ItemGroups.CopyTo (groups, 0);
 639                         Assert.AreEqual (4, groups [0].Count, "A4");
 640                 }
 641
 642                 [Test]
 643                 [ExpectedException (typeof (ArgumentNullException))]
 644                 public void TestSetMetadata1 ()
 645                 {
 646                         item = new BuildItem ("name", "include");
 647                         item.SetMetadata (null, null);
 648                 }
 649
 650                 [Test]
 651                 [ExpectedException (typeof (ArgumentNullException))]
 652                 public void TestSetMetadata2 ()
 653                 {
 654                         item = new BuildItem ("name", "include");
 655                         item.SetMetadata ("name", null);
 656                 }
 657
 658                 [Test]
 659                 public void TestSetMetadata3 ()
 660                 {
 661                         item = new BuildItem ("name", "include");
 662                         item.SetMetadata ("a", "$(A)");
 663                         item.SetMetadata ("b", "$(A)", true);
 664                         item.SetMetadata ("c", "$(A)", false);
 665
 666                         Assert.AreEqual ("$(A)", item.GetEvaluatedMetadata ("a"), "A1");
 667                         Assert.AreEqual ("$(A)", item.GetEvaluatedMetadata ("b"), "A2");
 668                         Assert.AreEqual ("$(A)", item.GetEvaluatedMetadata ("c"), "A3");
 669                         Assert.AreEqual ("$(A)", item.GetMetadata ("a"), "A4");
 670                         Assert.AreEqual (Utilities.Escape ("$(A)"), item.GetMetadata ("b"), "A5");
 671                         Assert.AreEqual ("$(A)", item.GetMetadata ("c"), "A6");
 672                 }
 673                 [Test]
 674                 [ExpectedException (typeof (ArgumentException),
 675                         "\"Filename\" is a reserved item meta-data, and cannot be modified or deleted.")]
 676                 public void TestSetMetadata4 ()
 677                 {
 678                         item = new BuildItem ("name", "include");
 679                         item.SetMetadata ("Filename", "something");
 680                 }
 681
 682                 [Test]
 683                 public void TestSetMetadata5 ()
 684                 {
 685                         Engine engine;
 686                         Project project;
 687                         BuildItemGroup [] groups = new BuildItemGroup [1];
 688
 689                         string documentString = @"
 690                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 691                                         <PropertyGroup>
 692                                                 <A>A</A>
 693                                         </PropertyGroup>
 694                                         <ItemGroup>
 695                                                 <A Include='a;b'/>
 696                                         </ItemGroup>
 697                                 </Project>
 698                         ";
 699
 700                         engine = new Engine (Consts.BinPath);
 701                         project = engine.CreateNewProject ();
 702                         project.LoadXml (documentString);
 703
 704                         project.ItemGroups.CopyTo (groups, 0);
 705
 706                         groups [0] [0].SetMetadata ("Meta", "$(A)");
 707                         Assert.AreEqual (2, project.EvaluatedItems.Count, "A0");
 708
 709                         Assert.AreEqual (1, groups [0].Count, "A1");
 710                         Assert.AreEqual ("$(A)", groups [0] [0].GetMetadata ("Meta"), "A2");
 711                         Assert.AreEqual ("$(A)", project.EvaluatedItems [0].GetMetadata ("Meta"), "A3");
 712                         Assert.AreEqual ("$(A)", project.EvaluatedItems [1].GetMetadata ("Meta"), "A4");
 713                         Assert.AreEqual ("A", project.EvaluatedItems [0].GetEvaluatedMetadata ("Meta"), "A5");
 714                         Assert.AreEqual ("A", project.EvaluatedItems [1].GetEvaluatedMetadata ("Meta"), "A6");
 715                 }
 716
 717                 [Test]
 718                 public void TestSetMetadata6 ()
 719                 {
 720                         Engine engine;
 721                         Project project;
 722                         BuildItemGroup [] groups = new BuildItemGroup [1];
 723
 724                         string documentString = @"
 725                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 726                                         <ItemGroup>
 727                                                 <A Include='a;b;c'/>
 728                                         </ItemGroup>
 729                                 </Project>
 730                         ";
 731
 732                         engine = new Engine (Consts.BinPath);
 733                         project = engine.CreateNewProject ();
 734                         project.LoadXml (documentString);
 735
 736                         project.EvaluatedItems [0].SetMetadata ("Meta", "Value");
 737                         //NOTE: this triggers reevaluation
 738                         Assert.AreEqual ("A", project.EvaluatedItems [0].Name, "A0");
 739                         project.ItemGroups.CopyTo (groups, 0);
 740
 741                         Assert.AreEqual (3, groups [0].Count, "A1");
 742                         Assert.AreEqual ("Value", groups [0] [0].GetMetadata ("Meta"), "A2");
 743                         Assert.AreEqual (String.Empty, groups [0] [1].GetMetadata ("Meta"), "A3");
 744                         Assert.AreEqual (String.Empty, groups [0] [2].GetMetadata ("Meta"), "A4");
 745                         Assert.AreEqual (3, project.EvaluatedItems.Count, "A5");
 746                         Assert.AreEqual ("Value", project.EvaluatedItems [0].GetMetadata ("Meta"), "A6");
 747                         Assert.AreEqual (String.Empty, project.EvaluatedItems [1].GetMetadata ("Meta"), "A7");
 748                         Assert.AreEqual (String.Empty, project.EvaluatedItems [1].GetMetadata ("Meta"), "A8");
 749                 }
 750
 751                 [Test]
 752                 public void TestSetMetadata7 ()
 753                 {
 754                         Engine engine;
 755                         Project project;
 756                         BuildItemGroup [] groups = new BuildItemGroup [1];
 757
 758                         string documentString = @"
 759                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 760                                         <ItemGroup>
 761                                                 <A Include='a;b;c'>
 762                                                         <Meta>Value2</Meta>
 763                                                 </A>
 764                                         </ItemGroup>
 765                                 </Project>
 766                         ";
 767
 768                         engine = new Engine (Consts.BinPath);
 769                         project = engine.CreateNewProject ();
 770                         project.LoadXml (documentString);
 771
 772                         project.ItemGroups.CopyTo (groups, 0);
 773                         groups [0][0].SetMetadata ("Meta", "Value");
 774                         Assert.AreEqual ("Value", groups [0] [0].GetEvaluatedMetadata ("Meta"), "A1");
 775                         Assert.AreEqual ("Value", groups [0] [0].GetMetadata ("Meta"), "A2");
 776                 }
 777
 778                 [Test]
 779                 public void TestSetMetadata8 ()
 780                 {
 781                         Engine engine;
 782                         Project project;
 783                         BuildItemGroup [] groups = new BuildItemGroup [1];
 784
 785                         string documentString = @"
 786                                 <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
 787                                         <ItemGroup>
 788                                                 <A Include='a' />
 789                                         </ItemGroup>
 790                                 </Project>
 791                         ";
 792
 793                         engine = new Engine (Consts.BinPath);
 794                         project = engine.CreateNewProject ();
 795                         project.LoadXml (documentString);
 796
 797                         project.EvaluatedItems [0].SetMetadata ("Meta", "Value");
 798
 799                         Assert.AreEqual (1, project.EvaluatedItems.Count, "A1");
 800                         Assert.AreEqual ("Value", project.EvaluatedItems [0].GetMetadata ("Meta"), "A2");
 801                         project.ItemGroups.CopyTo (groups, 0);
 802                         Assert.AreEqual (1, groups [0].Count, "A3");
 803                 }
 804         }
 805 }