mcs/class/Microsoft.Build.Tasks/Test/Microsoft.Build.Tasks/TaskBatchingTest.cs

   1 //
   2 // TaskBatchingTest.cs
   3 //
   4 // Author:
   5 //   Ankit Jain (jankit@novell.com)
   6 //
   7 // Copyright 2008 Novell, Inc (http://www.novell.com)
   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 System.Collections.Generic;
  30 using System.Text;
  31 using NUnit.Framework;
  32 using Microsoft.Build.BuildEngine;
  33 using Microsoft.Build.Framework;
  34 using Microsoft.Build.Tasks;
  35 using Microsoft.Build.Utilities;
  36
  37 namespace MonoTests.Microsoft.Build.Tasks
  38 {
  39         [TestFixture]
  40         public class TaskBatchingTest
  41         {
  42                 [Test]
  43                 public void Test1 ()
  44                 {
  45                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
  46                                 <ItemGroup>
  47                                         <ResXFile Include=""Item1"">
  48                                                 <Culture>fr</Culture>
  49                                         </ResXFile>
  50                                         <ResXFile Include=""Item2"">
  51                                                 <Culture>fr</Culture>
  52                                         </ResXFile>
  53                                         <ResXFile Include=""Item3"">
  54                                                 <Culture>en</Culture>
  55                                         </ResXFile>
  56                                         <ResXFile Include=""Item4"">
  57                                                 <Culture>gb</Culture>
  58                                         </ResXFile>
  59                                         <ResXFile Include=""Item5"">
  60                                                 <Culture>fr</Culture>
  61                                         </ResXFile>
  62                                         <ResXFile Include=""Item6"">
  63                                                 <Culture>it</Culture>
  64                                         </ResXFile>
  65                                 </ItemGroup>
  66
  67                                 <Target Name=""ShowMessage"">
  68                                         <Message
  69                                                 Text = ""Culture: %(ResXFile.Culture) -- ResXFile: @(ResXFile)"" />
  70                                 </Target>
  71                           </Project>";
  72
  73                         Engine engine = new Engine (Consts.BinPath);
  74                         Project project = engine.CreateNewProject ();
  75
  76                         TestMessageLogger testLogger = new TestMessageLogger ();
  77                         engine.RegisterLogger (testLogger);
  78
  79                         project.LoadXml (projectString);
  80                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
  81
  82                         CheckMessage (testLogger, "fr", "Item1;Item2;Item5", "A2");
  83                         CheckMessage (testLogger, "en", "Item3", "A3");
  84                         CheckMessage (testLogger, "gb", "Item4", "A4");
  85                         CheckMessage (testLogger, "it", "Item6", "A5");
  86                 }
  87
  88                 // Test1 with unqualified %(Culture)
  89                 [Test]
  90                 public void Test2 ()
  91                 {
  92                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
  93                                 <ItemGroup>
  94                                         <ResXFile Include=""Item1"">
  95                                                 <Culture>fr</Culture>
  96                                         </ResXFile>
  97                                         <ResXFile Include=""Item2"">
  98                                                 <Culture>fr</Culture>
  99                                         </ResXFile>
 100                                         <ResXFile Include=""Item3"">
 101                                                 <Culture>en</Culture>
 102                                         </ResXFile>
 103                                         <ResXFile Include=""Item4"">
 104                                                 <Culture>gb</Culture>
 105                                         </ResXFile>
 106                                         <ResXFile Include=""Item5"">
 107                                                 <Culture>fr</Culture>
 108                                         </ResXFile>
 109                                         <ResXFile Include=""Item6"">
 110                                                 <Culture>it</Culture>
 111                                         </ResXFile>
 112                                 </ItemGroup>
 113
 114                                 <Target Name=""ShowMessage"">
 115                                         <Message
 116                                                 Text = ""Culture: %(Culture) -- ResXFile: @(ResXFile)"" />
 117                                 </Target>
 118                           </Project>";
 119
 120                         Engine engine = new Engine (Consts.BinPath);
 121                         Project project = engine.CreateNewProject ();
 122
 123                         TestMessageLogger testLogger = new TestMessageLogger ();
 124                         engine.RegisterLogger (testLogger);
 125
 126                         project.LoadXml (projectString);
 127                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
 128
 129                         CheckMessage (testLogger, "fr", "Item1;Item2;Item5", "A2");
 130                         CheckMessage (testLogger, "en", "Item3", "A3");
 131                         CheckMessage (testLogger, "gb", "Item4", "A4");
 132                         CheckMessage (testLogger, "it", "Item6", "A5");
 133                 }
 134
 135                 [Test]
 136                 public void TestUnqualifiedMetadataReference ()
 137                 {
 138                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 139                                 <ItemGroup>
 140                                         <ResXFile Include=""Item1"">
 141                                                 <Culture>fr</Culture>
 142                                         </ResXFile>
 143                                         <ResXFile Include=""Item5"" />
 144                                         <ResXFile Include=""Item6"">
 145                                                 <Culture>it</Culture>
 146                                         </ResXFile>
 147                                 </ItemGroup>
 148
 149                                 <Target Name=""ShowMessage"">
 150                                         <Message
 151                                                 Text = ""Culture: %(Culture) -- ResXFile: @(ResXFile)"" />
 152                                 </Target>
 153                           </Project>";
 154
 155                         Engine engine = new Engine (Consts.BinPath);
 156                         Project project = engine.CreateNewProject ();
 157
 158                         TestMessageLogger testLogger = new TestMessageLogger ();
 159                         engine.RegisterLogger (testLogger);
 160
 161                         project.LoadXml (projectString);
 162
 163                         //Fails as Culture is being referenced unqualified, and no Culture is
 164                         //specified for "Item5"
 165                         Assert.IsFalse (project.Build ("ShowMessage"), "A1: Build should have failed");
 166                 }
 167
 168                 [Test]
 169                 public void Test4 ()
 170                 {
 171                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 172                                 <ItemGroup>
 173                                         <ResXFile Include=""Item1"">
 174                                                 <Culture>fr</Culture>
 175                                         </ResXFile>
 176                                         <ResXFile Include=""Item5"" />
 177                                         <ResXFile Include=""Item6"">
 178                                                 <Culture>it</Culture>
 179                                         </ResXFile>
 180                                 </ItemGroup>
 181
 182                                 <Target Name=""ShowMessage"">
 183                                         <Message
 184                                                 Text = ""Culture: %(ResXFile.Culture) -- ResXFile: @(ResXFile)"" />
 185                                 </Target>
 186                           </Project>";
 187
 188                         Engine engine = new Engine (Consts.BinPath);
 189                         Project project = engine.CreateNewProject ();
 190
 191                         TestMessageLogger testLogger = new TestMessageLogger ();
 192                         engine.RegisterLogger (testLogger);
 193
 194                         project.LoadXml (projectString);
 195
 196                         //no Culture is specified for "Item5", but
 197                         //Culture is being referenced __qualified__, so works
 198                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
 199
 200                         CheckMessage (testLogger, "fr", "Item1", "A2");
 201                         CheckMessage (testLogger, "", "Item5", "A3");
 202                         CheckMessage (testLogger, "it", "Item6", "A3");
 203                 }
 204
 205                 [Test]
 206                 public void TestMultiItemCollections ()
 207                 {
 208                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 209                                 <ItemGroup>
 210                                         <ResXFile Include=""Item1"">
 211                                                 <Culture>fr</Culture>
 212                                         </ResXFile>
 213                                         <ResXFile Include=""Item2"">
 214                                                 <Culture>fr</Culture>
 215                                         </ResXFile>
 216                                         <ResXFile Include=""Item3"">
 217                                                 <Culture>en</Culture>
 218                                         </ResXFile>
 219                                         <ResXFile Include=""Item4"">
 220                                                 <Culture>gb</Culture>
 221                                         </ResXFile>
 222                                         <ResXFile Include=""Item6"">
 223                                                 <Culture>it</Culture>
 224                                         </ResXFile>
 225
 226                                         <NonResXFile Include=""Item7"">
 227                                                 <Culture>it</Culture>
 228                                         </NonResXFile>
 229                                         <NonResXFile Include=""Item8"">
 230                                                 <Culture>en</Culture>
 231                                         </NonResXFile>
 232                                         <NonResXFile Include=""Item9"">
 233                                                 <Culture>en</Culture>
 234                                         </NonResXFile>
 235                                 </ItemGroup>
 236
 237                                 <Target Name=""ShowMessage"">
 238                                         <Message
 239                                                 Text = ""Culture: %(Culture) -- ResXFiles: @(ResXFile) NonResXFiles: @(NonResXFile)"" />
 240                                 </Target>
 241                           </Project>";
 242
 243                         Engine engine = new Engine (Consts.BinPath);
 244                         Project project = engine.CreateNewProject ();
 245
 246                         TestMessageLogger testLogger = new TestMessageLogger ();
 247                         engine.RegisterLogger (testLogger);
 248
 249                         project.LoadXml (projectString);
 250                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
 251
 252                         CheckMessage2 (testLogger, "fr", "Item1;Item2", string.Empty, "A2");
 253                         CheckMessage2 (testLogger, "en", "Item3", "Item8;Item9", "A3");
 254                         CheckMessage2 (testLogger, "gb", "Item4", string.Empty, "A4");
 255                         CheckMessage2 (testLogger, "it", "Item6", "Item7", "A6");
 256                 }
 257
 258                 [Test]
 259                 public void TestConditionalBatching ()
 260                 {
 261                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 262                                 <ItemGroup>
 263                                         <ResXFile Include=""Item1"">
 264                                                 <Culture>fr</Culture>
 265                                         </ResXFile>
 266                                         <ResXFile Include=""Item2"">
 267                                                 <Culture>fr</Culture>
 268                                         </ResXFile>
 269                                         <ResXFile Include=""Item3"">
 270                                                 <Culture>en</Culture>
 271                                         </ResXFile>
 272                                         <ResXFile Include=""Item4"">
 273                                                 <Culture>gb</Culture>
 274                                         </ResXFile>
 275                                         <ResXFile Include=""Item6"">
 276                                                 <Culture>it</Culture>
 277                                         </ResXFile>
 278
 279                                         <NonResXFile Include=""Item7"">
 280                                                 <Culture>it</Culture>
 281                                         </NonResXFile>
 282                                         <NonResXFile Include=""Item8"">
 283                                                 <Culture>en</Culture>
 284                                         </NonResXFile>
 285                                         <NonResXFile Include=""Item9"">
 286                                                 <Culture>en</Culture>
 287                                         </NonResXFile>
 288                                 </ItemGroup>
 289
 290                                 <Target Name=""ShowMessage"">
 291                                         <Message
 292                                                 Text = ""ResXFiles: @(ResXFile) NonResXFiles: @(NonResXFile)""
 293                                                 Condition = ""'%(Culture)' == 'fr'""/>
 294                                 </Target>
 295                           </Project>";
 296
 297                         Engine engine = new Engine (Consts.BinPath);
 298                         Project project = engine.CreateNewProject ();
 299
 300                         TestMessageLogger testLogger = new TestMessageLogger ();
 301                         engine.RegisterLogger (testLogger);
 302
 303                         project.LoadXml (projectString);
 304                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
 305
 306                         CheckLoggedMessageHead (testLogger, "ResXFiles: Item1;Item2 NonResXFiles: ", "A2");
 307                 }
 308
 309                 [Test]
 310                 public void TestMultipleMetadataReference ()
 311                 {
 312                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 313                                 <ItemGroup>
 314                                         <ExampColl Include=""Item1"">
 315                                                 <Number>1</Number>
 316                                         </ExampColl>
 317                                         <ExampColl Include=""Item2"">
 318                                                 <Number>2</Number>
 319                                         </ExampColl>
 320                                         <ExampColl Include=""Item3"">
 321                                         <Number>1</Number>
 322                                         </ExampColl>
 323
 324                                         <ExampColl2 Include=""Item4"">
 325                                                 <Number>1</Number>
 326                                         </ExampColl2>
 327                                         <ExampColl2 Include=""Item5"">
 328                                                 <Number>2</Number>
 329                                         <Color>Red</Color>
 330                                         </ExampColl2>
 331                                         <ExampColl2 Include=""Item6"">
 332                                                 <Number>3</Number>
 333                                         <Color>Green</Color>
 334                                         </ExampColl2>
 335                                 </ItemGroup>
 336                                 <Target Name=""ShowMessage"">
 337                                         <Message Text = ""Number: %(Number) Color: %(ExampColl2.Color)-- Items in ExampColl: @(ExampColl) ExampColl2: @(ExampColl2)""/>
 338                                 </Target>
 339                         </Project>";
 340
 341                         Engine engine = new Engine (Consts.BinPath);
 342                         Project project = engine.CreateNewProject ();
 343
 344                         TestMessageLogger testLogger = new TestMessageLogger ();
 345                         engine.RegisterLogger (testLogger);
 346
 347                         project.LoadXml (projectString);
 348                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
 349
 350                         CheckLoggedMessageAny (testLogger, "Number: 1 Color: -- Items in ExampColl: Item1;Item3 ExampColl2: Item4", "A2");
 351                         CheckLoggedMessageAny (testLogger, "Number: 2 Color: Red-- Items in ExampColl:  ExampColl2: Item5", "A3");
 352                         CheckLoggedMessageAny (testLogger, "Number: 3 Color: Green-- Items in ExampColl:  ExampColl2: Item6", "A4");
 353                         CheckLoggedMessageAny (testLogger, "Number: 2 Color: -- Items in ExampColl: Item2 ExampColl2: ", "A5");
 354                         Assert.AreEqual (0, testLogger.Count, "A6");
 355                 }
 356
 357                 [Test]
 358                 public void TestMultipleMetadataReference2 ()
 359                 {
 360                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 361                                 <ItemGroup>
 362                                         <GroupA Include=""file1.txt""/>
 363                                         <GroupA Include=""file2.txt""/>
 364                                         <GroupA Include=""file3.txt""/>
 365                                         <GroupA Include=""file3.txt""/>
 366                                         <GroupA Include=""file4.txt""/>
 367                                 </ItemGroup>
 368
 369                                 <ItemGroup>
 370                                         <GroupB Include=""file1.txt""/>
 371                                         <GroupB Include=""file3.txt""/>
 372                                         <GroupB Include=""file5.txt""/>
 373
 374                                         <GroupC Include=""PreExistingValue""/>
 375                                 </ItemGroup>
 376
 377                                 <Target Name=""Build"">
 378                                         <CreateItem Include=""@(GroupA)"" Condition=""'%(Identity)' != '' and '@(GroupA)' != '' and '@(GroupB)' != ''"" >
 379                                                 <Output TaskParameter=""Include"" ItemName=""GroupC""/>
 380                                         </CreateItem>
 381                                         <Message Text=""%(GroupC.Identity)""/>
 382                                 </Target>
 383                         </Project>";
 384
 385                         Engine engine = new Engine (Consts.BinPath);
 386                         Project project = engine.CreateNewProject ();
 387
 388                         TestMessageLogger testLogger = new TestMessageLogger ();
 389
 390                         project.LoadXml (projectString);
 391                         Assert.IsTrue (project.Build ("Build"), "A1: Build failed");
 392
 393                         BuildItemGroup include = project.GetEvaluatedItemsByName ("GroupC");
 394                         Assert.AreEqual (4, include.Count, "A2");
 395
 396                         string [,] additional_metadata = new string [,] { { "Identity", "PreExistingValue" } };
 397                         CreateItemTest.CheckBuildItem (include [0], "GroupC", additional_metadata, "PreExistingValue", "A3");
 398
 399                         additional_metadata = new string [,] { { "Identity", "file1.txt" } };
 400                         CreateItemTest.CheckBuildItem (include [1], "GroupC", additional_metadata, "file1.txt", "A4");
 401
 402                         additional_metadata = new string [,] { { "Identity", "file3.txt" } };
 403                         CreateItemTest.CheckBuildItem (include [2], "GroupC", additional_metadata, "file3.txt", "A5");
 404                         CreateItemTest.CheckBuildItem (include [3], "GroupC", additional_metadata, "file3.txt", "A6");
 405                 }
 406
 407                 [Test]
 408                 public void TestIdentity ()
 409                 {
 410                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 411                                 <ItemGroup>
 412                                         <ExampColl Include=""Item1""/>
 413                                         <ExampColl Include=""Item2""/>
 414                                         <ExampColl Include=""Item3""/>
 415                                         <ExampColl Include=""Item4""/>
 416                                         <ExampColl Include=""Item4""/>
 417                                         <ExampColl Include=""Item5""/>
 418                                         <ExampColl Include=""Item6""/>
 419                                 </ItemGroup>
 420                                 <Target Name=""ShowMessage"">
 421                                         <Message Text = ""Identity: %(IdenTIty) -- Items in ExampColl: @(ExampColl)""/>
 422                                 </Target>
 423                         </Project>";
 424
 425                         Engine engine = new Engine (Consts.BinPath);
 426                         Project project = engine.CreateNewProject ();
 427
 428                         TestMessageLogger testLogger = new TestMessageLogger ();
 429                         engine.RegisterLogger (testLogger);
 430
 431                         project.LoadXml (projectString);
 432                         Assert.IsTrue (project.Build ("ShowMessage"), "A1: Build failed");
 433
 434                         CheckLoggedMessageAny (testLogger, "Identity: Item1 -- Items in ExampColl: Item1", "A2");
 435                         CheckLoggedMessageAny (testLogger, "Identity: Item2 -- Items in ExampColl: Item2", "A3");
 436                         CheckLoggedMessageAny (testLogger, "Identity: Item3 -- Items in ExampColl: Item3", "A4");
 437                         CheckLoggedMessageAny (testLogger, "Identity: Item4 -- Items in ExampColl: Item4;Item4", "A5");
 438                         CheckLoggedMessageAny (testLogger, "Identity: Item5 -- Items in ExampColl: Item5", "A6");
 439                         CheckLoggedMessageAny (testLogger, "Identity: Item6 -- Items in ExampColl: Item6", "A7");
 440                         Assert.AreEqual (0, testLogger.Count, "A8");
 441                 }
 442
 443                 [Test]
 444                 public void TestFilter ()
 445                 {
 446                         string projectString = @"<Project xmlns=""http://schemas.microsoft.com/developer/msbuild/2003"">
 447                                  <ItemGroup>
 448                                          <fruit Include=""apple"">
 449                                                  <consistency>firm</consistency>
 450                                          </fruit>
 451                                          <fruit Include=""orange"">
 452                                                  <consistency>pulpy</consistency>
 453                                          </fruit>
 454                                          <fruit Include=""banana"">
 455                                                  <consistency>softish</consistency>
 456                                          </fruit>
 457                                          <fruit Include=""pear"">
 458                                                  <consistency>unsound</consistency>
 459                                          </fruit>
 460                                          <fruit Include=""apricot"">
 461                                                  <consistency>unsound</consistency>
 462                                          </fruit>
 463                                  </ItemGroup>
 464                                  <Target Name=""Compost"">
 465                                          <CreateItem Include=""@(fruit)"" Condition=""'%(consistency)' == 'pulpy' or '%(consistency)' == 'unsound' "">
 466                                                 <Output TaskParameter=""Include"" ItemName=""Final""/>
 467                                          </CreateItem>
 468                                  </Target>
 469                          </Project>";
 470
 471                         Engine engine = new Engine (Consts.BinPath);
 472                         Project project = engine.CreateNewProject ();
 473
 474                         TestMessageLogger testLogger = new TestMessageLogger ();
 475                         engine.RegisterLogger (testLogger);
 476
 477                         project.LoadXml (projectString);
 478                         Assert.IsTrue (project.Build ("Compost"), "A1: Build failed");
 479
 480                         BuildItemGroup include = project.GetEvaluatedItemsByName ("Final");
 481                         Assert.AreEqual (3, include.Count, "A2");
 482
 483                         string [,] additional_metadata = new string [,] { { "Identity", "orange" } };
 484                         CreateItemTest.CheckBuildItem (include [0], "Final", additional_metadata, "orange", "A3");
 485
 486                         additional_metadata = new string [,] { { "Identity", "pear" } };
 487                         CreateItemTest.CheckBuildItem (include [1], "Final", additional_metadata, "pear", "A4");
 488
 489                         additional_metadata = new string [,] { { "Identity", "apricot" } };
 490                         CreateItemTest.CheckBuildItem (include [2], "Final", additional_metadata, "apricot", "A5");
 491                 }
 492
 493
 494                 void CheckMessage (TestMessageLogger logger, string culture, string items, string id)
 495                 {
 496                         CheckLoggedMessageHead (logger, String.Format ("Culture: {0} -- ResXFile: {1}", culture, items), id);
 497                 }
 498
 499                 void CheckMessage2 (TestMessageLogger logger, string culture, string resx_files, string nonresx_files, string id)
 500                 {
 501                         CheckLoggedMessageHead (logger, String.Format ("Culture: {0} -- ResXFiles: {1} NonResXFiles: {2}", culture, resx_files, nonresx_files), id);
 502                 }
 503
 504                 void CheckLoggedMessageHead (TestMessageLogger logger, string expected, string id)
 505                 {
 506                         string actual;
 507                         int result = logger.CheckHead (expected, MessageImportance.Normal, out actual);
 508                         if (result == 1)
 509                                 Assert.Fail ("{0}: Expected message '{1}' was not emitted.", id, expected);
 510                         if (result == 2)
 511                                 Assert.AreEqual (expected, actual, id);
 512                 }
 513
 514                 void CheckLoggedMessageAny (TestMessageLogger logger, string expected, string id)
 515                 {
 516                         if (logger.CheckAny (expected, MessageImportance.Normal) == 1)
 517                                 Assert.Fail ("{0}: Expected message '{1}' was not emitted.", id, expected);
 518                 }
 519         }
 520 }