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

   1 //
   2 // Microsoft.VisualBasic.* Test Cases
   3 //
   4 // Authors:
   5 //      Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (c) Novell
   8 //
   9 using System;
  10 using System.Globalization;
  11 using System.Text;
  12 using System.CodeDom;
  13 using System.CodeDom.Compiler;
  14
  15 using NUnit.Framework;
  16
  17 namespace MonoTests.Microsoft.VisualBasic
  18 {
  19         ///
  20         /// <summary>
  21         ///     Test ICodeGenerator's GenerateCodeFromType, along with a
  22         ///     minimal set CodeDom components.
  23         /// </summary>
  24         ///
  25         [TestFixture]
  26         public class CodeGeneratorFromTypeTest : CodeGeneratorTestBase
  27         {
  28                 CodeTypeDeclaration type = null;
  29
  30                 [SetUp]
  31                 public void Init ()
  32                 {
  33                         InitBase ();
  34                         type = new CodeTypeDeclaration ();
  35                 }
  36
  37                 protected override void Generate ()
  38                 {
  39                         generator.GenerateCodeFromType (type, writer, options);
  40                         writer.Close ();
  41                 }
  42
  43                 [Test]
  44                 public void DefaultTypeTest ()
  45                 {
  46                         Generate ();
  47                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  48                                 "Public Class {0}End Class{0}", writer.NewLine), Code);
  49                 }
  50
  51                 [Test]
  52                 [ExpectedException (typeof (NullReferenceException))]
  53                 public void NullTypeTest ()
  54                 {
  55                         type = null;
  56                         Generate ();
  57                 }
  58
  59                 [Test]
  60                 public void SimpleTypeTest ()
  61                 {
  62                         type.Name = "Test1";
  63                         Generate ();
  64                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  65                                 "Public Class Test1{0}End Class{0}", writer.NewLine), Code);
  66                 }
  67
  68                 [Test]
  69                 public void AttributesAndTypeTest ()
  70                 {
  71                         type.Name = "Test1";
  72
  73                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
  74                         attrDec.Name = "A";
  75                         type.CustomAttributes.Add (attrDec);
  76
  77                         attrDec = new CodeAttributeDeclaration ();
  78                         attrDec.Name = "B";
  79                         type.CustomAttributes.Add (attrDec);
  80
  81                         Generate ();
  82                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  83                                 "<A(),  _{0} B()>  _{0}Public Class Test1{0}End Class{0}",
  84                                 writer.NewLine), Code);
  85                 }
  86
  87                 [Test]
  88                 public void EventMembersTypeTest1 ()
  89                 {
  90                         type.Name = "Test1";
  91
  92                         CodeMemberEvent evt = new CodeMemberEvent ();
  93
  94                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
  95                         attrDec.Name = "A";
  96                         evt.CustomAttributes.Add (attrDec);
  97
  98                         attrDec = new CodeAttributeDeclaration ();
  99                         attrDec.Name = "B";
 100                         evt.CustomAttributes.Add (attrDec);
 101
 102                         type.Members.Add (evt);
 103
 104                         Generate ();
 105                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 106                                 "Public Class Test1{0}    {0}    <A(),  _{0}     B()>  _{0}    "
 107                                 + "Private Event  As System.Void{0}End Class{0}", writer.NewLine), Code);
 108                 }
 109
 110                 [Test]
 111                 public void EventMembersTypeTest2 ()
 112                 {
 113                         type.Name = "Test1";
 114
 115                         CodeMemberEvent evt = new CodeMemberEvent ();
 116                         evt.Name = "OnClick";
 117                         evt.Attributes = MemberAttributes.Public;
 118                         evt.Type = new CodeTypeReference(typeof (int));
 119                         type.Members.Add (evt);
 120
 121                         Generate ();
 122                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 123                                 "Public Class Test1{0}    {0}    "
 124                                 + "Public Event OnClick As Integer{0}"
 125                                 + "End Class{0}", writer.NewLine), Code);
 126                 }
 127
 128                 [Test]
 129                 public void FieldMembersTypeTest1 ()
 130                 {
 131                         type.Name = "Test1";
 132
 133                         CodeMemberField fld = new CodeMemberField ();
 134
 135                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 136                         attrDec.Name = "A";
 137                         fld.CustomAttributes.Add (attrDec);
 138
 139                         attrDec = new CodeAttributeDeclaration ();
 140                         attrDec.Name = "B";
 141                         fld.CustomAttributes.Add (attrDec);
 142
 143                         type.Members.Add (fld);
 144
 145                         Generate ();
 146                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 147                                 "Public Class Test1{0}    {0}    <A(),  _{0}     B()>  _{0}    "
 148                                 + "Private  As System.Void{0}End Class{0}", writer.NewLine), Code);
 149                 }
 150
 151                 [Test]
 152                 public void FieldMembersTypeTest2 ()
 153                 {
 154                         type.Name = "Test1";
 155
 156                         CodeMemberField fld = new CodeMemberField ();
 157                         fld.Name = "Name";
 158                         fld.Attributes = MemberAttributes.Public;
 159                         fld.Type = new CodeTypeReference (typeof (int));
 160                         type.Members.Add (fld);
 161
 162                         Generate ();
 163                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 164                                 "Public Class Test1{0}    {0}    "
 165                                 + "Public Name As Integer{0}"
 166                                 + "End Class{0}", writer.NewLine), Code);
 167                 }
 168
 169                 [Test]
 170                 public void PropertyMembersTypeTest1 ()
 171                 {
 172                         type.Name = "Test1";
 173
 174                         CodeMemberProperty property = new CodeMemberProperty ();
 175
 176                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 177                         attrDec.Name = "A";
 178                         property.CustomAttributes.Add (attrDec);
 179
 180                         attrDec = new CodeAttributeDeclaration ();
 181                         attrDec.Name = "B";
 182                         property.CustomAttributes.Add (attrDec);
 183
 184                         type.Members.Add (property);
 185
 186                         Generate ();
 187                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 188                                 "Public Class Test1{0}"
 189                                 + "    {0}"
 190                                 + "    <A(),  _{0}"
 191                                 + "     B()>  _{0}"
 192 #if NET_2_0
 193                                 + "    Private Property () As System.Void{0}"
 194 #else
 195                                 + "    Private Property  As System.Void{0}"
 196 #endif
 197                                 + "    End Property{0}"
 198                                 + "End Class{0}", writer.NewLine), Code);
 199                 }
 200
 201                 [Test]
 202                 public void PropertyMembersTypeTest2 ()
 203                 {
 204                         type.Name = "Test1";
 205
 206                         CodeMemberProperty property = new CodeMemberProperty ();
 207                         property.Name = "Name";
 208                         property.Attributes = MemberAttributes.Public;
 209                         property.Type = new CodeTypeReference (typeof (int));
 210                         type.Members.Add (property);
 211
 212                         Generate ();
 213                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 214                                 "Public Class Test1{0}"
 215                                 + "    {0}"
 216 #if NET_2_0
 217                                 + "    Public Overridable Property Name() As Integer{0}"
 218 #else
 219                                 + "    Public Overridable Property Name As Integer{0}"
 220 #endif
 221                                 + "    End Property{0}"
 222                                 + "End Class{0}", writer.NewLine), Code);
 223                 }
 224
 225                 [Test]
 226                 public void PropertyMembersTypeGetOnly ()
 227                 {
 228                         type.Name = "Test1";
 229
 230                         CodeMemberProperty property = new CodeMemberProperty ();
 231                         property.Name = "Name";
 232                         property.Attributes = MemberAttributes.Family;
 233                         property.HasGet = true;
 234                         property.Type = new CodeTypeReference (typeof (int));
 235                         type.Members.Add (property);
 236
 237                         Generate ();
 238                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 239                                 "Public Class Test1{0}"
 240                                 + "    {0}"
 241 #if NET_2_0
 242                                 + "    Protected Overridable ReadOnly Property Name() As Integer{0}"
 243 #else
 244                                 + "    Protected Overridable ReadOnly Property Name As Integer{0}"
 245 #endif
 246                                 + "        Get{0}"
 247                                 + "        End Get{0}"
 248                                 + "    End Property{0}"
 249                                 + "End Class{0}", writer.NewLine), Code);
 250                 }
 251
 252                 [Test]
 253                 public void PropertyMembersTypeSetOnly ()
 254                 {
 255                         type.Name = "Test1";
 256
 257                         CodeMemberProperty property = new CodeMemberProperty ();
 258                         property.Name = "Name";
 259                         property.Attributes = MemberAttributes.FamilyAndAssembly;
 260                         property.HasSet = true;
 261                         property.Type = new CodeTypeReference (typeof (int));
 262                         type.Members.Add (property);
 263
 264                         Generate ();
 265                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 266                                 "Public Class Test1{0}"
 267                                 + "    {0}"
 268 #if NET_2_0
 269                                 + "    Friend WriteOnly Property Name() As Integer{0}"
 270 #else
 271                                 + "    Friend WriteOnly Property Name As Integer{0}"
 272 #endif
 273                                 + "        Set{0}"
 274                                 + "        End Set{0}"
 275                                 + "    End Property{0}"
 276                                 + "End Class{0}", writer.NewLine), Code);
 277                 }
 278
 279                 [Test]
 280                 public void PropertyMembersTypeGetSet ()
 281                 {
 282                         type.Name = "Test1";
 283
 284                         CodeMemberProperty property = new CodeMemberProperty ();
 285                         property.Name = "Name";
 286                         property.Attributes = MemberAttributes.Family;
 287                         property.HasGet = true;
 288                         property.HasSet = true;
 289                         property.Type = new CodeTypeReference (typeof (int));
 290                         type.Members.Add (property);
 291
 292                         Generate ();
 293                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 294                                 "Public Class Test1{0}"
 295                                 + "    {0}"
 296 #if NET_2_0
 297                                 + "    Protected Overridable Property Name() As Integer{0}"
 298 #else
 299                                 + "    Protected Overridable Property Name As Integer{0}"
 300 #endif
 301                                 + "        Get{0}"
 302                                 + "        End Get{0}"
 303                                 + "        Set{0}"
 304                                 + "        End Set{0}"
 305                                 + "    End Property{0}"
 306                                 + "End Class{0}", writer.NewLine), Code);
 307                 }
 308
 309 #if !NET_2_0
 310                 // A bug in MS.NET 1.x causes MemberAttributes.FamilyOrAssembly to be
 311                 // generated as Protected
 312                 [Category("NotDotNet")]
 313 #endif
 314                 [Test]
 315                 public void PropertyMembersTypeFamilyOrAssembly ()
 316                 {
 317                         type.Name = "Test1";
 318
 319                         CodeMemberProperty property = new CodeMemberProperty ();
 320                         property.Name = "Name";
 321                         property.Attributes = MemberAttributes.FamilyOrAssembly;
 322                         property.Type = new CodeTypeReference (typeof (int));
 323
 324                         type.Members.Add (property);
 325
 326                         Generate ();
 327                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 328                                 "Public Class Test1{0}"
 329                                 + "    {0}"
 330 #if NET_2_0
 331                                 + "    Protected Friend Property Name() As Integer{0}"
 332 #else
 333                                 + "    Protected Friend Property Name As Integer{0}"
 334 #endif
 335                                 + "    End Property{0}"
 336                                 + "End Class{0}", writer.NewLine), Code);
 337                 }
 338
 339 #if !NET_2_0
 340                 // A bug in MS.NET 1.x causes MemberAttributes.Assembly to be generated
 341                 // as Protected
 342                 [Category ("NotDotNet")]
 343 #endif
 344                 [Test]
 345                 public void PropertyMembersTypeAssembly ()
 346                 {
 347                         type.Name = "Test1";
 348
 349                         CodeMemberProperty property = new CodeMemberProperty ();
 350                         property.Name = "Name";
 351                         property.Attributes = MemberAttributes.Assembly;
 352                         property.Type = new CodeTypeReference (typeof (int));
 353
 354                         type.Members.Add (property);
 355
 356                         Generate ();
 357                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 358                                 "Public Class Test1{0}"
 359                                 + "    {0}"
 360 #if NET_2_0
 361                                 + "    Friend Overridable Property Name() As Integer{0}"
 362 #else
 363                                 + "    Friend Property Name As Integer{0}"
 364 #endif
 365                                 + "    End Property{0}"
 366                                 + "End Class{0}", writer.NewLine), Code);
 367                 }
 368
 369                 [Test]
 370                 public void MethodMembersTypeTest1 ()
 371                 {
 372                         type.Name = "Test1";
 373
 374                         CodeMemberMethod method = new CodeMemberMethod ();
 375
 376                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 377                         attrDec.Name = "A";
 378                         method.CustomAttributes.Add (attrDec);
 379
 380                         attrDec = new CodeAttributeDeclaration ();
 381                         attrDec.Name = "B";
 382                         method.CustomAttributes.Add (attrDec);
 383
 384                         type.Members.Add (method);
 385
 386                         Generate ();
 387                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 388                                 "Public Class Test1{0}"
 389                                 + "    {0}"
 390                                 + "    <A(),  _{0}"
 391                                 + "     B()>  _{0}"
 392                                 + "    Private Sub (){0}"
 393                                 + "    End Sub{0}"
 394                                 + "End Class{0}", writer.NewLine), Code);
 395                 }
 396
 397                 [Test]
 398                 public void MethodMembersTypeTest2 ()
 399                 {
 400                         type.Name = "Test1";
 401
 402                         CodeMemberMethod method = new CodeMemberMethod ();
 403                         method.Name = "Something";
 404                         method.Attributes = MemberAttributes.Public;
 405                         method.ReturnType = new CodeTypeReference (typeof (int));
 406
 407                         CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
 408                                 typeof(object), "value1");
 409                         method.Parameters.Add (param);
 410
 411                         param = new CodeParameterDeclarationExpression (
 412                                 typeof (object), "value2");
 413                         param.Direction = FieldDirection.In;
 414                         method.Parameters.Add (param);
 415
 416                         param = new CodeParameterDeclarationExpression (typeof (int), "index");
 417                         param.Direction = FieldDirection.Out;
 418                         method.Parameters.Add (param);
 419
 420                         param = new CodeParameterDeclarationExpression (typeof (int), "count");
 421                         param.Direction = FieldDirection.Ref;
 422                         method.Parameters.Add (param);
 423
 424                         type.Members.Add (method);
 425
 426                         Generate ();
 427                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 428                                 "Public Class Test1{0}"
 429                                 + "    {0}"
 430                                 + "    Public Overridable Function Something(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer) As Integer{0}"
 431                                 + "    End Function{0}"
 432                                 + "End Class{0}", writer.NewLine), Code);
 433                 }
 434
 435                 [Test]
 436                 public void MethodMembersTypeTest3 ()
 437                 {
 438                         type.Name = "Test1";
 439
 440                         CodeMemberMethod method = new CodeMemberMethod ();
 441                         method.Name = "Something";
 442                         method.Attributes = MemberAttributes.Public;
 443                         method.ReturnType = new CodeTypeReference (typeof (int));
 444
 445                         // first parameter
 446                         CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
 447                                 typeof (object), "value");
 448                         method.Parameters.Add (param);
 449
 450                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 451                         attrDec.Name = "A";
 452                         param.CustomAttributes.Add (attrDec);
 453
 454                         attrDec = new CodeAttributeDeclaration ();
 455                         attrDec.Name = "B";
 456                         param.CustomAttributes.Add (attrDec);
 457
 458
 459                         // second parameter
 460                         param = new CodeParameterDeclarationExpression (typeof (int), "index");
 461                         param.Direction = FieldDirection.Out;
 462                         method.Parameters.Add (param);
 463
 464                         attrDec = new CodeAttributeDeclaration ();
 465                         attrDec.Name = "C";
 466                         attrDec.Arguments.Add (new CodeAttributeArgument ("A1",
 467                                 new CodePrimitiveExpression (false)));
 468                         attrDec.Arguments.Add (new CodeAttributeArgument ("A2",
 469                                 new CodePrimitiveExpression (true)));
 470                         param.CustomAttributes.Add (attrDec);
 471
 472                         attrDec = new CodeAttributeDeclaration ();
 473                         attrDec.Name = "D";
 474                         param.CustomAttributes.Add (attrDec);
 475
 476                         type.Members.Add (method);
 477
 478                         Generate ();
 479                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 480                                 "Public Class Test1{0}"
 481                                 + "    {0}"
 482                                 + "    Public Overridable Function Something(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer) As Integer{0}"
 483                                 + "    End Function{0}"
 484                                 + "End Class{0}", writer.NewLine), Code);
 485                 }
 486
 487                 [Test]
 488                 public void ConstructorAttributesTest ()
 489                 {
 490                         type.Name = "Test1";
 491
 492                         CodeConstructor ctor = new CodeConstructor ();
 493
 494                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 495                         attrDec.Name = "A";
 496                         ctor.CustomAttributes.Add (attrDec);
 497
 498                         attrDec = new CodeAttributeDeclaration ();
 499                         attrDec.Name = "B";
 500                         ctor.CustomAttributes.Add (attrDec);
 501
 502                         type.Members.Add (ctor);
 503
 504                         Generate ();
 505                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 506                                 "Public Class Test1{0}"
 507                                 + "    {0}"
 508                                 + "    <A(),  _{0}"
 509                                 + "     B()>  _{0}"
 510                                 + "    Private Sub New(){0}"
 511                                 + "        MyBase.New{0}"
 512                                 + "    End Sub{0}"
 513                                 + "End Class{0}", writer.NewLine), Code);
 514                 }
 515
 516                 [Test]
 517                 public void ConstructorParametersTest ()
 518                 {
 519                         type.Name = "Test1";
 520
 521                         CodeConstructor ctor = new CodeConstructor ();
 522                         ctor.Name = "Whatever";
 523                         ctor.Attributes = MemberAttributes.Public;
 524
 525                         CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
 526                                 typeof (object), "value1");
 527                         ctor.Parameters.Add (param);
 528
 529                         param = new CodeParameterDeclarationExpression (
 530                                 typeof (object), "value2");
 531                         param.Direction = FieldDirection.In;
 532                         ctor.Parameters.Add (param);
 533
 534                         param = new CodeParameterDeclarationExpression (typeof (int), "index");
 535                         param.Direction = FieldDirection.Out;
 536                         ctor.Parameters.Add (param);
 537
 538                         param = new CodeParameterDeclarationExpression (typeof (int), "count");
 539                         param.Direction = FieldDirection.Ref;
 540                         ctor.Parameters.Add (param);
 541
 542                         type.Members.Add (ctor);
 543
 544                         Generate ();
 545                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 546                                 "Public Class Test1{0}"
 547                                 + "    {0}"
 548                                 + "    Public Sub New(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer){0}"
 549                                 + "        MyBase.New{0}"
 550                                 + "    End Sub{0}"
 551                                 + "End Class{0}", writer.NewLine), Code);
 552                 }
 553
 554                 [Test]
 555                 public void ConstructorParameterAttributesTest ()
 556                 {
 557                         type.Name = "Test1";
 558
 559                         CodeConstructor ctor = new CodeConstructor ();
 560                         ctor.Name = "Something";
 561                         ctor.Attributes = MemberAttributes.Public;
 562
 563                         // first parameter
 564                         CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
 565                                 typeof (object), "value");
 566                         ctor.Parameters.Add (param);
 567
 568                         CodeAttributeDeclaration attrDec = new CodeAttributeDeclaration ();
 569                         attrDec.Name = "A";
 570                         param.CustomAttributes.Add (attrDec);
 571
 572                         attrDec = new CodeAttributeDeclaration ();
 573                         attrDec.Name = "B";
 574                         param.CustomAttributes.Add (attrDec);
 575
 576                         // second parameter
 577                         param = new CodeParameterDeclarationExpression (typeof (int), "index");
 578                         param.Direction = FieldDirection.Out;
 579                         ctor.Parameters.Add (param);
 580
 581                         attrDec = new CodeAttributeDeclaration ();
 582                         attrDec.Name = "C";
 583                         attrDec.Arguments.Add (new CodeAttributeArgument ("A1",
 584                                 new CodePrimitiveExpression (false)));
 585                         attrDec.Arguments.Add (new CodeAttributeArgument ("A2",
 586                                 new CodePrimitiveExpression (true)));
 587                         param.CustomAttributes.Add (attrDec);
 588
 589                         attrDec = new CodeAttributeDeclaration ();
 590                         attrDec.Name = "D";
 591                         param.CustomAttributes.Add (attrDec);
 592
 593                         type.Members.Add (ctor);
 594
 595                         Generate ();
 596                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 597                                 "Public Class Test1{0}"
 598                                 + "    {0}"
 599                                 + "    Public Sub New(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer){0}"
 600                                 + "        MyBase.New{0}"
 601                                 + "    End Sub{0}"
 602                                 + "End Class{0}", writer.NewLine), Code);
 603                 }
 604
 605                 [Test]
 606                 public void BaseConstructorSingleArg ()
 607                 {
 608                         type.Name = "Test1";
 609
 610                         CodeConstructor ctor = new CodeConstructor ();
 611                         ctor.Name = "Something";
 612                         ctor.Attributes = MemberAttributes.Public;
 613
 614                         // first parameter
 615                         CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
 616                                 typeof (object), "value1");
 617                         ctor.Parameters.Add (param);
 618
 619                         // second parameter
 620                         param = new CodeParameterDeclarationExpression (typeof (int), "value2");
 621                         param.Direction = FieldDirection.Out;
 622                         ctor.Parameters.Add (param);
 623
 624                         // base ctor args
 625                         ctor.BaseConstructorArgs.Add (new CodeVariableReferenceExpression ("value1"));
 626
 627                         type.Members.Add (ctor);
 628
 629                         Generate ();
 630                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 631                                 "Public Class Test1{0}"
 632                                 + "    {0}"
 633                                 + "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}"
 634                                 + "        MyBase.New(value1){0}"
 635                                 + "    End Sub{0}"
 636                                 + "End Class{0}", writer.NewLine), Code);
 637                 }
 638
 639                 [Test]
 640                 public void BaseConstructorMultipleArgs ()
 641                 {
 642                         type.Name = "Test1";
 643
 644                         CodeConstructor ctor = new CodeConstructor ();
 645                         ctor.Name = "Something";
 646                         ctor.Attributes = MemberAttributes.Public;
 647
 648                         // first parameter
 649                         CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
 650                                 typeof (object), "value1");
 651                         ctor.Parameters.Add (param);
 652
 653                         // second parameter
 654                         param = new CodeParameterDeclarationExpression (typeof (int), "value2");
 655                         param.Direction = FieldDirection.Out;
 656                         ctor.Parameters.Add (param);
 657
 658                         // base ctor args
 659                         ctor.BaseConstructorArgs.Add (new CodeVariableReferenceExpression ("value1"));
 660                         ctor.BaseConstructorArgs.Add (new CodeVariableReferenceExpression ("value2"));
 661
 662                         type.Members.Add (ctor);
 663
 664                         Generate ();
 665                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 666                                 "Public Class Test1{0}"
 667                                 + "    {0}"
 668                                 + "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}"
 669                                 + "        MyBase.New(value1, value2){0}"
 670                                 + "    End Sub{0}"
 671                                 + "End Class{0}", writer.NewLine), Code);
 672                 }
 673
 674                 [Test]
 675                 public void ChainedConstructorSingleArg ()
 676                 {
 677                         type.Name = "Test1";
 678
 679                         CodeConstructor ctor = new CodeConstructor ();
 680                         ctor.Name = "Something";
 681                         ctor.Attributes = MemberAttributes.Public;
 682
 683                         // first parameter
 684                         CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
 685                                 typeof (object), "value1");
 686                         ctor.Parameters.Add (param);
 687
 688                         // second parameter
 689                         param = new CodeParameterDeclarationExpression (typeof (int), "value2");
 690                         param.Direction = FieldDirection.Out;
 691                         ctor.Parameters.Add (param);
 692
 693                         // chained ctor args
 694                         ctor.ChainedConstructorArgs.Add (new CodeVariableReferenceExpression ("value1"));
 695
 696                         // should be ignored as chained ctor args should take precedence over base
 697                         // ctor args
 698                         ctor.BaseConstructorArgs.Add (new CodeVariableReferenceExpression ("value3"));
 699
 700                         type.Members.Add (ctor);
 701
 702                         Generate ();
 703                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 704                                 "Public Class Test1{0}"
 705                                 + "    {0}"
 706                                 + "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}"
 707                                 + "        Me.New(value1){0}"
 708                                 + "    End Sub{0}"
 709                                 + "End Class{0}", writer.NewLine), Code);
 710                 }
 711
 712                 [Test]
 713                 public void ChainedConstructorMultipleArgs ()
 714                 {
 715                         type.Name = "Test1";
 716
 717                         CodeConstructor ctor = new CodeConstructor ();
 718                         ctor.Name = "Something";
 719                         ctor.Attributes = MemberAttributes.Public;
 720
 721                         // first parameter
 722                         CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression (
 723                                 typeof (object), "value1");
 724                         ctor.Parameters.Add (param);
 725
 726                         // second parameter
 727                         param = new CodeParameterDeclarationExpression (typeof (int), "value2");
 728                         param.Direction = FieldDirection.Out;
 729                         ctor.Parameters.Add (param);
 730
 731                         // chained ctor args
 732                         ctor.ChainedConstructorArgs.Add (new CodeVariableReferenceExpression ("value1"));
 733                         ctor.ChainedConstructorArgs.Add (new CodeVariableReferenceExpression ("value2"));
 734
 735                         // should be ignored as chained ctor args should take precedence over base
 736                         // ctor args
 737                         ctor.BaseConstructorArgs.Add (new CodeVariableReferenceExpression ("value3"));
 738
 739                         type.Members.Add (ctor);
 740
 741                         Generate ();
 742                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 743                                 "Public Class Test1{0}"
 744                                 + "    {0}"
 745                                 + "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}"
 746                                 + "        Me.New(value1, value2){0}"
 747                                 + "    End Sub{0}"
 748                                 + "End Class{0}", writer.NewLine), Code);
 749                 }
 750         }
 751 }