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