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