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

   1 //
   2 // Microsoft.VisualBasic.* Test Cases
   3 //
   4 // Authors:
   5 // Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (c) 2006 Novell
   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.VisualBasic
  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 = null;
  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                         codeNamespace.Name = "A";
  72                         Assert.AreEqual ("\nNamespace A\nEnd Namespace\n", Generate ());
  73                 }
  74
  75                 [Test]
  76                 public void InvalidNamespaceTest ()
  77                 {
  78                         codeNamespace.Name = "A,B";
  79                         Assert.AreEqual ("\nNamespace A,B\nEnd Namespace\n", Generate ());
  80                 }
  81
  82                 [Test]
  83                 public void CommentOnlyNamespaceTest ()
  84                 {
  85                         CodeCommentStatement comment = new CodeCommentStatement ("a");
  86                         codeNamespace.Comments.Add (comment);
  87                         Assert.AreEqual ("\n'a\n", Generate ());
  88                 }
  89
  90                 [Test]
  91                 public void ImportsTest ()
  92                 {
  93                         codeNamespace.Imports.Add (new CodeNamespaceImport ("System"));
  94                         codeNamespace.Imports.Add (new CodeNamespaceImport ("System.Collections"));
  95
  96                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
  97                                 "Imports System{0}" +
  98                                 "Imports System.Collections{0}" +
  99                                 "{0}", NewLine), Generate (), "#1");
 100
 101                         codeNamespace.Name = "A";
 102
 103                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 104                                 "Imports System{0}" +
 105                                 "Imports System.Collections{0}" +
 106                                 "{0}" +
 107                                 "Namespace A{0}" +
 108                                 "End Namespace{0}", NewLine), Generate (), "#2");
 109
 110                         codeNamespace.Name = null;
 111                         codeNamespace.Comments.Add (new CodeCommentStatement ("a"));
 112
 113                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 114                                 "Imports System{0}" +
 115                                 "Imports System.Collections{0}" +
 116                                 "{0}" +
 117                                 "'a{0}", NewLine), Generate (), "#3");
 118
 119                         codeNamespace.Name = "A";
 120
 121                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 122                                 "Imports System{0}" +
 123                                 "Imports System.Collections{0}" +
 124                                 "{0}" +
 125                                 "'a{0}" +
 126                                 "Namespace A{0}" +
 127                                 "End Namespace{0}", NewLine), Generate (), "#4");
 128                 }
 129
 130                 [Test]
 131                 public void TypeTest ()
 132                 {
 133                         codeNamespace.Types.Add (new CodeTypeDeclaration ("Person"));
 134                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 135                                 "{0}" +
 136                                 "{0}" +
 137                                 "Public Class Person{0}" +
 138                                 "End Class{0}", NewLine), Generate (), "#A1");
 139
 140                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
 141                         options.BlankLinesBetweenMembers = false;
 142                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 143                                 "{0}" +
 144                                 "Public Class Person{0}" +
 145                                 "End Class{0}", NewLine), Generate (options), "#A2");
 146
 147                         codeNamespace.Name = "A";
 148                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 149                                 "{0}" +
 150                                 "Namespace A{0}" +
 151                                 "    {0}" +
 152                                 "    Public Class Person{0}" +
 153                                 "    End Class{0}" +
 154                                 "End Namespace{0}", NewLine), Generate (), "#B1");
 155
 156                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 157                                 "{0}" +
 158                                 "Namespace A{0}" +
 159                                 "    Public Class Person{0}" +
 160                                 "    End Class{0}" +
 161                                 "End Namespace{0}", NewLine), Generate (options), "#B2");
 162                 }
 163
 164 #if NET_2_0
 165                 [Test]
 166                 public void Type_TypeParameters ()
 167                 {
 168                         codeNamespace.Name = "SomeNS";
 169
 170                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 171                         codeNamespace.Types.Add (type);
 172                         type.TypeParameters.Add (new CodeTypeParameter ("T"));
 173
 174                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 175                                 "{0}" +
 176                                 "Namespace SomeNS{0}" +
 177                                 "    {0}" +
 178                                 "    Public Class SomeClass(Of T){0}" +
 179                                 "    End Class{0}" +
 180                                 "End Namespace{0}", NewLine), Generate (), "#1");
 181
 182                         type.TypeParameters.Add (new CodeTypeParameter ("As"));
 183                         type.TypeParameters.Add (new CodeTypeParameter ("New"));
 184
 185                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 186                                 "{0}" +
 187                                 "Namespace SomeNS{0}" +
 188                                 "    {0}" +
 189                                 "    Public Class SomeClass(Of T, As, New){0}" +
 190                                 "    End Class{0}" +
 191                                 "End Namespace{0}", NewLine), Generate (), "#2");
 192
 193                         CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
 194                         typeParamR.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
 195                         type.TypeParameters.Add (typeParamR);
 196
 197                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 198                                 "{0}" +
 199                                 "Namespace SomeNS{0}" +
 200                                 "    {0}" +
 201                                 "    Public Class SomeClass(Of T, As, New, R As System.IComparable){0}" +
 202                                 "    End Class{0}" +
 203                                 "End Namespace{0}", NewLine), Generate (), "#3");
 204
 205                         type.TypeParameters.Add (new CodeTypeParameter ("S"));
 206
 207                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 208                                 "{0}" +
 209                                 "Namespace SomeNS{0}" +
 210                                 "    {0}" +
 211                                 "    Public Class SomeClass(Of T, As, New, R As System.IComparable, S){0}" +
 212                                 "    End Class{0}" +
 213                                 "End Namespace{0}", NewLine), Generate (), "#4");
 214                 }
 215
 216                 [Test]
 217                 public void Type_TypeParameters_Constraints ()
 218                 {
 219                         codeNamespace.Name = "SomeNS";
 220
 221                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 222                         codeNamespace.Types.Add (type);
 223
 224                         CodeTypeParameter typeParamT = new CodeTypeParameter ("T");
 225                         typeParamT.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
 226                         type.TypeParameters.Add (typeParamT);
 227
 228                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 229                                 "{0}" +
 230                                 "Namespace SomeNS{0}" +
 231                                 "    {0}" +
 232                                 "    Public Class SomeClass(Of T As System.IComparable){0}" +
 233                                 "    End Class{0}" +
 234                                 "End Namespace{0}", NewLine), Generate (), "#1");
 235
 236                         typeParamT.Constraints.Add (new CodeTypeReference (typeof (ICloneable)));
 237
 238                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 239                                 "{0}" +
 240                                 "Namespace SomeNS{0}" +
 241                                 "    {0}" +
 242                                 "    Public Class SomeClass(Of T As  {{System.IComparable, System.ICloneable}}){0}" +
 243                                 "    End Class{0}" +
 244                                 "End Namespace{0}", NewLine), Generate (), "#2");
 245
 246                         typeParamT.HasConstructorConstraint = true;
 247
 248                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 249                                 "{0}" +
 250                                 "Namespace SomeNS{0}" +
 251                                 "    {0}" +
 252                                 "    Public Class SomeClass(Of T As  {{System.IComparable, System.ICloneable, New}}){0}" +
 253                                 "    End Class{0}" +
 254                                 "End Namespace{0}", NewLine), Generate (), "#3");
 255
 256                         CodeTypeParameter typeParamS = new CodeTypeParameter ("S");
 257                         typeParamS.Constraints.Add (new CodeTypeReference (typeof (IDisposable)));
 258                         type.TypeParameters.Add (typeParamS);
 259
 260                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 261                                 "{0}" +
 262                                 "Namespace SomeNS{0}" +
 263                                 "    {0}" +
 264                                 "    Public Class SomeClass(Of T As  {{System.IComparable, System.ICloneable, New}}, S As System.IDisposable){0}" +
 265                                 "    End Class{0}" +
 266                                 "End Namespace{0}", NewLine), Generate (), "#4");
 267
 268                         CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
 269                         typeParamR.HasConstructorConstraint = true;
 270                         type.TypeParameters.Add (typeParamR);
 271
 272                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 273                                 "{0}" +
 274                                 "Namespace SomeNS{0}" +
 275                                 "    {0}" +
 276                                 "    Public Class SomeClass(Of T As  {{System.IComparable, System.ICloneable, New}}, S As System.IDisposable, R As New){0}" +
 277                                 "    End Class{0}" +
 278                                 "End Namespace{0}", NewLine), Generate (), "#5");
 279                 }
 280
 281                 [Test]
 282                 public void Type_TypeParameters_ConstructorConstraint ()
 283                 {
 284                         codeNamespace.Name = "SomeNS";
 285
 286                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 287                         codeNamespace.Types.Add (type);
 288
 289                         CodeTypeParameter typeParam = new CodeTypeParameter ("T");
 290                         typeParam.HasConstructorConstraint = true;
 291                         type.TypeParameters.Add (typeParam);
 292
 293                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 294                                 "{0}" +
 295                                 "Namespace SomeNS{0}" +
 296                                 "    {0}" +
 297                                 "    Public Class SomeClass(Of T As New){0}" +
 298                                 "    End Class{0}" +
 299                                 "End Namespace{0}", NewLine), Generate ());
 300                 }
 301
 302                 [Test]
 303                 public void Method_TypeParameters ()
 304                 {
 305                         codeNamespace.Name = "SomeNS";
 306
 307                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 308                         codeNamespace.Types.Add (type);
 309
 310                         CodeMemberMethod method = new CodeMemberMethod ();
 311                         method.Name = "SomeMethod";
 312                         type.Members.Add (method);
 313
 314                         method.TypeParameters.Add (new CodeTypeParameter ("T"));
 315
 316                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 317                                 "{0}" +
 318                                 "Namespace SomeNS{0}" +
 319                                 "    {0}" +
 320                                 "    Public Class SomeClass{0}" +
 321                                 "        {0}" +
 322                                 "        Private Sub SomeMethod(Of T)(){0}" +
 323                                 "        End Sub{0}" +
 324                                 "    End Class{0}" +
 325                                 "End Namespace{0}", NewLine), Generate (), "#1");
 326
 327                         method.TypeParameters.Add (new CodeTypeParameter ("As"));
 328                         method.TypeParameters.Add (new CodeTypeParameter ("New"));
 329
 330                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 331                                 "{0}" +
 332                                 "Namespace SomeNS{0}" +
 333                                 "    {0}" +
 334                                 "    Public Class SomeClass{0}" +
 335                                 "        {0}" +
 336                                 "        Private Sub SomeMethod(Of T, As, New)(){0}" +
 337                                 "        End Sub{0}" +
 338                                 "    End Class{0}" +
 339                                 "End Namespace{0}", NewLine), Generate (), "#2");
 340
 341                         CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
 342                         typeParamR.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
 343                         method.TypeParameters.Add (typeParamR);
 344
 345                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 346                                 "{0}" +
 347                                 "Namespace SomeNS{0}" +
 348                                 "    {0}" +
 349                                 "    Public Class SomeClass{0}" +
 350                                 "        {0}" +
 351                                 "        Private Sub SomeMethod(Of T, As, New, R As System.IComparable)(){0}" +
 352                                 "        End Sub{0}" +
 353                                 "    End Class{0}" +
 354                                 "End Namespace{0}", NewLine), Generate (), "#3");
 355
 356                         method.TypeParameters.Add (new CodeTypeParameter ("S"));
 357
 358                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 359                                 "{0}" +
 360                                 "Namespace SomeNS{0}" +
 361                                 "    {0}" +
 362                                 "    Public Class SomeClass{0}" +
 363                                 "        {0}" +
 364                                 "        Private Sub SomeMethod(Of T, As, New, R As System.IComparable, S)(){0}" +
 365                                 "        End Sub{0}" +
 366                                 "    End Class{0}" +
 367                                 "End Namespace{0}", NewLine), Generate (), "#4");
 368                 }
 369
 370                 [Test]
 371                 public void Method_TypeParameters_Constraints ()
 372                 {
 373                         codeNamespace.Name = "SomeNS";
 374
 375                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 376                         codeNamespace.Types.Add (type);
 377
 378                         CodeMemberMethod method = new CodeMemberMethod ();
 379                         method.Name = "SomeMethod";
 380                         type.Members.Add (method);
 381
 382                         CodeTypeParameter typeParamT = new CodeTypeParameter ("T");
 383                         typeParamT.Constraints.Add (new CodeTypeReference (typeof (IComparable)));
 384                         method.TypeParameters.Add (typeParamT);
 385
 386                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 387                                 "{0}" +
 388                                 "Namespace SomeNS{0}" +
 389                                 "    {0}" +
 390                                 "    Public Class SomeClass{0}" +
 391                                 "        {0}" +
 392                                 "        Private Sub SomeMethod(Of T As System.IComparable)(){0}" +
 393                                 "        End Sub{0}" +
 394                                 "    End Class{0}" +
 395                                 "End Namespace{0}", NewLine), Generate (), "#1");
 396
 397                         typeParamT.Constraints.Add (new CodeTypeReference (typeof (ICloneable)));
 398
 399                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 400                                 "{0}" +
 401                                 "Namespace SomeNS{0}" +
 402                                 "    {0}" +
 403                                 "    Public Class SomeClass{0}" +
 404                                 "        {0}" +
 405                                 "        Private Sub SomeMethod(Of T As  {{System.IComparable, System.ICloneable}})(){0}" +
 406                                 "        End Sub{0}" +
 407                                 "    End Class{0}" +
 408                                 "End Namespace{0}", NewLine), Generate (), "#2");
 409
 410                         typeParamT.HasConstructorConstraint = true;
 411
 412                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 413                                 "{0}" +
 414                                 "Namespace SomeNS{0}" +
 415                                 "    {0}" +
 416                                 "    Public Class SomeClass{0}" +
 417                                 "        {0}" +
 418                                 "        Private Sub SomeMethod(Of T As  {{System.IComparable, System.ICloneable, New}})(){0}" +
 419                                 "        End Sub{0}" +
 420                                 "    End Class{0}" +
 421                                 "End Namespace{0}", NewLine), Generate (), "#3");
 422
 423                         CodeTypeParameter typeParamS = new CodeTypeParameter ("S");
 424                         typeParamS.Constraints.Add (new CodeTypeReference (typeof (IDisposable)));
 425                         method.TypeParameters.Add (typeParamS);
 426
 427                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 428                                 "{0}" +
 429                                 "Namespace SomeNS{0}" +
 430                                 "    {0}" +
 431                                 "    Public Class SomeClass{0}" +
 432                                 "        {0}" +
 433                                 "        Private Sub SomeMethod(Of T As  {{System.IComparable, System.ICloneable, New}}, S As System.IDisposable)(){0}" +
 434                                 "        End Sub{0}" +
 435                                 "    End Class{0}" +
 436                                 "End Namespace{0}", NewLine), Generate (), "#4");
 437
 438                         CodeTypeParameter typeParamR = new CodeTypeParameter ("R");
 439                         typeParamR.HasConstructorConstraint = true;
 440                         method.TypeParameters.Add (typeParamR);
 441
 442                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 443                                 "{0}" +
 444                                 "Namespace SomeNS{0}" +
 445                                 "    {0}" +
 446                                 "    Public Class SomeClass{0}" +
 447                                 "        {0}" +
 448                                 "        Private Sub SomeMethod(Of T As  {{System.IComparable, System.ICloneable, New}}, S As System.IDisposable, R As New)(){0}" +
 449                                 "        End Sub{0}" +
 450                                 "    End Class{0}" +
 451                                 "End Namespace{0}", NewLine), Generate (), "#5");
 452                 }
 453
 454                 [Test]
 455                 public void Method_TypeParameters_ConstructorConstraint ()
 456                 {
 457                         codeNamespace.Name = "SomeNS";
 458
 459                         CodeTypeDeclaration type = new CodeTypeDeclaration ("SomeClass");
 460                         codeNamespace.Types.Add (type);
 461
 462                         CodeMemberMethod method = new CodeMemberMethod ();
 463                         method.Name = "SomeMethod";
 464                         type.Members.Add (method);
 465
 466                         CodeTypeParameter typeParam = new CodeTypeParameter ("T");
 467                         typeParam.HasConstructorConstraint = true;
 468                         method.TypeParameters.Add (typeParam);
 469
 470                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 471                                 "{0}" +
 472                                 "Namespace SomeNS{0}" +
 473                                 "    {0}" +
 474                                 "    Public Class SomeClass{0}" +
 475                                 "        {0}" +
 476                                 "        Private Sub SomeMethod(Of T As New)(){0}" +
 477                                 "        End Sub{0}" +
 478                                 "    End Class{0}" +
 479                                 "End Namespace{0}", NewLine), Generate ());
 480                 }
 481 #endif
 482         }
 483 }