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

   1 //
   2 // CscTest.cs
   3 //
   4 // Author:
   5 //   Marek Sieradzki (marek.sieradzki@gmail.com)
   6 //
   7 // (C) 2006 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 System.Collections;
  30 using Microsoft.Build.Framework;
  31 using Microsoft.Build.Utilities;
  32 using Microsoft.Build.Tasks;
  33 using NUnit.Framework;
  34
  35 namespace MonoTests.Microsoft.Build.Tasks {
  36
  37         class CscExtended : Csc {
  38                 public CscExtended ()
  39                         : base ()
  40                 {
  41                 }
  42
  43                 public void ARFC (CommandLineBuilderExtension commandLine)
  44                 {
  45                         base.AddResponseFileCommands (commandLine);
  46                 }
  47
  48                 public void ACLC (CommandLineBuilderExtension commandLine)
  49                 {
  50                         base.AddCommandLineCommands (commandLine);
  51                 }
  52         }
  53
  54         [TestFixture]
  55         public class CscTest {
  56                 [Test]
  57                 public void TestAssignment ()
  58                 {
  59                         Csc csc = new Csc ();
  60
  61                         csc.AllowUnsafeBlocks = true;
  62                         csc.BaseAddress = "1";
  63                         csc.CheckForOverflowUnderflow = true;
  64                         csc.DisabledWarnings = "2";
  65                         csc.DocumentationFile = "3";
  66                         csc.ErrorReport = "4";
  67                         csc.GenerateFullPaths = true;
  68                         csc.LangVersion = "5";
  69                         csc.ModuleAssemblyName = "6";
  70                         csc.NoStandardLib = true;
  71                         csc.PdbFile = "7";
  72                         csc.Platform = "8";
  73                         csc.UseHostCompilerIfAvailable = true;
  74                         csc.WarningLevel = 9;
  75                         csc.WarningsAsErrors = "10";
  76                         csc.WarningsNotAsErrors = "11";
  77
  78                         Assert.AreEqual (true, csc.AllowUnsafeBlocks, "A1");
  79                         Assert.AreEqual ("1", csc.BaseAddress, "A2");
  80                         Assert.AreEqual (true, csc.CheckForOverflowUnderflow, "A3");
  81                         Assert.AreEqual ("2", csc.DisabledWarnings, "A4");
  82                         Assert.AreEqual ("3", csc.DocumentationFile, "A5");
  83                         Assert.AreEqual ("4", csc.ErrorReport, "A6");
  84                         Assert.AreEqual (true, csc.GenerateFullPaths, "A7");
  85                         Assert.AreEqual ("5", csc.LangVersion, "A8");
  86                         Assert.AreEqual ("6", csc.ModuleAssemblyName, "A9");
  87                         Assert.AreEqual ("7", csc.PdbFile, "A10");
  88                         Assert.AreEqual ("8", csc.Platform, "A11");
  89                         Assert.AreEqual (true, csc.UseHostCompilerIfAvailable, "A12");
  90                         Assert.AreEqual (9, csc.WarningLevel, "A13");
  91                         Assert.AreEqual ("10", csc.WarningsAsErrors, "A14");
  92                         Assert.AreEqual ("11", csc.WarningsNotAsErrors, "A15");
  93                 }
  94
  95                 [Test]
  96                 public void TestDefaultValues ()
  97                 {
  98                         Csc csc = new Csc ();
  99
 100                         Assert.IsFalse (csc.AllowUnsafeBlocks, "A1");
 101                         Assert.IsNull (csc.BaseAddress, "A2");
 102                         Assert.IsFalse (csc.CheckForOverflowUnderflow, "A3");
 103                         Assert.IsNull (csc.DisabledWarnings, "A4");
 104                         Assert.IsNull (csc.DocumentationFile, "A5");
 105                         Assert.IsNull (csc.ErrorReport, "A6");
 106                         Assert.IsFalse (csc.GenerateFullPaths, "A7");
 107                         Assert.IsNull (csc.LangVersion, "A8");
 108                         Assert.IsNull (csc.ModuleAssemblyName, "A9");
 109                         Assert.IsNull (csc.PdbFile, "A10");
 110                         Assert.IsNull (csc.Platform, "A11");
 111                         Assert.IsFalse (csc.UseHostCompilerIfAvailable, "A12");
 112                         Assert.AreEqual (4, csc.WarningLevel, "A13");
 113                         Assert.IsNull (csc.WarningsAsErrors, "A14");
 114                         Assert.IsNull (csc.WarningsNotAsErrors, "A15");
 115                 }
 116
 117         #region CscSpecificVariables
 118
 119                 [Test]
 120                 public void TestAllowUnsafeBlocks1 ()
 121                 {
 122                         CscExtended csc = new CscExtended ();
 123                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 124
 125                         csc.AllowUnsafeBlocks = true;
 126                         csc.ARFC (clbe);
 127
 128                         Assert.AreEqual ("/unsafe+", clbe.ToString (), "A1");
 129                 }
 130
 131                 [Test]
 132                 public void TestAllowUnsafeBlocks2 ()
 133                 {
 134                         CscExtended csc = new CscExtended ();
 135                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 136
 137                         csc.AllowUnsafeBlocks = false;
 138                         csc.ARFC (clbe);
 139
 140                         Assert.AreEqual ("/unsafe-", clbe.ToString (), "A1");
 141                 }
 142
 143                 [Test]
 144                 [Category ("NotWorking")]
 145                 public void TestBaseAddress ()
 146                 {
 147                         CscExtended csc = new CscExtended ();
 148                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 149
 150                         csc.BaseAddress = "A";
 151                         csc.ARFC (clbe);
 152
 153                         Assert.AreEqual ("/baseaddress:A", clbe.ToString (), "A1");
 154                 }
 155
 156                 [Test]
 157                 public void TestCheckForOverflowUnderflow1 ()
 158                 {
 159                         CscExtended csc = new CscExtended ();
 160                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 161
 162                         csc.CheckForOverflowUnderflow = true;
 163                         csc.ARFC (clbe);
 164
 165                         Assert.AreEqual ("/checked+", clbe.ToString (), "A1");
 166                 }
 167
 168                 [Test]
 169                 public void TestCheckForOverflowUnderflow2 ()
 170                 {
 171                         CscExtended csc = new CscExtended ();
 172                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 173
 174                         csc.CheckForOverflowUnderflow = false;
 175                         csc.ARFC (clbe);
 176
 177                         Assert.AreEqual ("/checked-", clbe.ToString (), "A1");
 178                 }
 179
 180                 [Test]
 181                 public void TestDisabledWarnings ()
 182                 {
 183                         CscExtended csc = new CscExtended ();
 184                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 185
 186                         csc.DisabledWarnings = "A";
 187                         csc.ARFC (clbe);
 188
 189                         Assert.AreEqual ("/nowarn:A", clbe.ToString (), "A1");
 190                 }
 191
 192                 [Test]
 193                 public void TestDisabledWarningsComma ()
 194                 {
 195                         CscExtended csc = new CscExtended ();
 196                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 197
 198                         csc.DisabledWarnings = "A, B";
 199                         csc.ARFC (clbe);
 200
 201                         Assert.AreEqual ("/nowarn:A;B", clbe.ToString (), "A1");
 202                 }
 203
 204                 [Test]
 205                 public void TestDocumentationFile ()
 206                 {
 207                         CscExtended csc = new CscExtended ();
 208                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 209
 210                         csc.DocumentationFile = "A";
 211                         csc.ARFC (clbe);
 212
 213                         Assert.AreEqual ("/doc:A", clbe.ToString (), "A1");
 214                 }
 215
 216                 [Test]
 217                 [Category ("NotWorking")]
 218                 public void TestErrorReport ()
 219                 {
 220                         CscExtended csc = new CscExtended ();
 221                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 222
 223                         csc.ErrorReport = "A";
 224                         csc.ARFC (clbe);
 225
 226                         Assert.AreEqual ("/errorreport:A", clbe.ToString (), "A1");
 227                 }
 228
 229                 [Test]
 230                 public void TestGenerateFullPaths1 ()
 231                 {
 232                         CscExtended csc = new CscExtended ();
 233                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 234
 235                         csc.GenerateFullPaths = true;
 236                         csc.ARFC (clbe);
 237
 238                         Assert.AreEqual ("/fullpaths", clbe.ToString (), "A1");
 239                 }
 240
 241                 [Test]
 242                 public void TestGenerateFullPaths2 ()
 243                 {
 244                         CscExtended csc = new CscExtended ();
 245                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 246
 247                         csc.GenerateFullPaths = false;
 248                         csc.ARFC (clbe);
 249
 250                         Assert.AreEqual ("", clbe.ToString (), "A1");
 251                 }
 252
 253                 [Test]
 254                 public void TestLangVersion ()
 255                 {
 256                         CscExtended csc = new CscExtended ();
 257                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 258
 259                         csc.LangVersion = "A'B";
 260                         csc.ARFC (clbe);
 261
 262                         Assert.AreEqual ("/langversion:\"A'B\"", clbe.ToString (), "A1");
 263                 }
 264
 265                 [Test]
 266                 [Category ("NotWorking")]
 267                 public void TestModuleAssemblyName ()
 268                 {
 269                         CscExtended csc = new CscExtended ();
 270                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 271
 272                         csc.ModuleAssemblyName = "A'B";
 273                         csc.ARFC (clbe);
 274
 275                         Assert.AreEqual ("/moduleassemblyname:\"A'B\"", clbe.ToString (), "A1");
 276                 }
 277
 278                 [Test]
 279                 [Category ("NotWorking")]
 280                 public void TestPdbFile ()
 281                 {
 282                         CscExtended csc = new CscExtended ();
 283                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 284
 285                         csc.PdbFile = "A";
 286                         csc.ARFC (clbe);
 287
 288                         Assert.AreEqual ("/pdb:A", clbe.ToString (), "A1");
 289                 }
 290
 291                 [Test]
 292                 [Category ("NotWorking")]
 293                 public void TestPlatform ()
 294                 {
 295                         CscExtended csc = new CscExtended ();
 296                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 297
 298                         csc.Platform = "A";
 299                         csc.ARFC (clbe);
 300
 301                         Assert.AreEqual ("/platform:A", clbe.ToString (), "A1");
 302                 }
 303
 304                 [Test]
 305                 public void TestWarning ()
 306                 {
 307                         CscExtended csc = new CscExtended ();
 308                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 309
 310                         csc.WarningLevel = 4;
 311                         csc.ARFC (clbe);
 312
 313                         Assert.AreEqual ("/warn:4", clbe.ToString (), "A1");
 314                 }
 315
 316                 [Test]
 317                 public void TestWarningAsErrors ()
 318                 {
 319                         CscExtended csc = new CscExtended ();
 320                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 321
 322                         csc.WarningsAsErrors = "A'B";
 323                         csc.ARFC (clbe);
 324
 325                         Assert.AreEqual ("/warnaserror+:\"A'B\"", clbe.ToString (), "A1");
 326                 }
 327                 [Test]
 328                 public void TestWarningNotAsErrors ()
 329                 {
 330                         CscExtended csc = new CscExtended ();
 331                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 332
 333                         csc.WarningsNotAsErrors = "A'B";
 334                         csc.ARFC (clbe);
 335
 336                         Assert.AreEqual ("/warnaserror-:\"A'B\"", clbe.ToString (), "A1");
 337                 }
 338
 339         #endregion
 340
 341                 [Test]
 342                 public void TestAdditionalLibPaths ()
 343                 {
 344                         CscExtended csc = new CscExtended ();
 345                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 346                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 347
 348                         csc.AdditionalLibPaths = new string [2] { "A'Foo", "B" };
 349                         csc.ARFC (c1);
 350                         csc.ACLC (c2);
 351
 352                         Assert.AreEqual ("/lib:\"A'Foo\",B", c1.ToString (), "A1");
 353                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 354                 }
 355
 356                 // Behavior for this intentionally differs from .net .
 357                 // msbuild doesn't quote the define args, but we do
 358                 // that to make it easier to copy/paste and execute
 359                 // compiler command lines, helps in debugging.
 360                 [Category ("NotDotNet")]
 361                 [Test]
 362                 public void TestDefineConstants ()
 363                 {
 364                         CscExtended csc = new CscExtended ();
 365                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 366                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 367
 368                         csc.DefineConstants = "A;B;;CD;;;Foo  Bar";
 369                         csc.ARFC (c1);
 370                         csc.ACLC (c2);
 371
 372                         Assert.AreEqual ("/define:\"A;B;CD;Foo;Bar\"", c1.ToString (), "A1");
 373                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 374                 }
 375
 376                 [Test]
 377                 public void TestDefineConstants2 ()
 378                 {
 379                         CscExtended csc = new CscExtended ();
 380                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 381                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 382
 383                         csc.DefineConstants = ";;;";
 384                         csc.ARFC (c1);
 385                         csc.ACLC (c2);
 386
 387                         Assert.AreEqual (String.Empty, c1.ToString (), "A1");
 388                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 389                 }
 390
 391                 [Test]
 392                 public void TestMainEntryPoint ()
 393                 {
 394                         CscExtended csc = new CscExtended ();
 395                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 396                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 397
 398                         csc.MainEntryPoint = "A;B";
 399                         csc.ARFC (c1);
 400                         csc.ACLC (c2);
 401
 402                         Assert.AreEqual ("/main:\"A;B\"", c1.ToString (), "A1");
 403                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 404                 }
 405
 406                 [Test]
 407                 public void TestReferences ()
 408                 {
 409                         CscExtended csc = new CscExtended ();
 410                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 411                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 412
 413                         csc.References = new ITaskItem [2] { new TaskItem ("A;C"), new TaskItem ("B") };
 414                         csc.ARFC (c1);
 415                         csc.ACLC (c2);
 416
 417                         Assert.AreEqual ("/reference:\"A;C\" /reference:B", c1.ToString (), "A1");
 418                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 419                 }
 420
 421                 [Test]
 422                 public void TestResponseFiles ()
 423                 {
 424                         CscExtended csc = new CscExtended ();
 425                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 426                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 427
 428                         csc.ResponseFiles = new ITaskItem [2] { new TaskItem ("A\'Foo"), new TaskItem ("B") };
 429                         csc.ARFC (c1);
 430                         csc.ACLC (c2);
 431
 432                         Assert.AreEqual ("@\"A'Foo\" @B", c1.ToString (), "A1");
 433                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 434                 }
 435
 436                 [Test]
 437                 public void TestWin32Resource ()
 438                 {
 439                         CscExtended csc = new CscExtended ();
 440                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 441                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 442
 443                         csc.Win32Resource = "A;B";
 444                         csc.ARFC (c1);
 445                         csc.ACLC (c2);
 446
 447                         Assert.AreEqual ("/win32res:\"A;B\"", c1.ToString (), "A1");
 448                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 449                 }
 450         }
 451 }