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 TestDocumentationFile ()
 194                 {
 195                         CscExtended csc = new CscExtended ();
 196                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 197
 198                         csc.DocumentationFile = "A";
 199                         csc.ARFC (clbe);
 200
 201                         Assert.AreEqual ("/doc:A", clbe.ToString (), "A1");
 202                 }
 203
 204                 [Test]
 205                 [Category ("NotWorking")]
 206                 public void TestErrorReport ()
 207                 {
 208                         CscExtended csc = new CscExtended ();
 209                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 210
 211                         csc.ErrorReport = "A";
 212                         csc.ARFC (clbe);
 213
 214                         Assert.AreEqual ("/errorreport:A", clbe.ToString (), "A1");
 215                 }
 216
 217                 [Test]
 218                 public void TestGenerateFullPaths1 ()
 219                 {
 220                         CscExtended csc = new CscExtended ();
 221                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 222
 223                         csc.GenerateFullPaths = true;
 224                         csc.ARFC (clbe);
 225
 226                         Assert.AreEqual ("/fullpaths", clbe.ToString (), "A1");
 227                 }
 228
 229                 [Test]
 230                 public void TestGenerateFullPaths2 ()
 231                 {
 232                         CscExtended csc = new CscExtended ();
 233                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 234
 235                         csc.GenerateFullPaths = false;
 236                         csc.ARFC (clbe);
 237
 238                         Assert.AreEqual ("", clbe.ToString (), "A1");
 239                 }
 240
 241                 [Test]
 242                 public void TestLangVersion ()
 243                 {
 244                         CscExtended csc = new CscExtended ();
 245                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 246
 247                         csc.LangVersion = "A'B";
 248                         csc.ARFC (clbe);
 249
 250                         Assert.AreEqual ("/langversion:\"A'B\"", clbe.ToString (), "A1");
 251                 }
 252
 253                 [Test]
 254                 [Category ("NotWorking")]
 255                 public void TestModuleAssemblyName ()
 256                 {
 257                         CscExtended csc = new CscExtended ();
 258                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 259
 260                         csc.ModuleAssemblyName = "A'B";
 261                         csc.ARFC (clbe);
 262
 263                         Assert.AreEqual ("/moduleassemblyname:\"A'B\"", clbe.ToString (), "A1");
 264                 }
 265
 266                 [Test]
 267                 [Category ("NotWorking")]
 268                 public void TestPdbFile ()
 269                 {
 270                         CscExtended csc = new CscExtended ();
 271                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 272
 273                         csc.PdbFile = "A";
 274                         csc.ARFC (clbe);
 275
 276                         Assert.AreEqual ("/pdb:A", clbe.ToString (), "A1");
 277                 }
 278
 279                 [Test]
 280                 [Category ("NotWorking")]
 281                 public void TestPlatform ()
 282                 {
 283                         CscExtended csc = new CscExtended ();
 284                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 285
 286                         csc.Platform = "A";
 287                         csc.ARFC (clbe);
 288
 289                         Assert.AreEqual ("/platform:A", clbe.ToString (), "A1");
 290                 }
 291
 292                 [Test]
 293                 public void TestWarning ()
 294                 {
 295                         CscExtended csc = new CscExtended ();
 296                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 297
 298                         csc.WarningLevel = 4;
 299                         csc.ARFC (clbe);
 300
 301                         Assert.AreEqual ("/warn:4", clbe.ToString (), "A1");
 302                 }
 303
 304                 [Test]
 305                 public void TestWarningAsErrors ()
 306                 {
 307                         CscExtended csc = new CscExtended ();
 308                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 309
 310                         csc.WarningsAsErrors = "A'B";
 311                         csc.ARFC (clbe);
 312
 313                         Assert.AreEqual ("/warnaserror+:\"A'B\"", clbe.ToString (), "A1");
 314                 }
 315                 [Test]
 316                 public void TestWarningNotAsErrors ()
 317                 {
 318                         CscExtended csc = new CscExtended ();
 319                         CommandLineBuilderExtension clbe = new CommandLineBuilderExtension ();
 320
 321                         csc.WarningsNotAsErrors = "A'B";
 322                         csc.ARFC (clbe);
 323
 324                         Assert.AreEqual ("/warnaserror-:\"A'B\"", clbe.ToString (), "A1");
 325                 }
 326
 327         #endregion
 328
 329                 [Test]
 330                 public void TestAdditionalLibPaths ()
 331                 {
 332                         CscExtended csc = new CscExtended ();
 333                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 334                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 335
 336                         csc.AdditionalLibPaths = new string [2] { "A'Foo", "B" };
 337                         csc.ARFC (c1);
 338                         csc.ACLC (c2);
 339
 340                         Assert.AreEqual ("/lib:\"A'Foo\",B", c1.ToString (), "A1");
 341                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 342                 }
 343
 344                 // Behavior for this intentionally differs from .net .
 345                 // msbuild doesn't quote the define args, but we do
 346                 // that to make it easier to copy/paste and execute
 347                 // compiler command lines, helps in debugging.
 348                 [Category ("NotDotNet")]
 349                 [Test]
 350                 public void TestDefineConstants ()
 351                 {
 352                         CscExtended csc = new CscExtended ();
 353                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 354                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 355
 356                         csc.DefineConstants = "A;B;;CD;;;Foo  Bar";
 357                         csc.ARFC (c1);
 358                         csc.ACLC (c2);
 359
 360                         Assert.AreEqual ("/define:\"A;B;CD;Foo;Bar\"", c1.ToString (), "A1");
 361                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 362                 }
 363
 364                 [Test]
 365                 public void TestDefineConstants2 ()
 366                 {
 367                         CscExtended csc = new CscExtended ();
 368                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 369                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 370
 371                         csc.DefineConstants = ";;;";
 372                         csc.ARFC (c1);
 373                         csc.ACLC (c2);
 374
 375                         Assert.AreEqual (String.Empty, c1.ToString (), "A1");
 376                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 377                 }
 378
 379                 [Test]
 380                 public void TestMainEntryPoint ()
 381                 {
 382                         CscExtended csc = new CscExtended ();
 383                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 384                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 385
 386                         csc.MainEntryPoint = "A;B";
 387                         csc.ARFC (c1);
 388                         csc.ACLC (c2);
 389
 390                         Assert.AreEqual ("/main:\"A;B\"", c1.ToString (), "A1");
 391                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 392                 }
 393
 394                 [Test]
 395                 public void TestReferences ()
 396                 {
 397                         CscExtended csc = new CscExtended ();
 398                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 399                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 400
 401                         csc.References = new ITaskItem [2] { new TaskItem ("A;C"), new TaskItem ("B") };
 402                         csc.ARFC (c1);
 403                         csc.ACLC (c2);
 404
 405                         Assert.AreEqual ("/reference:\"A;C\" /reference:B", c1.ToString (), "A1");
 406                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 407                 }
 408
 409                 [Test]
 410                 public void TestResponseFiles ()
 411                 {
 412                         CscExtended csc = new CscExtended ();
 413                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 414                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 415
 416                         csc.ResponseFiles = new ITaskItem [2] { new TaskItem ("A\'Foo"), new TaskItem ("B") };
 417                         csc.ARFC (c1);
 418                         csc.ACLC (c2);
 419
 420                         Assert.AreEqual ("@\"A'Foo\" @B", c1.ToString (), "A1");
 421                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 422                 }
 423
 424                 [Test]
 425                 public void TestWin32Resource ()
 426                 {
 427                         CscExtended csc = new CscExtended ();
 428                         CommandLineBuilderExtension c1 = new CommandLineBuilderExtension ();
 429                         CommandLineBuilderExtension c2 = new CommandLineBuilderExtension ();
 430
 431                         csc.Win32Resource = "A;B";
 432                         csc.ARFC (c1);
 433                         csc.ACLC (c2);
 434
 435                         Assert.AreEqual ("/win32res:\"A;B\"", c1.ToString (), "A1");
 436                         Assert.AreEqual (String.Empty, c2.ToString (), "A2");
 437                 }
 438         }
 439 }