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