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
  10 using System;
  11 using System.CodeDom;
  12 using System.CodeDom.Compiler;
  13 using System.Globalization;
  14
  15 using Microsoft.VisualBasic;
  16
  17 using NUnit.Framework;
  18
  19 using MonoTests.System.CodeDom.Compiler;
  20
  21 namespace MonoTests.Microsoft.VisualBasic
  22 {
  23         [TestFixture]
  24         public class CodeGeneratorFromTypeTest_Class : CodeGeneratorFromTypeTestBase
  25         {
  26                 private CodeTypeDeclaration _typeDeclaration;
  27                 private ICodeGenerator _codeGenerator;
  28
  29                 protected override ICodeGenerator CodeGenerator
  30                 {
  31                         get { return _codeGenerator; }
  32                 }
  33
  34                 protected override CodeTypeDeclaration TypeDeclaration
  35                 {
  36                         get { return _typeDeclaration; }
  37                 }
  38
  39                 [SetUp]
  40                 public override void SetUp ()
  41                 {
  42                         base.SetUp ();
  43                         _typeDeclaration = new CodeTypeDeclaration ();
  44
  45                         CodeDomProvider provider = new VBCodeProvider ();
  46                         _codeGenerator = provider.CreateGenerator ();
  47                 }
  48
  49                 [Test]
  50                 public override void DefaultTypeTest ()
  51                 {
  52                         string code = GenerateDefaultType ();
  53                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  54                                 "Public Class {0}" +
  55                                 "End Class{0}", Writer.NewLine), code);
  56                 }
  57
  58                 [Test]
  59                 [ExpectedException (typeof (NullReferenceException))]
  60                 public override void NullTypeTest ()
  61                 {
  62                         GenerateNullType ();
  63                 }
  64
  65                 [Test]
  66                 public override void SimpleTypeTest ()
  67                 {
  68                         string code = GenerateSimpleType ();
  69                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  70                                 "Public Class Test1{0}" +
  71                                 "End Class{0}", Writer.NewLine), code);
  72                 }
  73
  74                 [Test]
  75                 public override void AttributesAndTypeTest ()
  76                 {
  77                         string code = GenerateAttributesAndType ();
  78                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  79                                 "<A(),  _{0}" +
  80                                 " B()>  _{0}" +
  81                                 "Public Class Test1{0}" +
  82                                 "End Class{0}", Writer.NewLine), code);
  83                 }
  84
  85                 [Test]
  86                 public override void EventMembersTypeTest1 ()
  87                 {
  88                         string code = GenerateEventMembersType1 ();
  89                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
  90                                 "Public Class Test1{0}" +
  91                                 "    {0}" +
  92                                 "    <A(),  _{0}" +
  93                                 "     B()>  _{0}" +
  94                                 "    Private Event  As System.Void{0}" +
  95                                 "End Class{0}", Writer.NewLine), code);
  96                 }
  97
  98                 [Test]
  99                 public override void EventMembersTypeTest2 ()
 100                 {
 101                         string code = GenerateEventMembersType2 ();
 102                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 103                                 "Public Class Test1{0}" +
 104                                 "    {0}" +
 105                                 "    Public Event Click As Integer{0}" +
 106                                 "End Class{0}", Writer.NewLine), code);
 107                 }
 108
 109                 [Test]
 110                 public override void EventImplementationTypes ()
 111                 {
 112                         string code = GenerateEventImplementationTypes ();
 113                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 114                                 "Public Class Test1{0}" +
 115                                 "    {0}" +
 116 #if NET_2_0
 117                                 "    Friend Event Click As Integer Implements IPolicy.Click , IWhatever.Click{0}" +
 118 #else
 119                                 "    Friend Event Click As Integer{0}" +
 120 #endif
 121                                 "End Class{0}", Writer.NewLine), code);
 122                 }
 123
 124                 /// <summary>
 125                 /// Ensure no access modifiers are output if PrivateImplementationType
 126                 /// is set.
 127                 /// </summary>
 128                 [Test]
 129                 public override void EventPrivateImplementationType ()
 130                 {
 131                         string code = GenerateEventPrivateImplementationType ();
 132                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 133                                 "Public Class Test1{0}" +
 134                                 "    {0}" +
 135 #if NET_2_0
 136                                 "    Protected Event System_Int32_Click As Integer Implements Integer.Click{0}" +
 137 #else
 138                                 "    Protected Event Click As Integer{0}" +
 139 #endif
 140                                 "End Class{0}", Writer.NewLine), code);
 141                 }
 142
 143                 /// <summary>
 144                 /// If both ImplementationTypes and PrivateImplementationType are set,
 145                 /// then only ImplementationTypes are output.
 146                 /// </summary>
 147                 [Test]
 148                 public override void EventImplementationTypeOrder ()
 149                 {
 150                         string code = GenerateEventImplementationTypeOrder ();
 151                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 152                                 "Public Class Test1{0}" +
 153                                 "    {0}" +
 154 #if NET_2_0
 155                                 "    Public Event System_Int32_Click As Integer Implements IPolicy.Click{0}" +
 156 #else
 157                                 "    Public Event Click As Integer{0}" +
 158 #endif
 159                                 "End Class{0}", Writer.NewLine), code);
 160                 }
 161
 162                 [Test]
 163                 public override void FieldMembersTypeTest1 ()
 164                 {
 165                         string code = GenerateFieldMembersType1 ();
 166                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 167                                 "Public Class Test1{0}" +
 168                                 "    {0}" +
 169                                 "    <A(),  _{0}" +
 170                                 "     B()>  _{0}" +
 171                                 "    Private  As System.Void{0}" +
 172                                 "End Class{0}", Writer.NewLine), code);
 173                 }
 174
 175                 [Test]
 176                 public override void FieldMembersTypeTest2 ()
 177                 {
 178                         string code = GenerateFieldMembersType2 ();
 179                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 180                                 "Public Class Test1{0}" +
 181                                 "    {0}" +
 182                                 "    Public Name As Integer{0}" +
 183                                 "End Class{0}", Writer.NewLine), code);
 184                 }
 185
 186                 [Test]
 187                 public override void PropertyMembersTypeTest1 ()
 188                 {
 189                         string code = GeneratePropertyMembersAttributes ();
 190                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 191                                 "Public Class Test1{0}" +
 192                                 "    {0}" +
 193                                 "    <A(),  _{0}" +
 194                                 "     B()>  _{0}" +
 195 #if NET_2_0
 196                                 "    Private Property () As System.Void{0}" +
 197 #else
 198                                 "    Private Property  As System.Void{0}" +
 199 #endif
 200                                 "    End Property{0}" +
 201                                 "End Class{0}", Writer.NewLine), code);
 202                 }
 203
 204                 [Test]
 205                 public override void PropertyMembersTypeTest2 ()
 206                 {
 207                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
 208                                 false, false);
 209                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 210                                 "Public Class Test1{0}" +
 211                                 "    {0}" +
 212 #if NET_2_0
 213                                 "    Public Overridable Property Name() As Integer{0}" +
 214 #else
 215                                 "    Public Overridable Property Name As Integer{0}" +
 216 #endif
 217                                 "    End Property{0}" +
 218                                 "End Class{0}", Writer.NewLine), code);
 219                 }
 220
 221                 [Test]
 222                 public override void PropertyMembersTypeGetOnly ()
 223                 {
 224                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
 225                                 true, false);
 226                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 227                                 "Public Class Test1{0}" +
 228                                 "    {0}" +
 229 #if NET_2_0
 230                                 "    Protected Overridable ReadOnly Property Name() As Integer{0}" +
 231 #else
 232                                 "    Protected Overridable ReadOnly Property Name As Integer{0}" +
 233 #endif
 234                                 "        Get{0}" +
 235                                 "        End Get{0}" +
 236                                 "    End Property{0}" +
 237                                 "End Class{0}", Writer.NewLine), code);
 238                 }
 239
 240                 [Test]
 241                 public override void PropertyMembersTypeSetOnly ()
 242                 {
 243                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
 244                                 false, true);
 245                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 246                                 "Public Class Test1{0}" +
 247                                 "    {0}" +
 248 #if NET_2_0
 249                                 "    Friend Overridable WriteOnly Property Name() As Integer{0}" +
 250 #else
 251                                 "    Friend WriteOnly Property Name As Integer{0}" +
 252 #endif
 253                                 "        Set{0}" +
 254                                 "        End Set{0}" +
 255                                 "    End Property{0}" +
 256                                 "End Class{0}", Writer.NewLine), code);
 257                 }
 258
 259                 [Test]
 260                 public override void PropertyMembersTypeGetSet ()
 261                 {
 262                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
 263                                 true, true);
 264                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 265                                 "Public Class Test1{0}" +
 266                                 "    {0}" +
 267 #if NET_2_0
 268                                 "    Protected Overridable Property Name() As Integer{0}" +
 269 #else
 270                                 "    Protected Overridable Property Name As Integer{0}" +
 271 #endif
 272                                 "        Get{0}" +
 273                                 "        End Get{0}" +
 274                                 "        Set{0}" +
 275                                 "        End Set{0}" +
 276                                 "    End Property{0}" +
 277                                 "End Class{0}", Writer.NewLine), code);
 278                 }
 279
 280 #if !NET_2_0
 281                 // A bug in MS.NET 1.x causes MemberAttributes.FamilyOrAssembly to be
 282                 // generated as Protected
 283                 [Category ("NotDotNet")]
 284 #endif
 285                 [Test]
 286                 public override void PropertyMembersTypeFamilyOrAssembly ()
 287                 {
 288                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
 289                                 false, false);
 290                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 291                                 "Public Class Test1{0}" +
 292                                 "    {0}" +
 293 #if NET_2_0
 294                                 "    Protected Friend Property Name() As Integer{0}" +
 295 #else
 296                                 "    Protected Friend Property Name As Integer{0}" +
 297 #endif
 298                                 "    End Property{0}" +
 299                                 "End Class{0}", Writer.NewLine), code);
 300                 }
 301
 302 #if !NET_2_0
 303                 // A bug in MS.NET 1.x causes MemberAttributes.Assembly to be generated
 304                 // as Protected
 305                 [Category ("NotDotNet")]
 306 #endif
 307                 [Test]
 308                 public override void PropertyMembersTypeAssembly ()
 309                 {
 310                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
 311                                 false, false);
 312                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 313                                 "Public Class Test1{0}" +
 314                                 "    {0}" +
 315 #if NET_2_0
 316                                 "    Friend Overridable Property Name() As Integer{0}" +
 317 #else
 318                                 "    Friend Property Name As Integer{0}" +
 319 #endif
 320                                 "    End Property{0}" +
 321                                 "End Class{0}", Writer.NewLine), code);
 322                 }
 323
 324                 /// <summary>
 325                 /// Apparently VB.NET CodeDOM also allows properties that aren't indexers
 326                 /// to have parameters.
 327                 /// </summary>
 328                 [Test]
 329                 public override void PropertyParametersTest ()
 330                 {
 331                         string code = GeneratePropertyParameters ();
 332                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 333                                 "Public Class Test1{0}" +
 334                                 "    {0}" +
 335                                 "    Public Overridable Property Name(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
 336                                 "    End Property{0}" +
 337                                 "End Class{0}", Writer.NewLine), code);
 338                 }
 339
 340                 [Test]
 341                 public override void PropertyIndexerTest1 ()
 342                 {
 343                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
 344                                 false, false, true);
 345                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 346                                 "Public Class Test1{0}" +
 347                                 "    {0}" +
 348                                 "    Public Overridable Default Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
 349                                 "    End Property{0}" +
 350                                 "End Class{0}", Writer.NewLine), code);
 351                 }
 352
 353                 /// <summary>
 354                 /// Ensures Default keyword is only output if property is named "Item"
 355                 /// (case-insensitive comparison) AND parameters are defined.
 356                 /// </summary>
 357                 [Test]
 358                 public override void PropertyIndexerTest2 ()
 359                 {
 360                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
 361                                 false, false, false);
 362                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 363                                 "Public Class Test1{0}" +
 364                                 "    {0}" +
 365 #if NET_2_0
 366                                 "    Public Overridable Property iTem() As Integer{0}" +
 367 #else
 368                                 "    Public Overridable Property iTem As Integer{0}" +
 369 #endif
 370                                 "    End Property{0}" +
 371                                 "End Class{0}", Writer.NewLine), code);
 372                 }
 373
 374                 /// <summary>
 375                 /// Ensures Default keyword is output after ReadOnly modifier.
 376                 /// </summary>
 377                 [Test]
 378                 public override void PropertyIndexerGetOnly ()
 379                 {
 380                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
 381                                 true, false, true);
 382                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 383                                 "Public Class Test1{0}" +
 384                                 "    {0}" +
 385                                 "    Protected Overridable Default ReadOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
 386                                 "        Get{0}" +
 387                                 "        End Get{0}" +
 388                                 "    End Property{0}" +
 389                                 "End Class{0}", Writer.NewLine), code);
 390                 }
 391
 392                 /// <summary>
 393                 /// Ensures Default keyword is output after WriteOnly modifier.
 394                 /// </summary>
 395                 [Test]
 396                 public override void PropertyIndexerSetOnly ()
 397                 {
 398                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
 399                                 false, true, true);
 400                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 401                                 "Public Class Test1{0}" +
 402                                 "    {0}" +
 403                                 "    Protected Overridable Default WriteOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
 404                                 "        Set{0}" +
 405                                 "        End Set{0}" +
 406                                 "    End Property{0}" +
 407                                 "End Class{0}", Writer.NewLine), code);
 408                 }
 409
 410                 [Test]
 411                 public override void PropertyImplementationTypes ()
 412                 {
 413                         string code = GeneratePropertyImplementationTypes ();
 414                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 415                                 "Public Class Test1{0}" +
 416                                 "    {0}" +
 417 #if NET_2_0
 418                                 "    Public Overridable Property Name() As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
 419 #else
 420                                 "    Public Overridable Property Name As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
 421 #endif
 422                                 "    End Property{0}" +
 423                                 "End Class{0}", Writer.NewLine), code);
 424                 }
 425
 426                 /// <summary>
 427                 /// Ensure that Overloads keyword is output for a property which has
 428                 /// explicitly been marked as Overloaded.
 429                 /// </summary>
 430                 [Test]
 431                 public override void PropertyOverloadsTest1 ()
 432                 {
 433                         string code = GeneratePropertyOverloads1 ();
 434                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 435                                 "Public Class Test1{0}" +
 436                                 "    {0}" +
 437 #if NET_2_0
 438                                 "    Public Overloads Overridable Property Name() As Integer{0}" +
 439 #else
 440                                 "    Public Overloads Overridable Property Name As Integer{0}" +
 441 #endif
 442                                 "    End Property{0}" +
 443                                 "End Class{0}", Writer.NewLine), code);
 444                 }
 445
 446                 /// <summary>
 447                 /// Ensure that Overloads keyword is output if multiple properties with
 448                 /// the same name are defined.
 449                 /// </summary>
 450                 [Test]
 451                 public override void PropertyOverloadsTest2 ()
 452                 {
 453                         string code = GeneratePropertyOverloads2 ();
 454                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 455                                 "Public Class Test1{0}" +
 456                                 "    {0}" +
 457 #if NET_2_0
 458                                 "    Public Overloads Overridable Property Name() As Integer{0}" +
 459 #else
 460                                 "    Public Overloads Overridable Property Name As Integer{0}" +
 461 #endif
 462                                 "    End Property{0}" +
 463                                 "    {0}" +
 464                                 "    Private Overloads Property Name(ByVal value1 As Object) As Integer{0}" +
 465                                 "    End Property{0}" +
 466                                 "End Class{0}", Writer.NewLine), code);
 467                 }
 468
 469                 /// <summary>
 470                 /// Ensure that a property with a PrivateImplementationType and with
 471                 /// the same name does not qualify as an overload.
 472                 /// </summary>
 473                 [Test]
 474                 public override void PropertyOverloadsTest3 ()
 475                 {
 476                         string code = GeneratePropertyOverloads3 ();
 477                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 478                                 "Public Class Test1{0}" +
 479                                 "    {0}" +
 480 #if NET_2_0
 481                                 "    Public Overridable Property Name() As Integer{0}" +
 482 #else
 483                                 "    Public Overridable Property Name As Integer{0}" +
 484 #endif
 485                                 "    End Property{0}" +
 486                                 "    {0}" +
 487                                 "    Property System_Int32_Name(ByVal value1 As Object) As Integer Implements Integer.Name{0}" +
 488                                 "    End Property{0}" +
 489                                 "End Class{0}", Writer.NewLine), code);
 490                 }
 491
 492                 /// <summary>
 493                 /// Ensure no access modifiers are output if PrivateImplementationType
 494                 /// is set. Default keyword is also not output in this case.
 495                 /// </summary>
 496                 [Test]
 497                 public override void PropertyPrivateImplementationType ()
 498                 {
 499                         string code = GeneratePropertyPrivateImplementationType ();
 500                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 501                                 "Public Class Test1{0}" +
 502                                 "    {0}" +
 503                                 "    Overridable Property System_Int32_Item(ByVal value1 As Object) As Integer Implements Integer.Item{0}" +
 504                                 "    End Property{0}" +
 505                                 "End Class{0}", Writer.NewLine), code);
 506                 }
 507
 508                 /// <summary>
 509                 /// If both ImplementationTypes and PrivateImplementationType are set,
 510                 /// then only ImplementationTypes are output.
 511                 /// </summary>
 512                 [Test]
 513                 public override void PropertyImplementationTypeOrder ()
 514                 {
 515                         string code = GeneratePropertyImplementationTypeOrder ();
 516                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 517                                 "Public Class Test1{0}" +
 518                                 "    {0}" +
 519                                 "    Overridable Property System_Int32_Item(ByVal value1 As Object) As Integer Implements IPolicy.Item{0}" +
 520                                 "    End Property{0}" +
 521                                 "End Class{0}", Writer.NewLine), code);
 522                 }
 523
 524                 [Test]
 525                 public override void MethodMembersTypeTest1 ()
 526                 {
 527                         string code = GenerateMethodMembersType1 ();
 528                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 529                                 "Public Class Test1{0}" +
 530                                 "    {0}" +
 531                                 "    <A(),  _{0}" +
 532                                 "     B()>  _{0}" +
 533                                 "    Private Sub (){0}" +
 534                                 "    End Sub{0}" +
 535                                 "End Class{0}", Writer.NewLine), code);
 536                 }
 537
 538                 [Test]
 539                 public override void MethodMembersTypeTest2 ()
 540                 {
 541                         string code = GenerateMethodMembersType2 ();
 542                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 543                                 "Public Class Test1{0}" +
 544                                 "    {0}" +
 545                                 "    Public Overridable Function Something(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer) As Integer{0}" +
 546                                 "    End Function{0}" +
 547                                 "End Class{0}", Writer.NewLine), code);
 548                 }
 549
 550                 [Test]
 551                 public override void MethodMembersTypeTest3 ()
 552                 {
 553                         string code = GenerateMethodMembersType3 ();
 554                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 555                                 "Public Class Test1{0}" +
 556                                 "    {0}" +
 557                                 "    Public Overridable Function Something(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer) As Integer{0}" +
 558                                 "    End Function{0}" +
 559                                 "End Class{0}", Writer.NewLine), code);
 560                 }
 561
 562                 [Test]
 563                 public override void MethodImplementationTypes ()
 564                 {
 565                         string code = GenerateMethodImplementationTypes ();
 566                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 567                                 "Public Class Test1{0}" +
 568                                 "    {0}" +
 569 #if NET_2_0
 570                                 "    Friend Overridable Function Execute() As Integer Implements IPolicy.Execute , IWhatever.Execute{0}" +
 571 #else
 572                                 "    Friend Function Execute() As Integer Implements IPolicy.Execute , IWhatever.Execute{0}" +
 573 #endif
 574                                 "    End Function{0}" +
 575                                 "End Class{0}", Writer.NewLine), code);
 576                 }
 577
 578                 /// <summary>
 579                 /// Ensure that Overloads keyword is output for a method which has
 580                 /// explicitly been marked as Overloaded.
 581                 /// </summary>
 582                 [Test]
 583                 public override void MethodOverloadsTest1 ()
 584                 {
 585                         string code = GenerateMethodOverloads1 ();
 586                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 587                                 "Public Class Test1{0}" +
 588                                 "    {0}" +
 589                                 "    Public Overloads Overridable Function Execute() As Integer{0}" +
 590                                 "    End Function{0}" +
 591                                 "End Class{0}", Writer.NewLine), code);
 592                 }
 593
 594                 /// <summary>
 595                 /// Ensure that Overloads keyword is output if multiple methods with
 596                 /// the same name are defined.
 597                 /// </summary>
 598                 [Test]
 599                 public override void MethodOverloadsTest2 ()
 600                 {
 601                         string code = GenerateMethodOverloads2 ();
 602                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 603                                 "Public Class Test1{0}" +
 604                                 "    {0}" +
 605                                 "    Public Overloads Overridable Sub Execute(){0}" +
 606                                 "    End Sub{0}" +
 607                                 "    {0}" +
 608                                 "    Private Overloads Function Execute(ByVal value1 As Object) As Integer{0}" +
 609                                 "    End Function{0}" +
 610                                 "End Class{0}", Writer.NewLine), code);
 611                 }
 612
 613                 /// <summary>
 614                 /// Ensure that a method with a PrivateImplementationType and with
 615                 /// the same name does not qualify as an overload.
 616                 /// </summary>
 617                 [Test]
 618                 public override void MethodOverloadsTest3 ()
 619                 {
 620                         string code = GenerateMethodOverloads3 ();
 621                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 622                                 "Public Class Test1{0}" +
 623                                 "    {0}" +
 624                                 "    Public Overridable Sub Execute(){0}" +
 625                                 "    End Sub{0}" +
 626                                 "    {0}" +
 627                                 "    Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
 628                                 "    End Function{0}" +
 629                                 "End Class{0}", Writer.NewLine), code);
 630                 }
 631
 632                 /// <summary>
 633                 /// Ensure no access modifiers are output if PrivateImplementationType
 634                 /// is set.
 635                 /// </summary>
 636                 [Test]
 637                 public override void MethodPrivateImplementationType ()
 638                 {
 639                         string code = GenerateMethodPrivateImplementationType ();
 640                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 641                                 "Public Class Test1{0}" +
 642                                 "    {0}" +
 643                                 "    Overridable Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
 644                                 "    End Function{0}" +
 645                                 "End Class{0}", Writer.NewLine), code);
 646                 }
 647
 648                 /// <summary>
 649                 /// If both ImplementationTypes and PrivateImplementationType are set,
 650                 /// then only ImplementationTypes are output.
 651                 /// </summary>
 652                 [Test]
 653                 public override void MethodImplementationTypeOrder ()
 654                 {
 655                         string code = GenerateMethodImplementationTypeOrder ();
 656                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 657                                 "Public Class Test1{0}" +
 658                                 "    {0}" +
 659                                 "    Overridable Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements IPolicy.Execute{0}" +
 660                                 "    End Function{0}" +
 661                                 "End Class{0}", Writer.NewLine), code);
 662                 }
 663
 664                 [Test]
 665                 public override void MethodReturnTypeAttributes ()
 666                 {
 667                         string code = GenerateMethodReturnTypeAttributes ();
 668                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 669                                 "Public Class Test1{0}" +
 670                                 "    {0}" +
 671                                 "    <A(),  _{0}" +
 672                                 "     B()>  _{0}" +
 673                                 "    Public Overridable Function Execute() As <C(A1:=false, A2:=true), D()> Integer{0}" +
 674                                 "    End Function{0}" +
 675                                 "End Class{0}", Writer.NewLine), code);
 676                 }
 677
 678                 [Test]
 679                 public override void ConstructorAttributesTest ()
 680                 {
 681                         string code = GenerateConstructorAttributes ();
 682                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 683                                 "Public Class Test1{0}" +
 684                                 "    {0}" +
 685                                 "    <A(),  _{0}" +
 686                                 "     B()>  _{0}" +
 687                                 "    Private Sub New(){0}" +
 688                                 "        MyBase.New{0}" +
 689                                 "    End Sub{0}" +
 690                                 "End Class{0}", Writer.NewLine), code);
 691                 }
 692
 693                 [Test]
 694                 public override void ConstructorParametersTest ()
 695                 {
 696                         string code = GenerateConstructorParameters ();
 697                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 698                                 "Public Class Test1{0}" +
 699                                 "    {0}" +
 700                                 "    Public Sub New(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer){0}" +
 701                                 "        MyBase.New{0}" +
 702                                 "    End Sub{0}" +
 703                                 "End Class{0}", Writer.NewLine), code);
 704                 }
 705
 706                 [Test]
 707                 public override void ConstructorParameterAttributesTest ()
 708                 {
 709                         string code = GenerateConstructorParameterAttributes ();
 710                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 711                                 "Public Class Test1{0}" +
 712                                 "    {0}" +
 713                                 "    Public Sub New(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer){0}" +
 714                                 "        MyBase.New{0}" +
 715                                 "    End Sub{0}" +
 716                                 "End Class{0}", Writer.NewLine), code);
 717                 }
 718
 719                 [Test]
 720                 public override void BaseConstructorSingleArg ()
 721                 {
 722                         string code = GenerateBaseConstructor (false);
 723                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 724                                 "Public Class Test1{0}" +
 725                                 "    {0}" +
 726                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
 727                                 "        MyBase.New(value1){0}" +
 728                                 "    End Sub{0}" +
 729                                 "End Class{0}", Writer.NewLine), code);
 730                 }
 731
 732                 [Test]
 733                 public override void BaseConstructorMultipleArgs ()
 734                 {
 735                         string code = GenerateBaseConstructor (true);
 736                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 737                                 "Public Class Test1{0}" +
 738                                 "    {0}" +
 739                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
 740                                 "        MyBase.New(value1, value2){0}" +
 741                                 "    End Sub{0}" +
 742                                 "End Class{0}", Writer.NewLine), code);
 743                 }
 744
 745                 [Test]
 746                 public override void ChainedConstructorSingleArg ()
 747                 {
 748                         string code = GenerateChainedConstructor (false);
 749                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 750                                 "Public Class Test1{0}" +
 751                                 "    {0}" +
 752                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
 753                                 "        Me.New(value1){0}" +
 754                                 "    End Sub{0}" +
 755                                 "End Class{0}", Writer.NewLine), code);
 756                 }
 757
 758                 [Test]
 759                 public override void ChainedConstructorMultipleArgs ()
 760                 {
 761                         string code = GenerateChainedConstructor (true);
 762                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 763                                 "Public Class Test1{0}" +
 764                                 "    {0}" +
 765                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
 766                                 "        Me.New(value1, value2){0}" +
 767                                 "    End Sub{0}" +
 768                                 "End Class{0}", Writer.NewLine), code);
 769                 }
 770         }
 771
 772         [TestFixture]
 773         [Category ("NotWorking")]
 774         public class CodeGeneratorFromTypeTest_Delegate : CodeGeneratorFromTypeTestBase
 775         {
 776                 private CodeTypeDeclaration _typeDeclaration;
 777                 private ICodeGenerator _codeGenerator;
 778
 779                 protected override ICodeGenerator CodeGenerator
 780                 {
 781                         get { return _codeGenerator; }
 782                 }
 783
 784                 protected override CodeTypeDeclaration TypeDeclaration
 785                 {
 786                         get { return _typeDeclaration; }
 787                 }
 788
 789                 [SetUp]
 790                 public override void SetUp ()
 791                 {
 792                         base.SetUp ();
 793                         _typeDeclaration = new CodeTypeDelegate ();
 794
 795                         CodeDomProvider provider = new VBCodeProvider ();
 796                         _codeGenerator = provider.CreateGenerator ();
 797                 }
 798
 799                 [Test]
 800                 public override void DefaultTypeTest ()
 801                 {
 802                         string code = GenerateDefaultType ();
 803                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 804                                 "Public Delegate Sub (){0}", Writer.NewLine), code);
 805                 }
 806
 807                 [Test]
 808                 [ExpectedException (typeof (NullReferenceException))]
 809                 public override void NullTypeTest ()
 810                 {
 811                         GenerateNullType ();
 812                 }
 813
 814                 [Test]
 815                 public override void SimpleTypeTest ()
 816                 {
 817                         string code = GenerateSimpleType ();
 818                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 819                                 "Public Delegate Sub Test1(){0}", Writer.NewLine), code);
 820                 }
 821
 822                 [Test]
 823                 public override void AttributesAndTypeTest ()
 824                 {
 825                         string code = GenerateAttributesAndType ();
 826                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 827                                 "<A(),  _{0}" +
 828                                 " B()>  _{0}" +
 829                                 "Public Delegate Sub Test1(){0}", Writer.NewLine), code);
 830                 }
 831
 832                 [Test]
 833                 public override void EventMembersTypeTest1 ()
 834                 {
 835                         string code = GenerateEventMembersType1 ();
 836                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 837                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 838                 }
 839
 840                 [Test]
 841                 public override void EventMembersTypeTest2 ()
 842                 {
 843                         string code = GenerateEventMembersType2 ();
 844                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 845                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 846                 }
 847
 848                 [Test]
 849                 public override void EventImplementationTypes ()
 850                 {
 851                         string code = GenerateEventImplementationTypes ();
 852                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 853                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 854                 }
 855
 856                 /// <summary>
 857                 /// Ensure no access modifiers are output if PrivateImplementationType
 858                 /// is set.
 859                 /// </summary>
 860                 [Test]
 861                 public override void EventPrivateImplementationType ()
 862                 {
 863                         string code = GenerateEventPrivateImplementationType ();
 864                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 865                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 866                 }
 867
 868                 /// <summary>
 869                 /// If both ImplementationTypes and PrivateImplementationType are set,
 870                 /// then only ImplementationTypes are output.
 871                 /// </summary>
 872                 [Test]
 873                 public override void EventImplementationTypeOrder ()
 874                 {
 875                         string code = GenerateEventImplementationTypeOrder ();
 876                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 877                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 878                 }
 879
 880                 [Test]
 881                 public override void FieldMembersTypeTest1 ()
 882                 {
 883                         string code = GenerateFieldMembersType1 ();
 884                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 885                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 886                 }
 887
 888                 [Test]
 889                 public override void FieldMembersTypeTest2 ()
 890                 {
 891                         string code = GenerateFieldMembersType2 ();
 892                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 893                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 894                 }
 895
 896                 [Test]
 897                 public override void PropertyMembersTypeTest1 ()
 898                 {
 899                         string code = GeneratePropertyMembersAttributes ();
 900                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 901                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 902                 }
 903
 904                 [Test]
 905                 public override void PropertyMembersTypeTest2 ()
 906                 {
 907                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
 908                                 false, false);
 909                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 910                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 911                 }
 912
 913                 [Test]
 914                 public override void PropertyMembersTypeGetOnly ()
 915                 {
 916                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
 917                                 true, false);
 918                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 919                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 920                 }
 921
 922                 [Test]
 923                 public override void PropertyMembersTypeSetOnly ()
 924                 {
 925                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
 926                                 false, true);
 927                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 928                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 929                 }
 930
 931                 [Test]
 932                 public override void PropertyMembersTypeGetSet ()
 933                 {
 934                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
 935                                 true, true);
 936                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 937                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 938                 }
 939
 940                 [Test]
 941                 public override void PropertyMembersTypeFamilyOrAssembly ()
 942                 {
 943                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
 944                                 false, false);
 945                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 946                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 947                 }
 948
 949                 [Test]
 950                 public override void PropertyMembersTypeAssembly ()
 951                 {
 952                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
 953                                 false, false);
 954                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 955                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 956                 }
 957
 958                 [Test]
 959                 public override void PropertyParametersTest ()
 960                 {
 961                         string code = GeneratePropertyParameters ();
 962                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 963                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 964                 }
 965
 966                 [Test]
 967                 public override void PropertyIndexerTest1 ()
 968                 {
 969                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
 970                                 false, false, true);
 971                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 972                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 973                 }
 974
 975                 [Test]
 976                 public override void PropertyIndexerTest2 ()
 977                 {
 978                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
 979                                 false, false, false);
 980                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 981                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 982                 }
 983
 984                 [Test]
 985                 public override void PropertyIndexerGetOnly ()
 986                 {
 987                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
 988                                 true, false, true);
 989                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 990                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
 991                 }
 992
 993                 [Test]
 994                 public override void PropertyIndexerSetOnly ()
 995                 {
 996                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
 997                                 false, true, true);
 998                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 999                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1000                 }
1001
1002                 [Test]
1003                 public override void PropertyImplementationTypes ()
1004                 {
1005                         string code = GeneratePropertyImplementationTypes ();
1006                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1007                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1008                 }
1009
1010                 [Test]
1011                 public override void PropertyOverloadsTest1 ()
1012                 {
1013                         string code = GeneratePropertyOverloads1 ();
1014                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1015                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1016                 }
1017
1018                 [Test]
1019                 public override void PropertyOverloadsTest2 ()
1020                 {
1021                         string code = GeneratePropertyOverloads2 ();
1022                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1023                                 "Public Delegate Sub Test1(){0}{0}{0}", Writer.NewLine), code);
1024                 }
1025
1026                 [Test]
1027                 public override void PropertyOverloadsTest3 ()
1028                 {
1029                         string code = GeneratePropertyOverloads3 ();
1030                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1031                                 "Public Delegate Sub Test1(){0}{0}{0}", Writer.NewLine), code);
1032                 }
1033
1034                 [Test]
1035                 public override void PropertyPrivateImplementationType ()
1036                 {
1037                         string code = GeneratePropertyPrivateImplementationType ();
1038                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1039                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1040                 }
1041
1042                 [Test]
1043                 public override void PropertyImplementationTypeOrder ()
1044                 {
1045                         string code = GeneratePropertyImplementationTypeOrder ();
1046                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1047                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1048                 }
1049
1050                 [Test]
1051                 public override void MethodMembersTypeTest1 ()
1052                 {
1053                         string code = GenerateMethodMembersType1 ();
1054                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1055                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1056                 }
1057
1058                 [Test]
1059                 public override void MethodMembersTypeTest2 ()
1060                 {
1061                         string code = GenerateMethodMembersType2 ();
1062                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1063                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1064                 }
1065
1066                 [Test]
1067                 public override void MethodMembersTypeTest3 ()
1068                 {
1069                         string code = GenerateMethodMembersType3 ();
1070                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1071                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1072                 }
1073
1074                 [Test]
1075                 public override void MethodImplementationTypes ()
1076                 {
1077                         string code = GenerateMethodImplementationTypes ();
1078                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1079                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1080                 }
1081
1082                 [Test]
1083                 public override void MethodOverloadsTest1 ()
1084                 {
1085                         string code = GenerateMethodOverloads1 ();
1086                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1087                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1088                 }
1089
1090                 [Test]
1091                 public override void MethodOverloadsTest2 ()
1092                 {
1093                         string code = GenerateMethodOverloads2 ();
1094                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1095                                 "Public Delegate Sub Test1(){0}{0}{0}", Writer.NewLine), code);
1096                 }
1097
1098                 [Test]
1099                 public override void MethodOverloadsTest3 ()
1100                 {
1101                         string code = GenerateMethodOverloads3 ();
1102                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1103                                 "Public Delegate Sub Test1(){0}{0}{0}", Writer.NewLine), code);
1104                 }
1105
1106                 [Test]
1107                 public override void MethodPrivateImplementationType ()
1108                 {
1109                         string code = GenerateMethodPrivateImplementationType ();
1110                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1111                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1112                 }
1113
1114                 [Test]
1115                 public override void MethodImplementationTypeOrder ()
1116                 {
1117                         string code = GenerateMethodImplementationTypeOrder ();
1118                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1119                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1120                 }
1121
1122                 [Test]
1123                 public override void MethodReturnTypeAttributes ()
1124                 {
1125                         string code = GenerateMethodReturnTypeAttributes ();
1126                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1127                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1128                 }
1129
1130                 [Test]
1131                 public override void ConstructorAttributesTest ()
1132                 {
1133                         string code = GenerateConstructorAttributes ();
1134                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1135                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1136                 }
1137
1138                 [Test]
1139                 public override void ConstructorParametersTest ()
1140                 {
1141                         string code = GenerateConstructorParameters ();
1142                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1143                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1144                 }
1145
1146                 [Test]
1147                 public override void ConstructorParameterAttributesTest ()
1148                 {
1149                         string code = GenerateConstructorParameterAttributes ();
1150                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1151                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1152                 }
1153
1154                 [Test]
1155                 public override void BaseConstructorSingleArg ()
1156                 {
1157                         string code = GenerateBaseConstructor (false);
1158                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1159                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1160                 }
1161
1162                 [Test]
1163                 public override void BaseConstructorMultipleArgs ()
1164                 {
1165                         string code = GenerateBaseConstructor (true);
1166                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1167                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1168                 }
1169
1170                 [Test]
1171                 public override void ChainedConstructorSingleArg ()
1172                 {
1173                         string code = GenerateChainedConstructor (false);
1174                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1175                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1176                 }
1177
1178                 [Test]
1179                 public override void ChainedConstructorMultipleArgs ()
1180                 {
1181                         string code = GenerateChainedConstructor (true);
1182                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1183                                 "Public Delegate Sub Test1(){0}{0}", Writer.NewLine), code);
1184                 }
1185         }
1186
1187         [TestFixture]
1188         [Category ("NotWorking")]
1189         public class CodeGeneratorFromTypeTest_Interface : CodeGeneratorFromTypeTestBase
1190         {
1191                 private CodeTypeDeclaration _typeDeclaration;
1192                 private ICodeGenerator _codeGenerator;
1193
1194                 protected override ICodeGenerator CodeGenerator
1195                 {
1196                         get { return _codeGenerator; }
1197                 }
1198
1199                 protected override CodeTypeDeclaration TypeDeclaration
1200                 {
1201                         get { return _typeDeclaration; }
1202                 }
1203
1204                 [SetUp]
1205                 public override void SetUp ()
1206                 {
1207                         base.SetUp ();
1208                         _typeDeclaration = new CodeTypeDeclaration ();
1209                         _typeDeclaration.IsInterface = true;
1210
1211                         CodeDomProvider provider = new VBCodeProvider ();
1212                         _codeGenerator = provider.CreateGenerator ();
1213                 }
1214
1215                 [Test]
1216                 public override void DefaultTypeTest ()
1217                 {
1218                         string code = GenerateDefaultType ();
1219                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1220                                 "Public Interface {0}" +
1221                                 "End Interface{0}", Writer.NewLine), code);
1222                 }
1223
1224                 [Test]
1225                 [ExpectedException (typeof (NullReferenceException))]
1226                 public override void NullTypeTest ()
1227                 {
1228                         GenerateNullType ();
1229                 }
1230
1231                 [Test]
1232                 public override void SimpleTypeTest ()
1233                 {
1234                         string code = GenerateSimpleType ();
1235                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1236                                 "Public Interface Test1{0}" +
1237                                 "End Interface{0}", Writer.NewLine), code);
1238                 }
1239
1240                 [Test]
1241                 public override void AttributesAndTypeTest ()
1242                 {
1243                         string code = GenerateAttributesAndType ();
1244                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1245                                 "<A(),  _{0}" +
1246                                 " B()>  _{0}" +
1247                                 "Public Interface Test1{0}" +
1248                                 "End Interface{0}", Writer.NewLine), code);
1249                 }
1250
1251                 [Test]
1252                 public override void EventMembersTypeTest1 ()
1253                 {
1254                         string code = GenerateEventMembersType1 ();
1255                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1256                                 "Public Interface Test1{0}" +
1257                                 "    {0}" +
1258                                 "    <A(),  _{0}" +
1259                                 "     B()>  _{0}" +
1260                                 "    Private Event  As System.Void{0}" +
1261                                 "End Interface{0}", Writer.NewLine), code);
1262                 }
1263
1264                 [Test]
1265                 public override void EventMembersTypeTest2 ()
1266                 {
1267                         string code = GenerateEventMembersType2 ();
1268                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1269                                 "Public Interface Test1{0}" +
1270                                 "    {0}" +
1271                                 "    Public Event Click As Integer{0}" +
1272                                 "End Interface{0}", Writer.NewLine), code);
1273                 }
1274
1275                 [Test]
1276                 public override void EventImplementationTypes ()
1277                 {
1278                         string code = GenerateEventImplementationTypes ();
1279                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1280                                 "Public Interface Test1{0}" +
1281                                 "    {0}" +
1282 #if NET_2_0
1283                                 "    Friend Event Click As Integer Implements IPolicy.Click , IWhatever.Click{0}" +
1284 #else
1285                                 "    Friend Event Click As Integer{0}" +
1286 #endif
1287                                 "End Interface{0}", Writer.NewLine), code);
1288                 }
1289
1290                 [Test]
1291                 public override void EventPrivateImplementationType ()
1292                 {
1293                         string code = GenerateEventPrivateImplementationType ();
1294                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1295                                 "Public Interface Test1{0}" +
1296                                 "    {0}" +
1297 #if NET_2_0
1298                                 "    Protected Event System_Int32_Click As Integer Implements Integer.Click{0}" +
1299 #else
1300                                 "    Protected Event Click As Integer{0}" +
1301 #endif
1302                                 "End Interface{0}", Writer.NewLine), code);
1303                 }
1304
1305                 [Test]
1306                 public override void EventImplementationTypeOrder ()
1307                 {
1308                         string code = GenerateEventImplementationTypeOrder ();
1309                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1310                                 "Public Interface Test1{0}" +
1311                                 "    {0}" +
1312 #if NET_2_0
1313                                 "    Public Event System_Int32_Click As Integer Implements IPolicy.Click{0}" +
1314 #else
1315                                 "    Public Event Click As Integer{0}" +
1316 #endif
1317                                 "End Interface{0}", Writer.NewLine), code);
1318                 }
1319
1320                 [Test]
1321                 public override void FieldMembersTypeTest1 ()
1322                 {
1323                         string code = GenerateFieldMembersType1 ();
1324                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1325                                 "Public Interface Test1{0}" +
1326                                 "    {0}" +
1327                                 "End Interface{0}", Writer.NewLine), code);
1328                 }
1329
1330                 [Test]
1331                 public override void FieldMembersTypeTest2 ()
1332                 {
1333                         string code = GenerateFieldMembersType2 ();
1334                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1335                                 "Public Interface Test1{0}" +
1336                                 "    {0}" +
1337                                 "End Interface{0}", Writer.NewLine), code);
1338                 }
1339
1340                 [Test]
1341                 public override void PropertyMembersTypeTest1 ()
1342                 {
1343                         string code = GeneratePropertyMembersAttributes ();
1344                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1345                                 "Public Interface Test1{0}" +
1346                                 "    {0}" +
1347                                 "    <A(),  _{0}" +
1348                                 "     B()>  _{0}" +
1349 #if NET_2_0
1350                                 "    Property () As System.Void{0}" +
1351 #else
1352                                 "    Property  As System.Void{0}" +
1353 #endif
1354                                 "End Interface{0}", Writer.NewLine), code);
1355                 }
1356
1357                 [Test]
1358                 public override void PropertyMembersTypeTest2 ()
1359                 {
1360                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
1361                                 false, false);
1362                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1363                                 "Public Interface Test1{0}" +
1364                                 "    {0}" +
1365 #if NET_2_0
1366                                 "    Property Name() As Integer{0}" +
1367 #else
1368                                 "    Property Name As Integer{0}" +
1369 #endif
1370                                 "End Interface{0}", Writer.NewLine), code);
1371                 }
1372
1373                 [Test]
1374                 public override void PropertyMembersTypeGetOnly ()
1375                 {
1376                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1377                                 true, false);
1378                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1379                                 "Public Interface Test1{0}" +
1380                                 "    {0}" +
1381 #if NET_2_0
1382                                 "    ReadOnly Property Name() As Integer{0}" +
1383 #else
1384                                 "    ReadOnly Property Name As Integer{0}" +
1385 #endif
1386                                 "End Interface{0}", Writer.NewLine), code);
1387                 }
1388
1389                 [Test]
1390                 public override void PropertyMembersTypeSetOnly ()
1391                 {
1392                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1393                                 false, true);
1394                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1395                                 "Public Interface Test1{0}" +
1396                                 "    {0}" +
1397 #if NET_2_0
1398                                 "    WriteOnly Property Name() As Integer{0}" +
1399 #else
1400                                 "    WriteOnly Property Name As Integer{0}" +
1401 #endif
1402                                 "End Interface{0}", Writer.NewLine), code);
1403                 }
1404
1405                 [Test]
1406                 public override void PropertyMembersTypeGetSet ()
1407                 {
1408                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1409                                 true, true);
1410                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1411                                 "Public Interface Test1{0}" +
1412                                 "    {0}" +
1413 #if NET_2_0
1414                                 "    Property Name() As Integer{0}" +
1415 #else
1416                                 "    Property Name As Integer{0}" +
1417 #endif
1418                                 "End Interface{0}", Writer.NewLine), code);
1419                 }
1420
1421                 [Test]
1422                 public override void PropertyMembersTypeFamilyOrAssembly ()
1423                 {
1424                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
1425                                 false, false);
1426                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1427                                 "Public Interface Test1{0}" +
1428                                 "    {0}" +
1429 #if NET_2_0
1430                                 "    Property Name() As Integer{0}" +
1431 #else
1432                                 "    Property Name As Integer{0}" +
1433 #endif
1434                                 "End Interface{0}", Writer.NewLine), code);
1435                 }
1436
1437                 [Test]
1438                 public override void PropertyMembersTypeAssembly ()
1439                 {
1440                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1441                                 false, false);
1442                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1443                                 "Public Interface Test1{0}" +
1444                                 "    {0}" +
1445 #if NET_2_0
1446                                 "    Property Name() As Integer{0}" +
1447 #else
1448                                 "    Property Name As Integer{0}" +
1449 #endif
1450                                 "End Interface{0}", Writer.NewLine), code);
1451                 }
1452
1453                 [Test]
1454                 public override void PropertyParametersTest ()
1455                 {
1456                         string code = GeneratePropertyParameters ();
1457                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1458                                 "Public Interface Test1{0}" +
1459                                 "    {0}" +
1460                                 "    Property Name(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
1461                                 "End Interface{0}", Writer.NewLine), code);
1462                 }
1463
1464                 [Test]
1465                 public override void PropertyIndexerTest1 ()
1466                 {
1467                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
1468                                 false, false, true);
1469                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1470                                 "Public Interface Test1{0}" +
1471                                 "    {0}" +
1472                                 "    Default Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
1473                                 "End Interface{0}", Writer.NewLine), code);
1474                 }
1475
1476                 [Test]
1477                 public override void PropertyIndexerTest2 ()
1478                 {
1479                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
1480                                 false, false, false);
1481                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1482                                 "Public Interface Test1{0}" +
1483                                 "    {0}" +
1484 #if NET_2_0
1485                                 "    Property iTem() As Integer{0}" +
1486 #else
1487                                 "    Property iTem As Integer{0}" +
1488 #endif
1489                                 "End Interface{0}", Writer.NewLine), code);
1490                 }
1491
1492                 [Test]
1493                 public override void PropertyIndexerGetOnly ()
1494                 {
1495                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
1496                                 true, false, true);
1497                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1498                                 "Public Interface Test1{0}" +
1499                                 "    {0}" +
1500                                 "    Default ReadOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
1501                                 "End Interface{0}", Writer.NewLine), code);
1502                 }
1503
1504                 [Test]
1505                 public override void PropertyIndexerSetOnly ()
1506                 {
1507                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
1508                                 false, true, true);
1509                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1510                                 "Public Interface Test1{0}" +
1511                                 "    {0}" +
1512                                 "    Default WriteOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
1513                                 "End Interface{0}", Writer.NewLine), code);
1514                 }
1515
1516                 [Test]
1517                 public override void PropertyImplementationTypes ()
1518                 {
1519                         string code = GeneratePropertyImplementationTypes ();
1520                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1521                                 "Public Interface Test1{0}" +
1522                                 "    {0}" +
1523 #if NET_2_0
1524                                 "    Property Name() As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
1525 #else
1526                                 "    Property Name As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
1527 #endif
1528                                 "End Interface{0}", Writer.NewLine), code);
1529                 }
1530
1531                 [Test]
1532                 public override void PropertyOverloadsTest1 ()
1533                 {
1534                         string code = GeneratePropertyOverloads1 ();
1535                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1536                                 "Public Interface Test1{0}" +
1537                                 "    {0}" +
1538 #if NET_2_0
1539                                 "    Property Name() As Integer{0}" +
1540 #else
1541                                 "    Property Name As Integer{0}" +
1542 #endif
1543                                 "End Interface{0}", Writer.NewLine), code);
1544                 }
1545
1546                 [Test]
1547                 public override void PropertyOverloadsTest2 ()
1548                 {
1549                         string code = GeneratePropertyOverloads2 ();
1550                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1551                                 "Public Interface Test1{0}" +
1552                                 "    {0}" +
1553 #if NET_2_0
1554                                 "    Property Name() As Integer{0}" +
1555 #else
1556                                 "    Property Name As Integer{0}" +
1557 #endif
1558                                 "    {0}" +
1559                                 "    Property Name(ByVal value1 As Object) As Integer{0}" +
1560                                 "End Interface{0}", Writer.NewLine), code);
1561                 }
1562
1563                 [Test]
1564                 public override void PropertyOverloadsTest3 ()
1565                 {
1566                         string code = GeneratePropertyOverloads3 ();
1567                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1568                                 "Public Interface Test1{0}" +
1569                                 "    {0}" +
1570 #if NET_2_0
1571                                 "    Property Name() As Integer{0}" +
1572 #else
1573                                 "    Property Name As Integer{0}" +
1574 #endif
1575                                 "    {0}" +
1576                                 "    Property System_Int32_Name(ByVal value1 As Object) As Integer Implements Integer.Name{0}" +
1577                                 "End Interface{0}", Writer.NewLine), code);
1578                 }
1579
1580                 [Test]
1581                 public override void PropertyPrivateImplementationType ()
1582                 {
1583                         string code = GeneratePropertyPrivateImplementationType ();
1584                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1585                                 "Public Interface Test1{0}" +
1586                                 "    {0}" +
1587                                 "    Property System_Int32_Item(ByVal value1 As Object) As Integer Implements Integer.Item{0}" +
1588                                 "End Interface{0}", Writer.NewLine), code);
1589                 }
1590
1591                 [Test]
1592                 public override void PropertyImplementationTypeOrder ()
1593                 {
1594                         string code = GeneratePropertyImplementationTypeOrder ();
1595                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1596                                 "Public Interface Test1{0}" +
1597                                 "    {0}" +
1598                                 "    Property System_Int32_Item(ByVal value1 As Object) As Integer Implements IPolicy.Item{0}" +
1599                                 "End Interface{0}", Writer.NewLine), code);
1600                 }
1601
1602                 [Test]
1603                 public override void MethodMembersTypeTest1 ()
1604                 {
1605                         string code = GenerateMethodMembersType1 ();
1606                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1607                                 "Public Interface Test1{0}" +
1608                                 "    {0}" +
1609                                 "    <A(),  _{0}" +
1610                                 "     B()>  _{0}" +
1611                                 "    Sub (){0}" +
1612                                 "End Interface{0}", Writer.NewLine), code);
1613                 }
1614
1615                 [Test]
1616                 public override void MethodMembersTypeTest2 ()
1617                 {
1618                         string code = GenerateMethodMembersType2 ();
1619                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1620                                 "Public Interface Test1{0}" +
1621                                 "    {0}" +
1622                                 "    Function Something(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer) As Integer{0}" +
1623                                 "End Interface{0}", Writer.NewLine), code);
1624                 }
1625
1626                 [Test]
1627                 public override void MethodMembersTypeTest3 ()
1628                 {
1629                         string code = GenerateMethodMembersType3 ();
1630                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1631                                 "Public Interface Test1{0}" +
1632                                 "    {0}" +
1633                                 "    Function Something(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer) As Integer{0}" +
1634                                 "End Interface{0}", Writer.NewLine), code);
1635                 }
1636
1637                 [Test]
1638                 public override void MethodImplementationTypes ()
1639                 {
1640                         string code = GenerateMethodImplementationTypes ();
1641                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1642                                 "Public Interface Test1{0}" +
1643                                 "    {0}" +
1644                                 "    Function Execute() As Integer Implements IPolicy.Execute , IWhatever.Execute{0}" +
1645                                 "End Interface{0}", Writer.NewLine), code);
1646                 }
1647
1648                 [Test]
1649                 public override void MethodOverloadsTest1 ()
1650                 {
1651                         string code = GenerateMethodOverloads1 ();
1652                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1653                                 "Public Interface Test1{0}" +
1654                                 "    {0}" +
1655                                 "    Function Execute() As Integer{0}" +
1656                                 "End Interface{0}", Writer.NewLine), code);
1657                 }
1658
1659                 [Test]
1660                 public override void MethodOverloadsTest2 ()
1661                 {
1662                         string code = GenerateMethodOverloads2 ();
1663                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1664                                 "Public Interface Test1{0}" +
1665                                 "    {0}" +
1666                                 "    Sub Execute(){0}" +
1667                                 "    {0}" +
1668                                 "    Function Execute(ByVal value1 As Object) As Integer{0}" +
1669                                 "End Interface{0}", Writer.NewLine), code);
1670                 }
1671
1672                 [Test]
1673                 public override void MethodOverloadsTest3 ()
1674                 {
1675                         string code = GenerateMethodOverloads3 ();
1676                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1677                                 "Public Interface Test1{0}" +
1678                                 "    {0}" +
1679                                 "    Sub Execute(){0}" +
1680                                 "    {0}" +
1681                                 "    Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
1682                                 "End Interface{0}", Writer.NewLine), code);
1683                 }
1684
1685                 [Test]
1686                 public override void MethodPrivateImplementationType ()
1687                 {
1688                         string code = GenerateMethodPrivateImplementationType ();
1689                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1690                                 "Public Interface Test1{0}" +
1691                                 "    {0}" +
1692                                 "    Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
1693                                 "End Interface{0}", Writer.NewLine), code);
1694                 }
1695
1696                 [Test]
1697                 public override void MethodImplementationTypeOrder ()
1698                 {
1699                         string code = GenerateMethodImplementationTypeOrder ();
1700                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1701                                 "Public Interface Test1{0}" +
1702                                 "    {0}" +
1703                                 "    Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements IPolicy.Execute{0}" +
1704                                 "End Interface{0}", Writer.NewLine), code);
1705                 }
1706
1707                 [Test]
1708                 public override void MethodReturnTypeAttributes ()
1709                 {
1710                         string code = GenerateMethodReturnTypeAttributes ();
1711                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1712                                 "Public Interface Test1{0}" +
1713                                 "    {0}" +
1714                                 "    <A(),  _{0}" +
1715                                 "     B()>  _{0}" +
1716                                 "    Function Execute() As <C(A1:=false, A2:=true), D()> Integer{0}" +
1717                                 "End Interface{0}", Writer.NewLine), code);
1718                 }
1719
1720                 [Test]
1721                 public override void ConstructorAttributesTest ()
1722                 {
1723                         string code = GenerateConstructorAttributes ();
1724                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1725                                 "Public Interface Test1{0}" +
1726                                 "    {0}" +
1727                                 "End Interface{0}", Writer.NewLine), code);
1728                 }
1729
1730                 [Test]
1731                 public override void ConstructorParametersTest ()
1732                 {
1733                         string code = GenerateConstructorParameters ();
1734                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1735                                 "Public Interface Test1{0}" +
1736                                 "    {0}" +
1737                                 "End Interface{0}", Writer.NewLine), code);
1738                 }
1739
1740                 [Test]
1741                 public override void ConstructorParameterAttributesTest ()
1742                 {
1743                         string code = GenerateConstructorParameterAttributes ();
1744                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1745                                 "Public Interface Test1{0}" +
1746                                 "    {0}" +
1747                                 "End Interface{0}", Writer.NewLine), code);
1748                 }
1749
1750                 [Test]
1751                 public override void BaseConstructorSingleArg ()
1752                 {
1753                         string code = GenerateBaseConstructor (false);
1754                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1755                                 "Public Interface Test1{0}" +
1756                                 "    {0}" +
1757                                 "End Interface{0}", Writer.NewLine), code);
1758                 }
1759
1760                 [Test]
1761                 public override void BaseConstructorMultipleArgs ()
1762                 {
1763                         string code = GenerateBaseConstructor (true);
1764                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1765                                 "Public Interface Test1{0}" +
1766                                 "    {0}" +
1767                                 "End Interface{0}", Writer.NewLine), code);
1768                 }
1769
1770                 [Test]
1771                 public override void ChainedConstructorSingleArg ()
1772                 {
1773                         string code = GenerateChainedConstructor (false);
1774                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1775                                 "Public Interface Test1{0}" +
1776                                 "    {0}" +
1777                                 "End Interface{0}", Writer.NewLine), code);
1778                 }
1779
1780                 [Test]
1781                 public override void ChainedConstructorMultipleArgs ()
1782                 {
1783                         string code = GenerateChainedConstructor (true);
1784                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1785                                 "Public Interface Test1{0}" +
1786                                 "    {0}" +
1787                                 "End Interface{0}", Writer.NewLine), code);
1788                 }
1789         }
1790
1791         [TestFixture]
1792         [Category ("NotWorking")]
1793         public class CodeGeneratorFromTypeTest_Struct : CodeGeneratorFromTypeTestBase
1794         {
1795                 private CodeTypeDeclaration _typeDeclaration;
1796                 private ICodeGenerator _codeGenerator;
1797
1798                 protected override ICodeGenerator CodeGenerator
1799                 {
1800                         get { return _codeGenerator; }
1801                 }
1802
1803                 protected override CodeTypeDeclaration TypeDeclaration
1804                 {
1805                         get { return _typeDeclaration; }
1806                 }
1807
1808                 [SetUp]
1809                 public override void SetUp ()
1810                 {
1811                         base.SetUp ();
1812                         _typeDeclaration = new CodeTypeDeclaration ();
1813                         _typeDeclaration.IsStruct = true;
1814
1815                         CodeDomProvider provider = new VBCodeProvider ();
1816                         _codeGenerator = provider.CreateGenerator ();
1817                 }
1818
1819                 [Test]
1820                 public override void DefaultTypeTest ()
1821                 {
1822                         string code = GenerateDefaultType ();
1823                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1824                                 "Public Structure {0}" +
1825                                 "End Structure{0}", Writer.NewLine), code);
1826                 }
1827
1828                 [Test]
1829                 [ExpectedException (typeof (NullReferenceException))]
1830                 public override void NullTypeTest ()
1831                 {
1832                         GenerateNullType ();
1833                 }
1834
1835                 [Test]
1836                 public override void SimpleTypeTest ()
1837                 {
1838                         string code = GenerateSimpleType ();
1839                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1840                                 "Public Structure Test1{0}" +
1841                                 "End Structure{0}", Writer.NewLine), code);
1842                 }
1843
1844                 [Test]
1845                 public override void AttributesAndTypeTest ()
1846                 {
1847                         string code = GenerateAttributesAndType ();
1848                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1849                                 "<A(),  _{0}" +
1850                                 " B()>  _{0}" +
1851                                 "Public Structure Test1{0}" +
1852                                 "End Structure{0}", Writer.NewLine), code);
1853                 }
1854
1855                 [Test]
1856                 public override void EventMembersTypeTest1 ()
1857                 {
1858                         string code = GenerateEventMembersType1 ();
1859                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1860                                 "Public Structure Test1{0}" +
1861                                 "    {0}" +
1862                                 "    <A(),  _{0}" +
1863                                 "     B()>  _{0}" +
1864                                 "    Private Event  As System.Void{0}" +
1865                                 "End Structure{0}", Writer.NewLine), code);
1866                 }
1867
1868                 [Test]
1869                 public override void EventMembersTypeTest2 ()
1870                 {
1871                         string code = GenerateEventMembersType2 ();
1872                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1873                                 "Public Structure Test1{0}" +
1874                                 "    {0}" +
1875                                 "    Public Event Click As Integer{0}" +
1876                                 "End Structure{0}", Writer.NewLine), code);
1877                 }
1878
1879                 [Test]
1880                 public override void EventImplementationTypes ()
1881                 {
1882                         string code = GenerateEventImplementationTypes ();
1883                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1884                                 "Public Structure Test1{0}" +
1885                                 "    {0}" +
1886 #if NET_2_0
1887                                 "    Friend Event Click As Integer Implements IPolicy.Click , IWhatever.Click{0}" +
1888 #else
1889                                 "    Friend Event Click As Integer{0}" +
1890 #endif
1891                                 "End Structure{0}", Writer.NewLine), code);
1892                 }
1893
1894                 [Test]
1895                 public override void EventPrivateImplementationType ()
1896                 {
1897                         string code = GenerateEventPrivateImplementationType ();
1898                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1899                                 "Public Structure Test1{0}" +
1900                                 "    {0}" +
1901 #if NET_2_0
1902                                 "    Protected Event System_Int32_Click As Integer Implements Integer.Click{0}" +
1903 #else
1904                                 "    Protected Event Click As Integer{0}" +
1905 #endif
1906                                 "End Structure{0}", Writer.NewLine), code);
1907                 }
1908
1909                 [Test]
1910                 public override void EventImplementationTypeOrder ()
1911                 {
1912                         string code = GenerateEventImplementationTypeOrder ();
1913                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1914                                 "Public Structure Test1{0}" +
1915                                 "    {0}" +
1916 #if NET_2_0
1917                                 "    Public Event System_Int32_Click As Integer Implements IPolicy.Click{0}" +
1918 #else
1919                                 "    Public Event Click As Integer{0}" +
1920 #endif
1921                                 "End Structure{0}", Writer.NewLine), code);
1922                 }
1923
1924                 [Test]
1925                 public override void FieldMembersTypeTest1 ()
1926                 {
1927                         string code = GenerateFieldMembersType1 ();
1928                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1929                                 "Public Structure Test1{0}" +
1930                                 "    {0}" +
1931                                 "    <A(),  _{0}" +
1932                                 "     B()>  _{0}" +
1933                                 "    Private  As System.Void{0}" +
1934                                 "End Structure{0}", Writer.NewLine), code);
1935                 }
1936
1937                 [Test]
1938                 public override void FieldMembersTypeTest2 ()
1939                 {
1940                         string code = GenerateFieldMembersType2 ();
1941                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1942                                 "Public Structure Test1{0}" +
1943                                 "    {0}" +
1944                                 "    Public Name As Integer{0}" +
1945                                 "End Structure{0}", Writer.NewLine), code);
1946                 }
1947
1948                 [Test]
1949                 public override void PropertyMembersTypeTest1 ()
1950                 {
1951                         string code = GeneratePropertyMembersAttributes ();
1952                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1953                                 "Public Structure Test1{0}" +
1954                                 "    {0}" +
1955                                 "    <A(),  _{0}" +
1956                                 "     B()>  _{0}" +
1957 #if NET_2_0
1958                                 "    Private Property () As System.Void{0}" +
1959 #else
1960                                 "    Private Property  As System.Void{0}" +
1961 #endif
1962                                 "    End Property{0}" +
1963                                 "End Structure{0}", Writer.NewLine), code);
1964                 }
1965
1966                 [Test]
1967                 public override void PropertyMembersTypeTest2 ()
1968                 {
1969                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
1970                                 false, false);
1971                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1972                                 "Public Structure Test1{0}" +
1973                                 "    {0}" +
1974 #if NET_2_0
1975                                 "    Public Overridable Property Name() As Integer{0}" +
1976 #else
1977                                 "    Public Overridable Property Name As Integer{0}" +
1978 #endif
1979                                 "    End Property{0}" +
1980                                 "End Structure{0}", Writer.NewLine), code);
1981                 }
1982
1983                 [Test]
1984                 public override void PropertyMembersTypeGetOnly ()
1985                 {
1986                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1987                                 true, false);
1988                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1989                                 "Public Structure Test1{0}" +
1990                                 "    {0}" +
1991 #if NET_2_0
1992                                 "    Protected Overridable ReadOnly Property Name() As Integer{0}" +
1993 #else
1994                                 "    Protected Overridable ReadOnly Property Name As Integer{0}" +
1995 #endif
1996                                 "        Get{0}" +
1997                                 "        End Get{0}" +
1998                                 "    End Property{0}" +
1999                                 "End Structure{0}", Writer.NewLine), code);
2000                 }
2001
2002                 [Test]
2003                 public override void PropertyMembersTypeSetOnly ()
2004                 {
2005                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2006                                 false, true);
2007                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2008                                 "Public Structure Test1{0}" +
2009                                 "    {0}" +
2010 #if NET_2_0
2011                                 "    Friend Overridable WriteOnly Property Name() As Integer{0}" +
2012 #else
2013                                 "    Friend WriteOnly Property Name As Integer{0}" +
2014 #endif
2015                                 "        Set{0}" +
2016                                 "        End Set{0}" +
2017                                 "    End Property{0}" +
2018                                 "End Structure{0}", Writer.NewLine), code);
2019                 }
2020
2021                 [Test]
2022                 public override void PropertyMembersTypeGetSet ()
2023                 {
2024                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
2025                                 true, true);
2026                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2027                                 "Public Structure Test1{0}" +
2028                                 "    {0}" +
2029 #if NET_2_0
2030                                 "    Protected Overridable Property Name() As Integer{0}" +
2031 #else
2032                                 "    Protected Overridable Property Name As Integer{0}" +
2033 #endif
2034                                 "        Get{0}" +
2035                                 "        End Get{0}" +
2036                                 "        Set{0}" +
2037                                 "        End Set{0}" +
2038                                 "    End Property{0}" +
2039                                 "End Structure{0}", Writer.NewLine), code);
2040                 }
2041
2042 #if !NET_2_0
2043                 // A bug in MS.NET 1.x causes MemberAttributes.FamilyOrAssembly to be
2044                 // generated as Protected
2045                 [Category ("NotDotNet")]
2046 #endif
2047                 [Test]
2048                 public override void PropertyMembersTypeFamilyOrAssembly ()
2049                 {
2050                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
2051                                 false, false);
2052                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2053                                 "Public Structure Test1{0}" +
2054                                 "    {0}" +
2055 #if NET_2_0
2056                                 "    Protected Friend Property Name() As Integer{0}" +
2057 #else
2058                                 "    Protected Friend Property Name As Integer{0}" +
2059 #endif
2060                                 "    End Property{0}" +
2061                                 "End Structure{0}", Writer.NewLine), code);
2062                 }
2063
2064                 [Test]
2065                 public override void PropertyMembersTypeAssembly ()
2066                 {
2067                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2068                                 false, false);
2069                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2070                                 "Public Structure Test1{0}" +
2071                                 "    {0}" +
2072 #if NET_2_0
2073                                 "    Friend Overridable Property Name() As Integer{0}" +
2074 #else
2075                                 "    Friend Property Name As Integer{0}" +
2076 #endif
2077                                 "    End Property{0}" +
2078                                 "End Structure{0}", Writer.NewLine), code);
2079                 }
2080
2081                 [Test]
2082                 public override void PropertyParametersTest ()
2083                 {
2084                         string code = GeneratePropertyParameters ();
2085                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2086                                 "Public Structure Test1{0}" +
2087                                 "    {0}" +
2088                                 "    Public Overridable Property Name(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
2089                                 "    End Property{0}" +
2090                                 "End Structure{0}", Writer.NewLine), code);
2091                 }
2092
2093                 [Test]
2094                 public override void PropertyIndexerTest1 ()
2095                 {
2096                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
2097                                 false, false, true);
2098                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2099                                 "Public Structure Test1{0}" +
2100                                 "    {0}" +
2101                                 "    Public Overridable Default Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
2102                                 "    End Property{0}" +
2103                                 "End Structure{0}", Writer.NewLine), code);
2104                 }
2105
2106                 [Test]
2107                 public override void PropertyIndexerTest2 ()
2108                 {
2109                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
2110                                 false, false, false);
2111                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2112                                 "Public Structure Test1{0}" +
2113                                 "    {0}" +
2114 #if NET_2_0
2115                                 "    Public Overridable Property iTem() As Integer{0}" +
2116 #else
2117                                 "    Public Overridable Property iTem As Integer{0}" +
2118 #endif
2119                                 "    End Property{0}" +
2120                                 "End Structure{0}", Writer.NewLine), code);
2121                 }
2122
2123                 [Test]
2124                 public override void PropertyIndexerGetOnly ()
2125                 {
2126                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
2127                                 true, false, true);
2128                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2129                                 "Public Structure Test1{0}" +
2130                                 "    {0}" +
2131                                 "    Protected Overridable Default ReadOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
2132                                 "        Get{0}" +
2133                                 "        End Get{0}" +
2134                                 "    End Property{0}" +
2135                                 "End Structure{0}", Writer.NewLine), code);
2136                 }
2137
2138                 [Test]
2139                 public override void PropertyIndexerSetOnly ()
2140                 {
2141                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
2142                                 false, true, true);
2143                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2144                                 "Public Structure Test1{0}" +
2145                                 "    {0}" +
2146                                 "    Protected Overridable Default WriteOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
2147                                 "        Set{0}" +
2148                                 "        End Set{0}" +
2149                                 "    End Property{0}" +
2150                                 "End Structure{0}", Writer.NewLine), code);
2151                 }
2152
2153                 [Test]
2154                 public override void PropertyImplementationTypes ()
2155                 {
2156                         string code = GeneratePropertyImplementationTypes ();
2157                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2158                                 "Public Structure Test1{0}" +
2159                                 "    {0}" +
2160 #if NET_2_0
2161                                 "    Public Overridable Property Name() As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
2162 #else
2163                                 "    Public Overridable Property Name As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
2164 #endif
2165                                 "    End Property{0}" +
2166                                 "End Structure{0}", Writer.NewLine), code);
2167                 }
2168
2169                 [Test]
2170                 public override void PropertyOverloadsTest1 ()
2171                 {
2172                         string code = GeneratePropertyOverloads1 ();
2173                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2174                                 "Public Structure Test1{0}" +
2175                                 "    {0}" +
2176 #if NET_2_0
2177                                 "    Public Overloads Overridable Property Name() As Integer{0}" +
2178 #else
2179                                 "    Public Overloads Overridable Property Name As Integer{0}" +
2180 #endif
2181                                 "    End Property{0}" +
2182                                 "End Structure{0}", Writer.NewLine), code);
2183                 }
2184
2185                 [Test]
2186                 public override void PropertyOverloadsTest2 ()
2187                 {
2188                         string code = GeneratePropertyOverloads2 ();
2189                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2190                                 "Public Structure Test1{0}" +
2191                                 "    {0}" +
2192 #if NET_2_0
2193                                 "    Public Overloads Overridable Property Name() As Integer{0}" +
2194 #else
2195                                 "    Public Overloads Overridable Property Name As Integer{0}" +
2196 #endif
2197                                 "    End Property{0}" +
2198                                 "    {0}" +
2199                                 "    Private Overloads Property Name(ByVal value1 As Object) As Integer{0}" +
2200                                 "    End Property{0}" +
2201                                 "End Structure{0}", Writer.NewLine), code);
2202                 }
2203
2204                 [Test]
2205                 public override void PropertyOverloadsTest3 ()
2206                 {
2207                         string code = GeneratePropertyOverloads3 ();
2208                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2209                                 "Public Structure Test1{0}" +
2210                                 "    {0}" +
2211 #if NET_2_0
2212                                 "    Public Overridable Property Name() As Integer{0}" +
2213 #else
2214                                 "    Public Overridable Property Name As Integer{0}" +
2215 #endif
2216                                 "    End Property{0}" +
2217                                 "    {0}" +
2218                                 "    Property System_Int32_Name(ByVal value1 As Object) As Integer Implements Integer.Name{0}" +
2219                                 "    End Property{0}" +
2220                                 "End Structure{0}", Writer.NewLine), code);
2221                 }
2222
2223                 [Test]
2224                 public override void PropertyPrivateImplementationType ()
2225                 {
2226                         string code = GeneratePropertyPrivateImplementationType ();
2227                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2228                                 "Public Structure Test1{0}" +
2229                                 "    {0}" +
2230                                 "    Overridable Property System_Int32_Item(ByVal value1 As Object) As Integer Implements Integer.Item{0}" +
2231                                 "    End Property{0}" +
2232                                 "End Structure{0}", Writer.NewLine), code);
2233                 }
2234
2235                 [Test]
2236                 public override void PropertyImplementationTypeOrder ()
2237                 {
2238                         string code = GeneratePropertyImplementationTypeOrder ();
2239                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2240                                 "Public Structure Test1{0}" +
2241                                 "    {0}" +
2242                                 "    Overridable Property System_Int32_Item(ByVal value1 As Object) As Integer Implements IPolicy.Item{0}" +
2243                                 "    End Property{0}" +
2244                                 "End Structure{0}", Writer.NewLine), code);
2245                 }
2246
2247                 [Test]
2248                 public override void MethodMembersTypeTest1 ()
2249                 {
2250                         string code = GenerateMethodMembersType1 ();
2251                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2252                                 "Public Structure Test1{0}" +
2253                                 "    {0}" +
2254                                 "    <A(),  _{0}" +
2255                                 "     B()>  _{0}" +
2256                                 "    Private Sub (){0}" +
2257                                 "    End Sub{0}" +
2258                                 "End Structure{0}", Writer.NewLine), code);
2259                 }
2260
2261                 [Test]
2262                 public override void MethodMembersTypeTest2 ()
2263                 {
2264                         string code = GenerateMethodMembersType2 ();
2265                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2266                                 "Public Structure Test1{0}" +
2267                                 "    {0}" +
2268                                 "    Public Overridable Function Something(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer) As Integer{0}" +
2269                                 "    End Function{0}" +
2270                                 "End Structure{0}", Writer.NewLine), code);
2271                 }
2272
2273                 [Test]
2274                 public override void MethodMembersTypeTest3 ()
2275                 {
2276                         string code = GenerateMethodMembersType3 ();
2277                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2278                                 "Public Structure Test1{0}" +
2279                                 "    {0}" +
2280                                 "    Public Overridable Function Something(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer) As Integer{0}" +
2281                                 "    End Function{0}" +
2282                                 "End Structure{0}", Writer.NewLine), code);
2283                 }
2284
2285                 [Test]
2286                 public override void MethodImplementationTypes ()
2287                 {
2288                         string code = GenerateMethodImplementationTypes ();
2289                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2290                                 "Public Structure Test1{0}" +
2291                                 "    {0}" +
2292 #if NET_2_0
2293                                 "    Friend Overridable Function Execute() As Integer Implements IPolicy.Execute , IWhatever.Execute{0}" +
2294 #else
2295                                 "    Friend Function Execute() As Integer Implements IPolicy.Execute , IWhatever.Execute{0}" +
2296 #endif
2297                                 "    End Function{0}" +
2298                                 "End Structure{0}", Writer.NewLine), code);
2299                 }
2300
2301                 [Test]
2302                 public override void MethodOverloadsTest1 ()
2303                 {
2304                         string code = GenerateMethodOverloads1 ();
2305                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2306                                 "Public Structure Test1{0}" +
2307                                 "    {0}" +
2308                                 "    Public Overloads Overridable Function Execute() As Integer{0}" +
2309                                 "    End Function{0}" +
2310                                 "End Structure{0}", Writer.NewLine), code);
2311                 }
2312
2313                 [Test]
2314                 public override void MethodOverloadsTest2 ()
2315                 {
2316                         string code = GenerateMethodOverloads2 ();
2317                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2318                                 "Public Structure Test1{0}" +
2319                                 "    {0}" +
2320                                 "    Public Overloads Overridable Sub Execute(){0}" +
2321                                 "    End Sub{0}" +
2322                                 "    {0}" +
2323                                 "    Private Overloads Function Execute(ByVal value1 As Object) As Integer{0}" +
2324                                 "    End Function{0}" +
2325                                 "End Structure{0}", Writer.NewLine), code);
2326                 }
2327
2328                 [Test]
2329                 public override void MethodOverloadsTest3 ()
2330                 {
2331                         string code = GenerateMethodOverloads3 ();
2332                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2333                                 "Public Structure Test1{0}" +
2334                                 "    {0}" +
2335                                 "    Public Overridable Sub Execute(){0}" +
2336                                 "    End Sub{0}" +
2337                                 "    {0}" +
2338                                 "    Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
2339                                 "    End Function{0}" +
2340                                 "End Structure{0}", Writer.NewLine), code);
2341                 }
2342
2343                 [Test]
2344                 public override void MethodPrivateImplementationType ()
2345                 {
2346                         string code = GenerateMethodPrivateImplementationType ();
2347                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2348                                 "Public Structure Test1{0}" +
2349                                 "    {0}" +
2350                                 "    Overridable Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
2351                                 "    End Function{0}" +
2352                                 "End Structure{0}", Writer.NewLine), code);
2353                 }
2354
2355                 [Test]
2356                 public override void MethodImplementationTypeOrder ()
2357                 {
2358                         string code = GenerateMethodImplementationTypeOrder ();
2359                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2360                                 "Public Structure Test1{0}" +
2361                                 "    {0}" +
2362                                 "    Overridable Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements IPolicy.Execute{0}" +
2363                                 "    End Function{0}" +
2364                                 "End Structure{0}", Writer.NewLine), code);
2365                 }
2366
2367                 [Test]
2368                 public override void MethodReturnTypeAttributes ()
2369                 {
2370                         string code = GenerateMethodReturnTypeAttributes ();
2371                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2372                                 "Public Structure Test1{0}" +
2373                                 "    {0}" +
2374                                 "    <A(),  _{0}" +
2375                                 "     B()>  _{0}" +
2376                                 "    Public Overridable Function Execute() As <C(A1:=false, A2:=true), D()> Integer{0}" +
2377                                 "    End Function{0}" +
2378                                 "End Structure{0}", Writer.NewLine), code);
2379                 }
2380
2381                 [Test]
2382                 public override void ConstructorAttributesTest ()
2383                 {
2384                         string code = GenerateConstructorAttributes ();
2385                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2386                                 "Public Structure Test1{0}" +
2387                                 "    {0}" +
2388                                 "    <A(),  _{0}" +
2389                                 "     B()>  _{0}" +
2390                                 "    Private Sub New(){0}" +
2391 #if !NET_2_0
2392                                 "        MyBase.New{0}" +
2393 #endif
2394                                 "    End Sub{0}" +
2395                                 "End Structure{0}", Writer.NewLine), code);
2396                 }
2397
2398                 [Test]
2399                 public override void ConstructorParametersTest ()
2400                 {
2401                         string code = GenerateConstructorParameters ();
2402                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2403                                 "Public Structure Test1{0}" +
2404                                 "    {0}" +
2405                                 "    Public Sub New(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer){0}" +
2406 #if !NET_2_0
2407                                 "        MyBase.New{0}" +
2408 #endif
2409                                 "    End Sub{0}" +
2410                                 "End Structure{0}", Writer.NewLine), code);
2411                 }
2412
2413                 [Test]
2414                 public override void ConstructorParameterAttributesTest ()
2415                 {
2416                         string code = GenerateConstructorParameterAttributes ();
2417                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2418                                 "Public Structure Test1{0}" +
2419                                 "    {0}" +
2420                                 "    Public Sub New(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer){0}" +
2421 #if !NET_2_0
2422                                 "        MyBase.New{0}" +
2423 #endif
2424                                 "    End Sub{0}" +
2425                                 "End Structure{0}", Writer.NewLine), code);
2426                 }
2427
2428                 [Test]
2429                 public override void BaseConstructorSingleArg ()
2430                 {
2431                         string code = GenerateBaseConstructor (false);
2432                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2433                                 "Public Structure Test1{0}" +
2434                                 "    {0}" +
2435                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
2436                                 "        MyBase.New(value1){0}" +
2437                                 "    End Sub{0}" +
2438                                 "End Structure{0}", Writer.NewLine), code);
2439                 }
2440
2441                 [Test]
2442                 public override void BaseConstructorMultipleArgs ()
2443                 {
2444                         string code = GenerateBaseConstructor (true);
2445                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2446                                 "Public Structure Test1{0}" +
2447                                 "    {0}" +
2448                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
2449                                 "        MyBase.New(value1, value2){0}" +
2450                                 "    End Sub{0}" +
2451                                 "End Structure{0}", Writer.NewLine), code);
2452                 }
2453
2454                 [Test]
2455                 public override void ChainedConstructorSingleArg ()
2456                 {
2457                         string code = GenerateChainedConstructor (false);
2458                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2459                                 "Public Structure Test1{0}" +
2460                                 "    {0}" +
2461                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
2462                                 "        Me.New(value1){0}" +
2463                                 "    End Sub{0}" +
2464                                 "End Structure{0}", Writer.NewLine), code);
2465                 }
2466
2467                 [Test]
2468                 public override void ChainedConstructorMultipleArgs ()
2469                 {
2470                         string code = GenerateChainedConstructor (true);
2471                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2472                                 "Public Structure Test1{0}" +
2473                                 "    {0}" +
2474                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
2475                                 "        Me.New(value1, value2){0}" +
2476                                 "    End Sub{0}" +
2477                                 "End Structure{0}", Writer.NewLine), code);
2478                 }
2479         }
2480
2481         [TestFixture]
2482         [Category ("NotWorking")]
2483         public class CodeGeneratorFromTypeTest_Enum : CodeGeneratorFromTypeTestBase
2484         {
2485                 private CodeTypeDeclaration _typeDeclaration;
2486                 private ICodeGenerator _codeGenerator;
2487
2488                 protected override ICodeGenerator CodeGenerator
2489                 {
2490                         get { return _codeGenerator; }
2491                 }
2492
2493                 protected override CodeTypeDeclaration TypeDeclaration
2494                 {
2495                         get { return _typeDeclaration; }
2496                 }
2497
2498                 [SetUp]
2499                 public override void SetUp ()
2500                 {
2501                         base.SetUp ();
2502                         _typeDeclaration = new CodeTypeDeclaration ();
2503                         _typeDeclaration.IsEnum = true;
2504
2505                         CodeDomProvider provider = new VBCodeProvider ();
2506                         _codeGenerator = provider.CreateGenerator ();
2507                 }
2508
2509                 [Test]
2510                 public override void DefaultTypeTest ()
2511                 {
2512                         string code = GenerateDefaultType ();
2513                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2514                                 "Public Enum {0}" +
2515                                 "End Enum{0}", Writer.NewLine), code);
2516                 }
2517
2518                 [Test]
2519                 [ExpectedException (typeof (NullReferenceException))]
2520                 public override void NullTypeTest ()
2521                 {
2522                         GenerateNullType ();
2523                 }
2524
2525                 [Test]
2526                 public override void SimpleTypeTest ()
2527                 {
2528                         string code = GenerateSimpleType ();
2529                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2530                                 "Public Enum Test1{0}" +
2531                                 "End Enum{0}", Writer.NewLine), code);
2532                 }
2533
2534                 [Test]
2535                 public override void AttributesAndTypeTest ()
2536                 {
2537                         string code = GenerateAttributesAndType ();
2538                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2539                                 "<A(),  _{0}" +
2540                                 " B()>  _{0}" +
2541                                 "Public Enum Test1{0}" +
2542                                 "End Enum{0}", Writer.NewLine), code);
2543                 }
2544
2545                 [Test]
2546                 public override void EventMembersTypeTest1 ()
2547                 {
2548                         string code = GenerateEventMembersType1 ();
2549                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2550                                 "Public Enum Test1{0}" +
2551                                 "    {0}" +
2552                                 "End Enum{0}", Writer.NewLine), code);
2553                 }
2554
2555                 [Test]
2556                 public override void EventMembersTypeTest2 ()
2557                 {
2558                         string code = GenerateEventMembersType2 ();
2559                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2560                                 "Public Enum Test1{0}" +
2561                                 "    {0}" +
2562                                 "End Enum{0}", Writer.NewLine), code);
2563                 }
2564
2565                 [Test]
2566                 public override void EventImplementationTypes ()
2567                 {
2568                         string code = GenerateEventImplementationTypes ();
2569                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2570                                 "Public Enum Test1{0}" +
2571                                 "    {0}" +
2572                                 "End Enum{0}", Writer.NewLine), code);
2573                 }
2574
2575                 [Test]
2576                 public override void EventPrivateImplementationType ()
2577                 {
2578                         string code = GenerateEventPrivateImplementationType ();
2579                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2580                                 "Public Enum Test1{0}" +
2581                                 "    {0}" +
2582                                 "End Enum{0}", Writer.NewLine), code);
2583                 }
2584
2585                 [Test]
2586                 public override void EventImplementationTypeOrder ()
2587                 {
2588                         string code = GenerateEventImplementationTypeOrder ();
2589                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2590                                 "Public Enum Test1{0}" +
2591                                 "    {0}" +
2592                                 "End Enum{0}", Writer.NewLine), code);
2593                 }
2594
2595                 [Test]
2596                 public override void FieldMembersTypeTest1 ()
2597                 {
2598                         string code = GenerateFieldMembersType1 ();
2599                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2600                                 "Public Enum Test1{0}" +
2601                                 "    {0}" +
2602                                 "    <A(),  _{0}" +
2603                                 "     B()>  _{0}" +
2604                                 "    {0}" +
2605                                 "End Enum{0}", Writer.NewLine), code);
2606                 }
2607
2608                 [Test]
2609                 public override void FieldMembersTypeTest2 ()
2610                 {
2611                         string code = GenerateFieldMembersType2 ();
2612                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2613                                 "Public Enum Test1{0}" +
2614                                 "    {0}" +
2615                                 "    Name{0}" +
2616                                 "End Enum{0}", Writer.NewLine), code);
2617                 }
2618
2619                 [Test]
2620                 public override void PropertyMembersTypeTest1 ()
2621                 {
2622                         string code = GeneratePropertyMembersAttributes ();
2623                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2624                                 "Public Enum Test1{0}" +
2625                                 "    {0}" +
2626                                 "End Enum{0}", Writer.NewLine), code);
2627                 }
2628
2629                 [Test]
2630                 public override void PropertyMembersTypeTest2 ()
2631                 {
2632                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
2633                                 false, false);
2634                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2635                                 "Public Enum Test1{0}" +
2636                                 "    {0}" +
2637                                 "End Enum{0}", Writer.NewLine), code);
2638                 }
2639
2640                 [Test]
2641                 public override void PropertyMembersTypeGetOnly ()
2642                 {
2643                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
2644                                 true, false);
2645                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2646                                 "Public Enum Test1{0}" +
2647                                 "    {0}" +
2648                                 "End Enum{0}", Writer.NewLine), code);
2649                 }
2650
2651                 [Test]
2652                 public override void PropertyMembersTypeSetOnly ()
2653                 {
2654                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2655                                 false, true);
2656                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2657                                 "Public Enum Test1{0}" +
2658                                 "    {0}" +
2659                                 "End Enum{0}", Writer.NewLine), code);
2660                 }
2661
2662                 [Test]
2663                 public override void PropertyMembersTypeGetSet ()
2664                 {
2665                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
2666                                 true, true);
2667                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2668                                 "Public Enum Test1{0}" +
2669                                 "    {0}" +
2670                                 "End Enum{0}", Writer.NewLine), code);
2671                 }
2672
2673                 [Test]
2674                 public override void PropertyMembersTypeFamilyOrAssembly ()
2675                 {
2676                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
2677                                 false, false);
2678                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2679                                 "Public Enum Test1{0}" +
2680                                 "    {0}" +
2681                                 "End Enum{0}", Writer.NewLine), code);
2682                 }
2683
2684                 [Test]
2685                 public override void PropertyMembersTypeAssembly ()
2686                 {
2687                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2688                                 false, false);
2689                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2690                                 "Public Enum Test1{0}" +
2691                                 "    {0}" +
2692                                 "End Enum{0}", Writer.NewLine), code);
2693                 }
2694
2695                 [Test]
2696                 public override void PropertyParametersTest ()
2697                 {
2698                         string code = GeneratePropertyParameters ();
2699                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2700                                 "Public Enum Test1{0}" +
2701                                 "    {0}" +
2702                                 "End Enum{0}", Writer.NewLine), code);
2703                 }
2704
2705                 [Test]
2706                 public override void PropertyIndexerTest1 ()
2707                 {
2708                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
2709                                 false, false, true);
2710                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2711                                 "Public Enum Test1{0}" +
2712                                 "    {0}" +
2713                                 "End Enum{0}", Writer.NewLine), code);
2714                 }
2715
2716                 [Test]
2717                 public override void PropertyIndexerTest2 ()
2718                 {
2719                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
2720                                 false, false, false);
2721                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2722                                 "Public Enum Test1{0}" +
2723                                 "    {0}" +
2724                                 "End Enum{0}", Writer.NewLine), code);
2725                 }
2726
2727                 [Test]
2728                 public override void PropertyIndexerGetOnly ()
2729                 {
2730                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
2731                                 true, false, true);
2732                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2733                                 "Public Enum Test1{0}" +
2734                                 "    {0}" +
2735                                 "End Enum{0}", Writer.NewLine), code);
2736                 }
2737
2738                 [Test]
2739                 public override void PropertyIndexerSetOnly ()
2740                 {
2741                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
2742                                 false, true, true);
2743                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2744                                 "Public Enum Test1{0}" +
2745                                 "    {0}" +
2746                                 "End Enum{0}", Writer.NewLine), code);
2747                 }
2748
2749                 [Test]
2750                 public override void PropertyImplementationTypes ()
2751                 {
2752                         string code = GeneratePropertyImplementationTypes ();
2753                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2754                                 "Public Enum Test1{0}" +
2755                                 "    {0}" +
2756                                 "End Enum{0}", Writer.NewLine), code);
2757                 }
2758
2759                 [Test]
2760                 public override void PropertyOverloadsTest1 ()
2761                 {
2762                         string code = GeneratePropertyOverloads1 ();
2763                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2764                                 "Public Enum Test1{0}" +
2765                                 "    {0}" +
2766                                 "End Enum{0}", Writer.NewLine), code);
2767                 }
2768
2769                 [Test]
2770                 public override void PropertyOverloadsTest2 ()
2771                 {
2772                         string code = GeneratePropertyOverloads2 ();
2773                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2774                                 "Public Enum Test1{0}" +
2775                                 "    {0}" +
2776                                 "    {0}" +
2777                                 "End Enum{0}", Writer.NewLine), code);
2778                 }
2779
2780                 [Test]
2781                 public override void PropertyOverloadsTest3 ()
2782                 {
2783                         string code = GeneratePropertyOverloads3 ();
2784                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2785                                 "Public Enum Test1{0}" +
2786                                 "    {0}" +
2787                                 "    {0}" +
2788                                 "End Enum{0}", Writer.NewLine), code);
2789                 }
2790
2791                 [Test]
2792                 public override void PropertyPrivateImplementationType ()
2793                 {
2794                         string code = GeneratePropertyPrivateImplementationType ();
2795                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2796                                 "Public Enum Test1{0}" +
2797                                 "    {0}" +
2798                                 "End Enum{0}", Writer.NewLine), code);
2799                 }
2800
2801                 [Test]
2802                 public override void PropertyImplementationTypeOrder ()
2803                 {
2804                         string code = GeneratePropertyImplementationTypeOrder ();
2805                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2806                                 "Public Enum Test1{0}" +
2807                                 "    {0}" +
2808                                 "End Enum{0}", Writer.NewLine), code);
2809                 }
2810
2811                 [Test]
2812                 public override void MethodMembersTypeTest1 ()
2813                 {
2814                         string code = GenerateMethodMembersType1 ();
2815                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2816                                 "Public Enum Test1{0}" +
2817                                 "    {0}" +
2818                                 "End Enum{0}", Writer.NewLine), code);
2819                 }
2820
2821                 [Test]
2822                 public override void MethodMembersTypeTest2 ()
2823                 {
2824                         string code = GenerateMethodMembersType2 ();
2825                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2826                                 "Public Enum Test1{0}" +
2827                                 "    {0}" +
2828                                 "End Enum{0}", Writer.NewLine), code);
2829                 }
2830
2831                 [Test]
2832                 public override void MethodMembersTypeTest3 ()
2833                 {
2834                         string code = GenerateMethodMembersType3 ();
2835                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2836                                 "Public Enum Test1{0}" +
2837                                 "    {0}" +
2838                                 "End Enum{0}", Writer.NewLine), code);
2839                 }
2840
2841                 [Test]
2842                 public override void MethodImplementationTypes ()
2843                 {
2844                         string code = GenerateMethodImplementationTypes ();
2845                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2846                                 "Public Enum Test1{0}" +
2847                                 "    {0}" +
2848                                 "End Enum{0}", Writer.NewLine), code);
2849                 }
2850
2851                 [Test]
2852                 public override void MethodOverloadsTest1 ()
2853                 {
2854                         string code = GenerateMethodOverloads1 ();
2855                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2856                                 "Public Enum Test1{0}" +
2857                                 "    {0}" +
2858                                 "End Enum{0}", Writer.NewLine), code);
2859                 }
2860
2861                 [Test]
2862                 public override void MethodOverloadsTest2 ()
2863                 {
2864                         string code = GenerateMethodOverloads2 ();
2865                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2866                                 "Public Enum Test1{0}" +
2867                                 "    {0}" +
2868                                 "    {0}" +
2869                                 "End Enum{0}", Writer.NewLine), code);
2870                 }
2871
2872                 [Test]
2873                 public override void MethodOverloadsTest3 ()
2874                 {
2875                         string code = GenerateMethodOverloads3 ();
2876                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2877                                 "Public Enum Test1{0}" +
2878                                 "    {0}" +
2879                                 "    {0}" +
2880                                 "End Enum{0}", Writer.NewLine), code);
2881                 }
2882
2883                 [Test]
2884                 public override void MethodPrivateImplementationType ()
2885                 {
2886                         string code = GenerateMethodPrivateImplementationType ();
2887                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2888                                 "Public Enum Test1{0}" +
2889                                 "    {0}" +
2890                                 "End Enum{0}", Writer.NewLine), code);
2891                 }
2892
2893                 [Test]
2894                 public override void MethodImplementationTypeOrder ()
2895                 {
2896                         string code = GenerateMethodImplementationTypeOrder ();
2897                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2898                                 "Public Enum Test1{0}" +
2899                                 "    {0}" +
2900                                 "End Enum{0}", Writer.NewLine), code);
2901                 }
2902
2903                 [Test]
2904                 public override void MethodReturnTypeAttributes ()
2905                 {
2906                         string code = GenerateMethodReturnTypeAttributes ();
2907                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2908                                 "Public Enum Test1{0}" +
2909                                 "    {0}" +
2910                                 "End Enum{0}", Writer.NewLine), code);
2911                 }
2912
2913                 [Test]
2914                 public override void ConstructorAttributesTest ()
2915                 {
2916                         string code = GenerateConstructorAttributes ();
2917                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2918                                 "Public Enum Test1{0}" +
2919                                 "    {0}" +
2920                                 "End Enum{0}", Writer.NewLine), code);
2921                 }
2922
2923                 [Test]
2924                 public override void ConstructorParametersTest ()
2925                 {
2926                         string code = GenerateConstructorParameters ();
2927                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2928                                 "Public Enum Test1{0}" +
2929                                 "    {0}" +
2930                                 "End Enum{0}", Writer.NewLine), code);
2931                 }
2932
2933                 [Test]
2934                 public override void ConstructorParameterAttributesTest ()
2935                 {
2936                         string code = GenerateConstructorParameterAttributes ();
2937                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2938                                 "Public Enum Test1{0}" +
2939                                 "    {0}" +
2940                                 "End Enum{0}", Writer.NewLine), code);
2941                 }
2942
2943                 [Test]
2944                 public override void BaseConstructorSingleArg ()
2945                 {
2946                         string code = GenerateBaseConstructor (false);
2947                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2948                                 "Public Enum Test1{0}" +
2949                                 "    {0}" +
2950                                 "End Enum{0}", Writer.NewLine), code);
2951                 }
2952
2953                 [Test]
2954                 public override void BaseConstructorMultipleArgs ()
2955                 {
2956                         string code = GenerateBaseConstructor (true);
2957                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2958                                 "Public Enum Test1{0}" +
2959                                 "    {0}" +
2960                                 "End Enum{0}", Writer.NewLine), code);
2961                 }
2962
2963                 [Test]
2964                 public override void ChainedConstructorSingleArg ()
2965                 {
2966                         string code = GenerateChainedConstructor (false);
2967                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2968                                 "Public Enum Test1{0}" +
2969                                 "    {0}" +
2970                                 "End Enum{0}", Writer.NewLine), code);
2971                 }
2972
2973                 [Test]
2974                 public override void ChainedConstructorMultipleArgs ()
2975                 {
2976                         string code = GenerateChainedConstructor (true);
2977                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2978                                 "Public Enum Test1{0}" +
2979                                 "    {0}" +
2980                                 "End Enum{0}", Writer.NewLine), code);
2981                 }
2982         }
2983 }