mcs/class/System/Test/Microsoft.CSharp/CodeGeneratorFromNamespaceTest.cs

   1 //
   2 // Microsoft.CSharp.* Test Cases
   3 //
   4 // Authors:
   5 //      Erik LeBel (eriklebel@yahoo.ca)
   6 //
   7 // (c) 2003 Erik LeBel
   8 //
   9 using System;
  10 using System.CodeDom;
  11 using System.CodeDom.Compiler;
  12 using System.Globalization;
  13 using System.IO;
  14 using System.Text;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.Microsoft.CSharp
  19 {
  20         /// <summary>
  21         /// Test ICodeGenerator's GenerateCodeFromNamespace, along with a
  22         /// minimal set CodeDom components.
  23         /// </summary>
  24         [TestFixture]
  25         public class CodeGeneratorFromNamespaceTest : CodeGeneratorTestBase
  26         {
  27                 CodeNamespace codeNamespace;
  28
  29                 [SetUp]
  30                 public void Init ()
  31                 {
  32                         InitBase ();
  33                         codeNamespace = new CodeNamespace ();
  34                 }
  35
  36                 protected override string Generate (CodeGeneratorOptions options)
  37                 {
  38                         StringWriter writer = new StringWriter ();
  39                         writer.NewLine = NewLine;
  40
  41                         generator.GenerateCodeFromNamespace (codeNamespace, writer, options);
  42                         writer.Close ();
  43                         return writer.ToString ();
  44                 }
  45
  46                 [Test]
  47                 [ExpectedException (typeof (NullReferenceException))]
  48                 public void NullNamespaceTest ()
  49                 {
  50                         codeNamespace = null;
  51                         Generate ();
  52                 }
  53
  54                 [Test]
  55                 public void NullNamespaceNameTest ()
  56                 {
  57                         codeNamespace.Name = null;
  58                         Assert.AreEqual ("\n", Generate ());
  59                 }
  60
  61
  62                 [Test]
  63                 public void DefaultNamespaceTest ()
  64                 {
  65                         Assert.AreEqual ("\n", Generate ());
  66                 }
  67
  68                 [Test]
  69                 public void SimpleNamespaceTest ()
  70                 {
  71                         string code = null;
  72
  73                         codeNamespace.Name = "A";
  74                         code = Generate ();
  75                         Assert.AreEqual ("namespace A {\n    \n}\n", code, "#1");
  76
  77                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
  78                         options.BracingStyle = "C";
  79                         code = Generate (options);
  80                         Assert.AreEqual ("namespace A\n{\n    \n}\n", code, "#2");
  81                 }
  82
  83                 [Test]
  84                 public void InvalidNamespaceTest ()
  85                 {
  86                         codeNamespace.Name = "A,B";
  87                         Assert.AreEqual ("namespace A,B {\n    \n}\n", Generate ());
  88                 }
  89
  90                 [Test]
  91                 public void CommentOnlyNamespaceTest ()
  92                 {
  93                         CodeCommentStatement comment = new CodeCommentStatement ("a");
  94                         codeNamespace.Comments.Add (comment);
  95                         Assert.AreEqual ("// a\n\n", Generate ());
  96                 }
  97
  98                 [Test]
  99                 public void ImportsTest ()
 100                 {
 101                         codeNamespace.Imports.Add (new CodeNamespaceImport ("System"));
 102                         codeNamespace.Imports.Add (new CodeNamespaceImport ("System.Collections"));
 103
 104                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 105                                 "using System;{0}" +
 106                                 "using System.Collections;{0}" +
 107                                 "{0}", NewLine), Generate (), "#1");
 108
 109                         codeNamespace.Name = "A";
 110
 111                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 112                                 "namespace A {{{0}" +
 113                                 "    using System;{0}" +
 114                                 "    using System.Collections;{0}" +
 115                                 "    {0}" +
 116                                 "}}{0}", NewLine), Generate (), "#2");
 117
 118                         codeNamespace.Name = null;
 119                         codeNamespace.Comments.Add (new CodeCommentStatement ("a"));
 120
 121                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 122                                 "// a{0}" +
 123                                 "using System;{0}" +
 124                                 "using System.Collections;{0}" +
 125                                 "{0}", NewLine), Generate (), "#3");
 126
 127                         codeNamespace.Name = "A";
 128
 129                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 130                                 "// a{0}" +
 131                                 "namespace A {{{0}" +
 132                                 "    using System;{0}" +
 133                                 "    using System.Collections;{0}" +
 134                                 "    {0}" +
 135                                 "}}{0}", NewLine), Generate (), "#4");
 136                 }
 137
 138                 [Test]
 139                 public void TypeTest ()
 140                 {
 141                         codeNamespace.Types.Add (new CodeTypeDeclaration ("Person"));
 142                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 143                                 "{0}" +
 144                                 "{0}" +
 145                                 "public class Person {{{0}" +
 146                                 "}}{0}", NewLine), Generate (), "#A1");
 147
 148                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
 149                         options.BlankLinesBetweenMembers = false;
 150                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 151                                 "{0}" +
 152                                 "public class Person {{{0}" +
 153                                 "}}{0}", NewLine), Generate (options), "#A2");
 154
 155                         codeNamespace.Name = "A";
 156                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 157                                 "namespace A {{{0}" +
 158                                 "    {0}" +
 159                                 "    {0}" +
 160                                 "    public class Person {{{0}" +
 161                                 "    }}{0}" +
 162                                 "}}{0}", NewLine), Generate (), "#B1");
 163
 164                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 165                                 "namespace A {{{0}" +
 166                                 "    {0}" +
 167                                 "    public class Person {{{0}" +
 168                                 "    }}{0}" +
 169                                 "}}{0}", NewLine), Generate (options), "#B2");
 170                 }
 171
 172 #if NET_2_0
 173                 [Test]
 174                 public void Type_TypeParameters ()
 175                 {
 176                         codeNamespace.Name = "SomeNS";
 177
 178                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 179                         codeNamespace.Types.Add (type);
 180                         type.TypeParameters.Add (new CodeTypeParameter ("T"));
 181
 182                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 183                                 "namespace SomeNS {{{0}" +
 184                                 "    {0}" +
 185                                 "    {0}" +
 186                                 "    public class SomeClass<T>{0}" +
 187                                 "     {{{0}" +
 188                                 "    }}{0}" +
 189                                 "}}{0}", NewLine), Generate (), "#1");
 190
 191                         type.TypeParameters.Add (new CodeTypeParameter ("as"));
 192                         type.TypeParameters.Add (new CodeTypeParameter ("is"));
 193
 194                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 195                                 "namespace SomeNS {{{0}" +
 196                                 "    {0}" +
 197                                 "    {0}" +
 198                                 "    public class SomeClass<T, as, is>{0}" +
 199                                 "    {0}" +
 200                                 "    {0}" +
 201                                 "     {{{0}" +
 202                                 "    }}{0}" +
 203                                 "}}{0}", NewLine), Generate (), "#2");
 204
 205                         CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
 206                         typeParamR.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
 207                         type.TypeParameters.Add (typeParamR);
 208
 209                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 210                                 "namespace SomeNS {{{0}" +
 211                                 "    {0}" +
 212                                 "    {0}" +
 213                                 "    public class SomeClass<T, as, is, R>{0}" +
 214                                 "    {0}" +
 215                                 "    {0}" +
 216                                 "    {0}" +
 217                                 "        where R : System.IComparable {{{0}" +
 218                                 "    }}{0}" +
 219                                 "}}{0}", NewLine), Generate (), "#3");
 220
 221                         type.TypeParameters.Add (new CodeTypeParameter ("S"));
 222
 223                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 224                                 "namespace SomeNS {{{0}" +
 225                                 "    {0}" +
 226                                 "    {0}" +
 227                                 "    public class SomeClass<T, as, is, R, S>{0}" +
 228                                 "    {0}" +
 229                                 "    {0}" +
 230                                 "    {0}" +
 231                                 "        where R : System.IComparable{0}" +
 232                                 "     {{{0}" +
 233                                 "    }}{0}" +
 234                                 "}}{0}", NewLine), Generate (), "#4");
 235                 }
 236
 237
 238                 [Test]
 239                 public void Type_TypeParameters_Constraints ()
 240                 {
 241                         codeNamespace.Name = "SomeNS";
 242
 243                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 244                         codeNamespace.Types.Add (type);
 245
 246                         CodeTypeParameter typeParamT = new CodeTypeParameter ("T");
 247                         typeParamT.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
 248                         type.TypeParameters.Add (typeParamT);
 249
 250                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 251                                 "namespace SomeNS {{{0}" +
 252                                 "    {0}" +
 253                                 "    {0}" +
 254                                 "    public class SomeClass<T>{0}" +
 255                                 "        where T : System.IComparable {{{0}" +
 256                                 "    }}{0}" +
 257                                 "}}{0}", NewLine), Generate (), "#1");
 258
 259                         typeParamT.Constraints.Add (new CodeTypeReference (typeof (ICloneable)));
 260
 261                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 262                                 "namespace SomeNS {{{0}" +
 263                                 "    {0}" +
 264                                 "    {0}" +
 265                                 "    public class SomeClass<T>{0}" +
 266                                 "        where T : System.IComparable, System.ICloneable {{{0}" +
 267                                 "    }}{0}" +
 268                                 "}}{0}", NewLine), Generate (), "#2");
 269
 270                         typeParamT.HasConstructorConstraint = true;
 271
 272                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 273                                 "namespace SomeNS {{{0}" +
 274                                 "    {0}" +
 275                                 "    {0}" +
 276                                 "    public class SomeClass<T>{0}" +
 277                                 "        where T : System.IComparable, System.ICloneable, new () {{{0}" +
 278                                 "    }}{0}" +
 279                                 "}}{0}", NewLine), Generate (), "#3");
 280
 281                         CodeTypeParameter typeParamS = new CodeTypeParameter ("S");
 282                         typeParamS.Constraints.Add (new CodeTypeReference (typeof (IDisposable)));
 283                         type.TypeParameters.Add (typeParamS);
 284
 285                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 286                                 "namespace SomeNS {{{0}" +
 287                                 "    {0}" +
 288                                 "    {0}" +
 289                                 "    public class SomeClass<T, S>{0}" +
 290                                 "        where T : System.IComparable, System.ICloneable, new (){0}" +
 291                                 "        where S : System.IDisposable {{{0}" +
 292                                 "    }}{0}" +
 293                                 "}}{0}", NewLine), Generate (), "#4");
 294
 295                         CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
 296                         typeParamR.HasConstructorConstraint = true;
 297                         type.TypeParameters.Add (typeParamR);
 298
 299                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 300                                 "namespace SomeNS {{{0}" +
 301                                 "    {0}" +
 302                                 "    {0}" +
 303                                 "    public class SomeClass<T, S, R>{0}" +
 304                                 "        where T : System.IComparable, System.ICloneable, new (){0}" +
 305                                 "        where S : System.IDisposable{0}" +
 306                                 "        where R : new() {{{0}" +
 307                                 "    }}{0}" +
 308                                 "}}{0}", NewLine), Generate (), "#5");
 309                 }
 310
 311                 [Test]
 312                 public void Type_TypeParameters_ConstructorConstraint ()
 313                 {
 314                         codeNamespace.Name = "SomeNS";
 315
 316                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 317                         codeNamespace.Types.Add (type);
 318
 319                         CodeTypeParameter typeParam = new CodeTypeParameter ("T");
 320                         typeParam.HasConstructorConstraint = true;
 321                         type.TypeParameters.Add (typeParam);
 322
 323                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 324                                 "namespace SomeNS {{{0}" +
 325                                 "    {0}" +
 326                                 "    {0}" +
 327                                 "    public class SomeClass<T>{0}" +
 328                                 "        where T : new() {{{0}" +
 329                                 "    }}{0}" +
 330                                 "}}{0}", NewLine), Generate ());
 331                 }
 332
 333                 [Test]
 334                 public void Method_TypeParameters ()
 335                 {
 336                         codeNamespace.Name = "SomeNS";
 337
 338                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 339                         codeNamespace.Types.Add (type);
 340
 341                         CodeMemberMethod method = new CodeMemberMethod ();
 342                         method.Name = "SomeMethod";
 343                         type.Members.Add (method);
 344
 345                         method.TypeParameters.Add (new CodeTypeParameter ("T"));
 346
 347                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 348                                 "namespace SomeNS {{{0}" +
 349                                 "    {0}" +
 350                                 "    {0}" +
 351                                 "    public class SomeClass {{{0}" +
 352                                 "        {0}" +
 353                                 "        private void SomeMethod<T>(){0}" +
 354                                 "         {{{0}" +
 355                                 "        }}{0}" +
 356                                 "    }}{0}" +
 357                                 "}}{0}", NewLine), Generate (), "#1");
 358
 359                         method.TypeParameters.Add (new CodeTypeParameter ("as"));
 360                         method.TypeParameters.Add (new CodeTypeParameter ("is"));
 361
 362                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 363                                 "namespace SomeNS {{{0}" +
 364                                 "    {0}" +
 365                                 "    {0}" +
 366                                 "    public class SomeClass {{{0}" +
 367                                 "        {0}" +
 368                                 "        private void SomeMethod<T, as, is>(){0}" +
 369                                 "        {0}" +
 370                                 "        {0}" +
 371                                 "         {{{0}" +
 372                                 "        }}{0}" +
 373                                 "    }}{0}" +
 374                                 "}}{0}", NewLine), Generate (), "#2");
 375
 376                         CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
 377                         typeParamR.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
 378                         method.TypeParameters.Add (typeParamR);
 379
 380                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 381                                 "namespace SomeNS {{{0}" +
 382                                 "    {0}" +
 383                                 "    {0}" +
 384                                 "    public class SomeClass {{{0}" +
 385                                 "        {0}" +
 386                                 "        private void SomeMethod<T, as, is, R>(){0}" +
 387                                 "        {0}" +
 388                                 "        {0}" +
 389                                 "        {0}" +
 390                                 "            where R : System.IComparable {{{0}" +
 391                                 "        }}{0}" +
 392                                 "    }}{0}" +
 393                                 "}}{0}", NewLine), Generate (), "#3");
 394
 395                         method.TypeParameters.Add (new CodeTypeParameter ("S"));
 396
 397                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 398                                 "namespace SomeNS {{{0}" +
 399                                 "    {0}" +
 400                                 "    {0}" +
 401                                 "    public class SomeClass {{{0}" +
 402                                 "        {0}" +
 403                                 "        private void SomeMethod<T, as, is, R, S>(){0}" +
 404                                 "        {0}" +
 405                                 "        {0}" +
 406                                 "        {0}" +
 407                                 "            where R : System.IComparable{0}" +
 408                                 "         {{{0}" +
 409                                 "        }}{0}" +
 410                                 "    }}{0}" +
 411                                 "}}{0}", NewLine), Generate (), "#4");
 412                 }
 413
 414                 [Test]
 415                 public void Method_TypeParameters_Constraints ()
 416                 {
 417                         codeNamespace.Name = "SomeNS";
 418
 419                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 420                         codeNamespace.Types.Add (type);
 421
 422                         CodeMemberMethod method = new CodeMemberMethod ();
 423                         method.Name = "SomeMethod";
 424                         type.Members.Add (method);
 425
 426                         CodeTypeParameter typeParamT = new CodeTypeParameter ("T");
 427                         typeParamT.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
 428                         method.TypeParameters.Add (typeParamT);
 429
 430                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 431                                 "namespace SomeNS {{{0}" +
 432                                 "    {0}" +
 433                                 "    {0}" +
 434                                 "    public class SomeClass {{{0}" +
 435                                 "        {0}" +
 436                                 "        private void SomeMethod<T>(){0}" +
 437                                 "            where T : System.IComparable {{{0}" +
 438                                 "        }}{0}" +
 439                                 "    }}{0}" +
 440                                 "}}{0}", NewLine), Generate (), "#1");
 441
 442                         typeParamT.Constraints.Add (new CodeTypeReference (typeof (ICloneable)));
 443
 444                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 445                                 "namespace SomeNS {{{0}" +
 446                                 "    {0}" +
 447                                 "    {0}" +
 448                                 "    public class SomeClass {{{0}" +
 449                                 "        {0}" +
 450                                 "        private void SomeMethod<T>(){0}" +
 451                                 "            where T : System.IComparable, System.ICloneable {{{0}" +
 452                                 "        }}{0}" +
 453                                 "    }}{0}" +
 454                                 "}}{0}", NewLine), Generate (), "#2");
 455
 456                         typeParamT.HasConstructorConstraint = true;
 457
 458                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 459                                 "namespace SomeNS {{{0}" +
 460                                 "    {0}" +
 461                                 "    {0}" +
 462                                 "    public class SomeClass {{{0}" +
 463                                 "        {0}" +
 464                                 "        private void SomeMethod<T>(){0}" +
 465                                 "            where T : System.IComparable, System.ICloneable, new () {{{0}" +
 466                                 "        }}{0}" +
 467                                 "    }}{0}" +
 468                                 "}}{0}", NewLine), Generate (), "#3");
 469
 470                         CodeTypeParameter typeParamS = new CodeTypeParameter ("S");
 471                         typeParamS.Constraints.Add (new CodeTypeReference (typeof (IDisposable)));
 472                         method.TypeParameters.Add (typeParamS);
 473
 474                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 475                                 "namespace SomeNS {{{0}" +
 476                                 "    {0}" +
 477                                 "    {0}" +
 478                                 "    public class SomeClass {{{0}" +
 479                                 "        {0}" +
 480                                 "        private void SomeMethod<T, S>(){0}" +
 481                                 "            where T : System.IComparable, System.ICloneable, new (){0}" +
 482                                 "            where S : System.IDisposable {{{0}" +
 483                                 "        }}{0}" +
 484                                 "    }}{0}" +
 485                                 "}}{0}", NewLine), Generate (), "#4");
 486
 487                         CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
 488                         typeParamR.HasConstructorConstraint = true;
 489                         method.TypeParameters.Add (typeParamR);
 490
 491                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 492                                 "namespace SomeNS {{{0}" +
 493                                 "    {0}" +
 494                                 "    {0}" +
 495                                 "    public class SomeClass {{{0}" +
 496                                 "        {0}" +
 497                                 "        private void SomeMethod<T, S, R>(){0}" +
 498                                 "            where T : System.IComparable, System.ICloneable, new (){0}" +
 499                                 "            where S : System.IDisposable{0}" +
 500                                 "            where R : new() {{{0}" +
 501                                 "        }}{0}" +
 502                                 "    }}{0}" +
 503                                 "}}{0}", NewLine), Generate (), "#5");
 504                 }
 505
 506                 [Test] // bug #353921
 507                 public void Method_TypeParameters_ConstructorConstraint ()
 508                 {
 509                         codeNamespace.Name = "SomeNS";
 510
 511                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 512                         codeNamespace.Types.Add (type);
 513
 514                         CodeMemberMethod method = new CodeMemberMethod ();
 515                         method.Name = "SomeMethod";
 516                         type.Members.Add (method);
 517
 518                         CodeTypeParameter typeParam = new CodeTypeParameter ("T");
 519                         typeParam.HasConstructorConstraint = true;
 520                         method.TypeParameters.Add (typeParam);
 521
 522                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 523                                 "namespace SomeNS {{{0}" +
 524                                 "    {0}" +
 525                                 "    {0}" +
 526                                 "    public class SomeClass {{{0}" +
 527                                 "        {0}" +
 528                                 "        private void SomeMethod<T>(){0}" +
 529                                 "            where T : new() {{{0}" +
 530                                 "        }}{0}" +
 531                                 "    }}{0}" +
 532                                 "}}{0}", NewLine), Generate ());
 533                 }
 534 #endif
 535         }
 536 }