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 !NET_2_0
 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 !NET_2_0
 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
1358         [TestFixture]
1359         public class CodeGeneratorFromTypeTest_Interface : CodeGeneratorFromTypeTestBase
1360         {
1361                 private CodeTypeDeclaration _typeDeclaration;
1362                 private ICodeGenerator _codeGenerator;
1363
1364                 protected override ICodeGenerator CodeGenerator
1365                 {
1366                         get { return _codeGenerator; }
1367                 }
1368
1369                 protected override CodeTypeDeclaration TypeDeclaration
1370                 {
1371                         get { return _typeDeclaration; }
1372                 }
1373
1374                 [SetUp]
1375                 public override void SetUp ()
1376                 {
1377                         base.SetUp ();
1378                         _typeDeclaration = new CodeTypeDeclaration ();
1379                         _typeDeclaration.IsInterface = true;
1380
1381                         CodeDomProvider provider = new VBCodeProvider ();
1382                         _codeGenerator = provider.CreateGenerator ();
1383                 }
1384
1385                 [Test]
1386                 public override void DefaultTypeTest ()
1387                 {
1388                         string code = GenerateDefaultType (Options);
1389                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1390                                 "Public Interface {0}" +
1391                                 "End Interface{0}", NewLine), code);
1392                 }
1393
1394                 [Test]
1395                 [ExpectedException (typeof (NullReferenceException))]
1396                 public override void NullTypeTest ()
1397                 {
1398                         GenerateNullType (Options);
1399                 }
1400
1401                 [Test]
1402                 public override void SimpleTypeTest ()
1403                 {
1404                         string code = GenerateSimpleType (Options);
1405                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1406                                 "Public Interface Test1{0}" +
1407                                 "End Interface{0}", NewLine), code);
1408                 }
1409
1410                 [Test]
1411                 public override void DerivedTypeTest ()
1412                 {
1413                         string code = GenerateDerivedType (Options);
1414                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1415 #if NET_2_0
1416                                 "Friend Interface Test1{0}" +
1417 #else
1418                                 "Interface Test1{0}" +
1419 #endif
1420                                 "    Inherits Integer, System.Security.Principal.IIdentity, String, System.Security.IPermission{0}" +
1421                                 "End Interface{0}", NewLine), code);
1422                 }
1423
1424                 [Test]
1425                 public override void AttributesAndTypeTest ()
1426                 {
1427                         string code = GenerateAttributesAndType (Options);
1428                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1429                                 "<A(),  _{0}" +
1430                                 " B()>  _{0}" +
1431                                 "Public Interface Test1{0}" +
1432                                 "End Interface{0}", NewLine), code);
1433                 }
1434
1435                 [Test]
1436                 public override void EventMembersTypeTest1 ()
1437                 {
1438                         string code = GenerateEventMembersType1 (Options);
1439                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1440                                 "Public Interface Test1{0}" +
1441                                 "    {0}" +
1442                                 "    <A(),  _{0}" +
1443                                 "     B()>  _{0}" +
1444 #if NET_2_0
1445                                 "    Private Event __exception As System.Void{0}" +
1446 #else
1447                                 "    Private Event  As System.Void{0}" +
1448 #endif
1449                                 "End Interface{0}", NewLine), code);
1450                 }
1451
1452                 [Test]
1453                 public override void EventMembersTypeTest2 ()
1454                 {
1455                         string code = GenerateEventMembersType2 (Options);
1456                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1457                                 "Public Interface Test1{0}" +
1458                                 "    {0}" +
1459                                 "    Public Event Click As Integer{0}" +
1460                                 "End Interface{0}", NewLine), code);
1461                 }
1462
1463                 [Test]
1464                 public override void EventImplementationTypes ()
1465                 {
1466                         string code = GenerateEventImplementationTypes (Options);
1467                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1468                                 "Public Interface Test1{0}" +
1469                                 "    {0}" +
1470 #if NET_2_0
1471                                 "    Friend Event Click As Integer Implements IPolicy.Click , IWhatever.Click{0}" +
1472 #else
1473                                 "    Friend Event Click As Integer{0}" +
1474 #endif
1475                                 "End Interface{0}", NewLine), code);
1476                 }
1477
1478                 [Test]
1479                 public override void EventPrivateImplementationType ()
1480                 {
1481                         string code = GenerateEventPrivateImplementationType (Options);
1482                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1483                                 "Public Interface Test1{0}" +
1484                                 "    {0}" +
1485 #if NET_2_0
1486                                 "    Protected Event System_Int32_Click As Integer Implements Integer.Click{0}" +
1487 #else
1488                                 "    Protected Event Click As Integer{0}" +
1489 #endif
1490                                 "End Interface{0}", NewLine), code);
1491                 }
1492
1493                 [Test]
1494                 public override void EventImplementationTypeOrder ()
1495                 {
1496                         string code = GenerateEventImplementationTypeOrder (Options);
1497                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1498                                 "Public Interface Test1{0}" +
1499                                 "    {0}" +
1500 #if NET_2_0
1501                                 "    Public Event System_Int32_Click As Integer Implements IPolicy.Click{0}" +
1502 #else
1503                                 "    Public Event Click As Integer{0}" +
1504 #endif
1505                                 "End Interface{0}", NewLine), code);
1506                 }
1507
1508                 [Test]
1509                 public override void FieldMembersAttributesTest ()
1510                 {
1511                         string code = GenerateFieldMembersAttributes (Options);
1512                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1513                                 "Public Interface Test1{0}" +
1514                                 "    {0}" +
1515                                 "End Interface{0}", NewLine), code);
1516                 }
1517
1518                 [Test]
1519                 public override void FieldMembersTypeTest ()
1520                 {
1521                         string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
1522                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1523                                 "Public Interface Test1{0}" +
1524                                 "    {0}" +
1525                                 "End Interface{0}", NewLine), code);
1526                 }
1527
1528                 [Test]
1529                 public override void FieldNewSlotTest ()
1530                 {
1531                         string code = GenerateFieldMembersType (MemberAttributes.Assembly |
1532                                 MemberAttributes.New, 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 PropertyMembersTypeTest1 ()
1541                 {
1542                         string code = GeneratePropertyMembersAttributes (Options);
1543                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1544                                 "Public Interface Test1{0}" +
1545                                 "    {0}" +
1546                                 "    <A(),  _{0}" +
1547                                 "     B()>  _{0}" +
1548 #if NET_2_0
1549                                 "    Property () As System.Void{0}" +
1550 #else
1551                                 "    Property  As System.Void{0}" +
1552 #endif
1553                                 "End Interface{0}", NewLine), code);
1554                 }
1555
1556                 [Test]
1557                 public override void PropertyMembersTypeTest2 ()
1558                 {
1559                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
1560                                 false, false, Options);
1561                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1562                                 "Public Interface Test1{0}" +
1563                                 "    {0}" +
1564 #if NET_2_0
1565                                 "    Property Name() As Integer{0}" +
1566 #else
1567                                 "    Property Name As Integer{0}" +
1568 #endif
1569                                 "End Interface{0}", NewLine), code);
1570                 }
1571
1572                 [Test]
1573                 public override void PropertyMembersTypeGetOnly ()
1574                 {
1575                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1576                                 true, false, Options);
1577                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1578                                 "Public Interface Test1{0}" +
1579                                 "    {0}" +
1580 #if NET_2_0
1581                                 "    ReadOnly Property Name() As Integer{0}" +
1582 #else
1583                                 "    ReadOnly Property Name As Integer{0}" +
1584 #endif
1585                                 "End Interface{0}", NewLine), code);
1586                 }
1587
1588                 [Test]
1589                 public override void PropertyMembersTypeSetOnly ()
1590                 {
1591                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1592                                 false, true, Options);
1593                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1594                                 "Public Interface Test1{0}" +
1595                                 "    {0}" +
1596 #if NET_2_0
1597                                 "    WriteOnly Property Name() As Integer{0}" +
1598 #else
1599                                 "    WriteOnly Property Name As Integer{0}" +
1600 #endif
1601                                 "End Interface{0}", NewLine), code);
1602                 }
1603
1604                 [Test]
1605                 public override void PropertyMembersTypeGetSet ()
1606                 {
1607                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1608                                 true, true, Options);
1609                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1610                                 "Public Interface Test1{0}" +
1611                                 "    {0}" +
1612 #if NET_2_0
1613                                 "    Property Name() As Integer{0}" +
1614 #else
1615                                 "    Property Name As Integer{0}" +
1616 #endif
1617                                 "End Interface{0}", NewLine), code);
1618                 }
1619
1620                 [Test]
1621                 public override void PropertyMembersTypeFamilyOrAssembly ()
1622                 {
1623                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
1624                                 false, false, Options);
1625                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1626                                 "Public Interface Test1{0}" +
1627                                 "    {0}" +
1628 #if NET_2_0
1629                                 "    Property Name() As Integer{0}" +
1630 #else
1631                                 "    Property Name As Integer{0}" +
1632 #endif
1633                                 "End Interface{0}", NewLine), code);
1634                 }
1635
1636                 [Test]
1637                 public override void PropertyMembersTypeAssembly ()
1638                 {
1639                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1640                                 false, false, Options);
1641                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1642                                 "Public Interface Test1{0}" +
1643                                 "    {0}" +
1644 #if NET_2_0
1645                                 "    Property Name() As Integer{0}" +
1646 #else
1647                                 "    Property Name As Integer{0}" +
1648 #endif
1649                                 "End Interface{0}", NewLine), code);
1650                 }
1651
1652                 [Test]
1653                 public override void PropertyParametersTest ()
1654                 {
1655                         string code = GeneratePropertyParameters (Options);
1656                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1657                                 "Public Interface Test1{0}" +
1658                                 "    {0}" +
1659                                 "    Property Name(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
1660                                 "End Interface{0}", NewLine), code);
1661                 }
1662
1663                 [Test]
1664                 public override void PropertyIndexerTest1 ()
1665                 {
1666                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
1667                                 false, false, true, Options);
1668                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1669                                 "Public Interface Test1{0}" +
1670                                 "    {0}" +
1671                                 "    Default Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
1672                                 "End Interface{0}", NewLine), code);
1673                 }
1674
1675                 [Test]
1676                 public override void PropertyIndexerTest2 ()
1677                 {
1678                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
1679                                 false, false, false, Options);
1680                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1681                                 "Public Interface Test1{0}" +
1682                                 "    {0}" +
1683 #if NET_2_0
1684                                 "    Property iTem() As Integer{0}" +
1685 #else
1686                                 "    Property iTem As Integer{0}" +
1687 #endif
1688                                 "End Interface{0}", NewLine), code);
1689                 }
1690
1691                 [Test]
1692                 public override void PropertyIndexerGetOnly ()
1693                 {
1694                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
1695                                 true, false, true, Options);
1696                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1697                                 "Public Interface Test1{0}" +
1698                                 "    {0}" +
1699                                 "    Default ReadOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
1700                                 "End Interface{0}", NewLine), code);
1701                 }
1702
1703                 [Test]
1704                 public override void PropertyIndexerSetOnly ()
1705                 {
1706                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
1707                                 false, true, true, Options);
1708                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1709                                 "Public Interface Test1{0}" +
1710                                 "    {0}" +
1711                                 "    Default WriteOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
1712                                 "End Interface{0}", NewLine), code);
1713                 }
1714
1715                 [Test]
1716                 public override void PropertyImplementationTypes ()
1717                 {
1718                         string code = GeneratePropertyImplementationTypes (Options);
1719                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1720                                 "Public Interface Test1{0}" +
1721                                 "    {0}" +
1722 #if NET_2_0
1723                                 "    Property Name() As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
1724 #else
1725                                 "    Property Name As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
1726 #endif
1727                                 "End Interface{0}", NewLine), code);
1728                 }
1729
1730                 [Test]
1731                 public override void PropertyOverloadsTest1 ()
1732                 {
1733                         string code = GeneratePropertyOverloads1 (Options);
1734                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1735                                 "Public Interface Test1{0}" +
1736                                 "    {0}" +
1737 #if NET_2_0
1738                                 "    Property Name() As Integer{0}" +
1739 #else
1740                                 "    Property Name As Integer{0}" +
1741 #endif
1742                                 "End Interface{0}", NewLine), code);
1743                 }
1744
1745                 [Test]
1746                 public override void PropertyOverloadsTest2 ()
1747                 {
1748                         string code = GeneratePropertyOverloads2 (Options);
1749                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1750                                 "Public Interface Test1{0}" +
1751                                 "    {0}" +
1752 #if NET_2_0
1753                                 "    Property Name() As Integer{0}" +
1754 #else
1755                                 "    Property Name As Integer{0}" +
1756 #endif
1757                                 "    {0}" +
1758                                 "    Property Name(ByVal value1 As Object) As Integer{0}" +
1759                                 "End Interface{0}", NewLine), code);
1760                 }
1761
1762                 [Test]
1763                 public override void PropertyOverloadsTest3 ()
1764                 {
1765                         string code = GeneratePropertyOverloads3 (Options);
1766                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1767                                 "Public Interface Test1{0}" +
1768                                 "    {0}" +
1769 #if NET_2_0
1770                                 "    Property Name() As Integer{0}" +
1771 #else
1772                                 "    Property Name As Integer{0}" +
1773 #endif
1774                                 "    {0}" +
1775                                 "    Property System_Int32_Name(ByVal value1 As Object) As Integer Implements Integer.Name{0}" +
1776                                 "End Interface{0}", NewLine), code);
1777                 }
1778
1779                 [Test]
1780                 public override void PropertyPrivateImplementationType ()
1781                 {
1782                         string code = GeneratePropertyPrivateImplementationType (Options);
1783                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1784                                 "Public Interface Test1{0}" +
1785                                 "    {0}" +
1786                                 "    Property System_Int32_Item(ByVal value1 As Object) As Integer Implements Integer.Item{0}" +
1787                                 "End Interface{0}", NewLine), code);
1788                 }
1789
1790                 [Test]
1791                 public override void PropertyImplementationTypeOrder ()
1792                 {
1793                         string code = GeneratePropertyImplementationTypeOrder (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 IPolicy.Item{0}" +
1798                                 "End Interface{0}", NewLine), code);
1799                 }
1800
1801                 [Test]
1802                 public override void PropertyNewSlotTest ()
1803                 {
1804                         string code = GeneratePropertyMembersType (MemberAttributes.Private |
1805                                 MemberAttributes.New, true, true, Options);
1806                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1807                                 "Public Interface Test1{0}" +
1808                                 "    {0}" +
1809 #if NET_2_0
1810                                 "    Shadows Property Name() As Integer{0}" +
1811 #else
1812                                 "    Shadows Property Name As Integer{0}" +
1813 #endif
1814                                 "End Interface{0}", NewLine), code);
1815                 }
1816
1817                 [Test]
1818                 public override void MethodMembersTypeTest1 ()
1819                 {
1820                         string code = GenerateMethodMembersType1 (Options);
1821                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1822                                 "Public Interface Test1{0}" +
1823                                 "    {0}" +
1824                                 "    <A(),  _{0}" +
1825                                 "     B()>  _{0}" +
1826                                 "    Sub (){0}" +
1827                                 "End Interface{0}", NewLine), code);
1828                 }
1829
1830                 [Test]
1831                 public override void MethodMembersTypeTest2 ()
1832                 {
1833                         string code = GenerateMethodMembersType2 (Options);
1834                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1835                                 "Public Interface Test1{0}" +
1836                                 "    {0}" +
1837                                 "    Function Something(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer) As Integer{0}" +
1838                                 "End Interface{0}", NewLine), code);
1839                 }
1840
1841                 [Test]
1842                 public override void MethodMembersTypeTest3 ()
1843                 {
1844                         string code = GenerateMethodMembersType3 (Options);
1845                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1846                                 "Public Interface Test1{0}" +
1847                                 "    {0}" +
1848 #if NET_2_0
1849                                 "    Function Something(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef __exception As Integer) As Integer{0}" +
1850 #else
1851                                 "    Function Something(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef  As Integer) As Integer{0}" +
1852 #endif
1853                                 "End Interface{0}", NewLine), code);
1854                 }
1855
1856                 [Test]
1857                 public override void MethodImplementationTypes ()
1858                 {
1859                         string code = GenerateMethodImplementationTypes (Options);
1860                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1861                                 "Public Interface Test1{0}" +
1862                                 "    {0}" +
1863                                 "    Function Execute() As Integer Implements IPolicy.Execute , IWhatever.Execute{0}" +
1864                                 "End Interface{0}", NewLine), code);
1865                 }
1866
1867                 [Test]
1868                 public override void MethodOverloadsTest1 ()
1869                 {
1870                         string code = GenerateMethodOverloads1 (Options);
1871                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1872                                 "Public Interface Test1{0}" +
1873                                 "    {0}" +
1874                                 "    Function Execute() As Integer{0}" +
1875                                 "End Interface{0}", NewLine), code);
1876                 }
1877
1878                 [Test]
1879                 public override void MethodOverloadsTest2 ()
1880                 {
1881                         string code = GenerateMethodOverloads2 (Options);
1882                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1883                                 "Public Interface Test1{0}" +
1884                                 "    {0}" +
1885                                 "    Sub Execute(){0}" +
1886                                 "    {0}" +
1887                                 "    Function Execute(ByVal value1 As Object) As Integer{0}" +
1888                                 "End Interface{0}", NewLine), code);
1889                 }
1890
1891                 [Test]
1892                 public override void MethodOverloadsTest3 ()
1893                 {
1894                         string code = GenerateMethodOverloads3 (Options);
1895                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1896                                 "Public Interface Test1{0}" +
1897                                 "    {0}" +
1898                                 "    Sub Execute(){0}" +
1899                                 "    {0}" +
1900                                 "    Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
1901                                 "End Interface{0}", NewLine), code);
1902                 }
1903
1904                 [Test]
1905                 public override void MethodPrivateImplementationType ()
1906                 {
1907                         string code = GenerateMethodPrivateImplementationType (Options);
1908                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1909                                 "Public Interface Test1{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 MethodImplementationTypeOrder ()
1917                 {
1918                         string code = GenerateMethodImplementationTypeOrder (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 IPolicy.Execute{0}" +
1923                                 "End Interface{0}", NewLine), code);
1924                 }
1925
1926                 [Test]
1927                 public override void MethodReturnTypeAttributes ()
1928                 {
1929                         string code = GenerateMethodReturnTypeAttributes (Options);
1930                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1931                                 "Public Interface Test1{0}" +
1932                                 "    {0}" +
1933                                 "    <A(),  _{0}" +
1934                                 "     B()>  _{0}" +
1935                                 "    Function Execute() As <C(A1:=false, A2:=true), D()> Integer{0}" +
1936                                 "End Interface{0}", NewLine), code);
1937                 }
1938
1939                 [Test]
1940                 public override void MethodNewSlotTest ()
1941                 {
1942                         string code = GenerateMethodNewSlot (Options);
1943                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1944                                 "Public Interface Test1{0}" +
1945                                 "    {0}" +
1946                                 "    Shadows Function Execute() As Integer{0}" +
1947                                 "End Interface{0}", NewLine), code);
1948                 }
1949
1950                 [Test]
1951                 public override void ConstructorAttributesTest ()
1952                 {
1953                         string code = GenerateConstructorAttributes (Options);
1954                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1955                                 "Public Interface Test1{0}" +
1956                                 "    {0}" +
1957                                 "End Interface{0}", NewLine), code);
1958                 }
1959
1960                 [Test]
1961                 public override void ConstructorParametersTest ()
1962                 {
1963                         string code = GenerateConstructorParameters (Options);
1964                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1965                                 "Public Interface Test1{0}" +
1966                                 "    {0}" +
1967                                 "End Interface{0}", NewLine), code);
1968                 }
1969
1970                 [Test]
1971                 public override void ConstructorParameterAttributesTest ()
1972                 {
1973                         string code = GenerateConstructorParameterAttributes (Options);
1974                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1975                                 "Public Interface Test1{0}" +
1976                                 "    {0}" +
1977                                 "End Interface{0}", NewLine), code);
1978                 }
1979
1980                 [Test]
1981                 public override void BaseConstructorSingleArg ()
1982                 {
1983                         string code = GenerateBaseConstructor (false, Options);
1984                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1985                                 "Public Interface Test1{0}" +
1986                                 "    {0}" +
1987                                 "End Interface{0}", NewLine), code);
1988                 }
1989
1990                 [Test]
1991                 public override void BaseConstructorMultipleArgs ()
1992                 {
1993                         string code = GenerateBaseConstructor (true, Options);
1994                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1995                                 "Public Interface Test1{0}" +
1996                                 "    {0}" +
1997                                 "End Interface{0}", NewLine), code);
1998                 }
1999
2000                 [Test]
2001                 public override void ChainedConstructorSingleArg ()
2002                 {
2003                         string code = GenerateChainedConstructor (false, Options);
2004                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2005                                 "Public Interface Test1{0}" +
2006                                 "    {0}" +
2007                                 "End Interface{0}", NewLine), code);
2008                 }
2009
2010                 [Test]
2011                 public override void ChainedConstructorMultipleArgs ()
2012                 {
2013                         string code = GenerateChainedConstructor (true, Options);
2014                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2015                                 "Public Interface Test1{0}" +
2016                                 "    {0}" +
2017                                 "End Interface{0}", NewLine), code);
2018                 }
2019
2020                 [Test]
2021                 public override void TypeConstructorTest ()
2022                 {
2023                         string code = GenerateTypeConstructor (Options);
2024                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2025                                 "Public Interface Test1{0}" +
2026                                 "    {0}" +
2027                                 "End Interface{0}", NewLine), code);
2028                 }
2029
2030                 [Test]
2031                 public override void EntryPointMethodTest ()
2032                 {
2033                         string code = GenerateEntryPointMethod (Options);
2034                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2035                                 "Public Interface Test1{0}" +
2036                                 "    {0}" +
2037 #if NET_2_0
2038                                 "    <A()>  _{0}" +
2039 #endif
2040                                 "    Public Shared Sub Main(){0}" +
2041                                 "        Dim x As Test.InnerType{0}" +
2042                                 "    End Sub{0}" +
2043                                 "End Interface{0}", NewLine), code);
2044                 }
2045         }
2046
2047         [TestFixture]
2048         public class CodeGeneratorFromTypeTest_Struct : CodeGeneratorFromTypeTestBase
2049         {
2050                 private CodeTypeDeclaration _typeDeclaration;
2051                 private ICodeGenerator _codeGenerator;
2052
2053                 protected override ICodeGenerator CodeGenerator
2054                 {
2055                         get { return _codeGenerator; }
2056                 }
2057
2058                 protected override CodeTypeDeclaration TypeDeclaration
2059                 {
2060                         get { return _typeDeclaration; }
2061                 }
2062
2063                 [SetUp]
2064                 public override void SetUp ()
2065                 {
2066                         base.SetUp ();
2067                         _typeDeclaration = new CodeTypeDeclaration ();
2068                         _typeDeclaration.IsStruct = true;
2069
2070                         CodeDomProvider provider = new VBCodeProvider ();
2071                         _codeGenerator = provider.CreateGenerator ();
2072                 }
2073
2074                 [Test]
2075                 public override void DefaultTypeTest ()
2076                 {
2077                         string code = GenerateDefaultType (Options);
2078                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2079                                 "Public Structure {0}" +
2080                                 "End Structure{0}", NewLine), code);
2081                 }
2082
2083                 [Test]
2084                 [ExpectedException (typeof (NullReferenceException))]
2085                 public override void NullTypeTest ()
2086                 {
2087                         GenerateNullType (Options);
2088                 }
2089
2090                 [Test]
2091                 public override void SimpleTypeTest ()
2092                 {
2093                         string code = GenerateSimpleType (Options);
2094                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2095                                 "Public Structure Test1{0}" +
2096                                 "End Structure{0}", NewLine), code);
2097                 }
2098
2099                 [Test]
2100                 public override void DerivedTypeTest ()
2101                 {
2102                         string code = GenerateDerivedType (Options);
2103                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2104 #if NET_2_0
2105                                 "Friend Structure Test1{0}" +
2106 #else
2107                                 "Structure Test1{0}" +
2108 #endif
2109                                 "    Implements Integer, System.Security.Principal.IIdentity, String, System.Security.IPermission{0}" +
2110                                 "End Structure{0}", NewLine), code);
2111                 }
2112
2113                 [Test]
2114                 public override void AttributesAndTypeTest ()
2115                 {
2116                         string code = GenerateAttributesAndType (Options);
2117                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2118                                 "<A(),  _{0}" +
2119                                 " B()>  _{0}" +
2120                                 "Public Structure Test1{0}" +
2121                                 "End Structure{0}", NewLine), code);
2122                 }
2123
2124                 [Test]
2125                 public override void EventMembersTypeTest1 ()
2126                 {
2127                         string code = GenerateEventMembersType1 (Options);
2128                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2129                                 "Public Structure Test1{0}" +
2130                                 "    {0}" +
2131                                 "    <A(),  _{0}" +
2132                                 "     B()>  _{0}" +
2133 #if NET_2_0
2134                                 "    Private Event __exception As System.Void{0}" +
2135 #else
2136                                 "    Private Event  As System.Void{0}" +
2137 #endif
2138                                 "End Structure{0}", NewLine), code);
2139                 }
2140
2141                 [Test]
2142                 public override void EventMembersTypeTest2 ()
2143                 {
2144                         string code = GenerateEventMembersType2 (Options);
2145                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2146                                 "Public Structure Test1{0}" +
2147                                 "    {0}" +
2148                                 "    Public Event Click As Integer{0}" +
2149                                 "End Structure{0}", NewLine), code);
2150                 }
2151
2152                 [Test]
2153                 public override void EventImplementationTypes ()
2154                 {
2155                         string code = GenerateEventImplementationTypes (Options);
2156                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2157                                 "Public Structure Test1{0}" +
2158                                 "    {0}" +
2159 #if NET_2_0
2160                                 "    Friend Event Click As Integer Implements IPolicy.Click , IWhatever.Click{0}" +
2161 #else
2162                                 "    Friend Event Click As Integer{0}" +
2163 #endif
2164                                 "End Structure{0}", NewLine), code);
2165                 }
2166
2167                 [Test]
2168                 public override void EventPrivateImplementationType ()
2169                 {
2170                         string code = GenerateEventPrivateImplementationType (Options);
2171                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2172                                 "Public Structure Test1{0}" +
2173                                 "    {0}" +
2174 #if NET_2_0
2175                                 "    Protected Event System_Int32_Click As Integer Implements Integer.Click{0}" +
2176 #else
2177                                 "    Protected Event Click As Integer{0}" +
2178 #endif
2179                                 "End Structure{0}", NewLine), code);
2180                 }
2181
2182                 [Test]
2183                 public override void EventImplementationTypeOrder ()
2184                 {
2185                         string code = GenerateEventImplementationTypeOrder (Options);
2186                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2187                                 "Public Structure Test1{0}" +
2188                                 "    {0}" +
2189 #if NET_2_0
2190                                 "    Public Event System_Int32_Click As Integer Implements IPolicy.Click{0}" +
2191 #else
2192                                 "    Public Event Click As Integer{0}" +
2193 #endif
2194                                 "End Structure{0}", NewLine), code);
2195                 }
2196
2197                 [Test]
2198                 public override void FieldMembersAttributesTest ()
2199                 {
2200                         string code = GenerateFieldMembersAttributes (Options);
2201                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2202                                 "Public Structure Test1{0}" +
2203                                 "    {0}" +
2204                                 "    <A(),  _{0}" +
2205                                 "     B()>  _{0}" +
2206 #if NET_2_0
2207                                 "    Private __exception As System.Void{0}" +
2208 #else
2209                                 "    Private  As System.Void{0}" +
2210 #endif
2211                                 "End Structure{0}", NewLine), code);
2212                 }
2213
2214                 [Test]
2215                 public override void FieldMembersTypeTest ()
2216                 {
2217                         string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
2218                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2219                                 "Public Structure Test1{0}" +
2220                                 "    {0}" +
2221                                 "    Public Name As Integer = 2{0}" +
2222                                 "End Structure{0}", NewLine), code);
2223                 }
2224
2225                 [Test]
2226                 public override void FieldNewSlotTest ()
2227                 {
2228                         string code = GenerateFieldMembersType (MemberAttributes.Assembly |
2229                                 MemberAttributes.New, Options);
2230                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2231                                 "Public Structure Test1{0}" +
2232                                 "    {0}" +
2233                                 "    Friend Shadows Name As Integer = 2{0}" +
2234                                 "End Structure{0}", NewLine), code);
2235                 }
2236
2237                 [Test]
2238                 public override void PropertyMembersTypeTest1 ()
2239                 {
2240                         string code = GeneratePropertyMembersAttributes (Options);
2241                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2242                                 "Public Structure Test1{0}" +
2243                                 "    {0}" +
2244                                 "    <A(),  _{0}" +
2245                                 "     B()>  _{0}" +
2246 #if NET_2_0
2247                                 "    Private Property () As System.Void{0}" +
2248 #else
2249                                 "    Private Property  As System.Void{0}" +
2250 #endif
2251                                 "    End Property{0}" +
2252                                 "End Structure{0}", NewLine), code);
2253                 }
2254
2255                 [Test]
2256                 public override void PropertyMembersTypeTest2 ()
2257                 {
2258                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
2259                                 false, false, Options);
2260                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2261                                 "Public Structure Test1{0}" +
2262                                 "    {0}" +
2263 #if NET_2_0
2264                                 "    Public Overridable Property Name() As Integer{0}" +
2265 #else
2266                                 "    Public Overridable Property Name As Integer{0}" +
2267 #endif
2268                                 "    End Property{0}" +
2269                                 "End Structure{0}", NewLine), code);
2270                 }
2271
2272                 [Test]
2273                 public override void PropertyMembersTypeGetOnly ()
2274                 {
2275                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
2276                                 true, false, Options);
2277                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2278                                 "Public Structure Test1{0}" +
2279                                 "    {0}" +
2280 #if NET_2_0
2281                                 "    Protected Overridable ReadOnly Property Name() As Integer{0}" +
2282 #else
2283                                 "    Protected Overridable ReadOnly Property Name As Integer{0}" +
2284 #endif
2285                                 "        Get{0}" +
2286                                 "        End Get{0}" +
2287                                 "    End Property{0}" +
2288                                 "End Structure{0}", NewLine), code);
2289                 }
2290
2291                 [Test]
2292                 public override void PropertyMembersTypeSetOnly ()
2293                 {
2294                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2295                                 false, true, Options);
2296                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2297                                 "Public Structure Test1{0}" +
2298                                 "    {0}" +
2299 #if NET_2_0
2300                                 "    Friend Overridable WriteOnly Property Name() As Integer{0}" +
2301 #else
2302                                 "    Friend WriteOnly Property Name As Integer{0}" +
2303 #endif
2304                                 "        Set{0}" +
2305                                 "        End Set{0}" +
2306                                 "    End Property{0}" +
2307                                 "End Structure{0}", NewLine), code);
2308                 }
2309
2310                 [Test]
2311                 public override void PropertyMembersTypeGetSet ()
2312                 {
2313                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
2314                                 true, true, Options);
2315                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2316                                 "Public Structure Test1{0}" +
2317                                 "    {0}" +
2318 #if NET_2_0
2319                                 "    Protected Overridable Property Name() As Integer{0}" +
2320 #else
2321                                 "    Protected Overridable Property Name As Integer{0}" +
2322 #endif
2323                                 "        Get{0}" +
2324                                 "        End Get{0}" +
2325                                 "        Set{0}" +
2326                                 "        End Set{0}" +
2327                                 "    End Property{0}" +
2328                                 "End Structure{0}", NewLine), code);
2329                 }
2330
2331 #if !NET_2_0
2332                 // A bug in MS.NET 1.x causes MemberAttributes.FamilyOrAssembly to be
2333                 // generated as Protected
2334                 [Category ("NotDotNet")]
2335 #endif
2336                 [Test]
2337                 public override void PropertyMembersTypeFamilyOrAssembly ()
2338                 {
2339                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
2340                                 false, false, Options);
2341                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2342                                 "Public Structure Test1{0}" +
2343                                 "    {0}" +
2344 #if NET_2_0
2345                                 "    Protected Friend Property Name() As Integer{0}" +
2346 #else
2347                                 "    Protected Friend Property Name As Integer{0}" +
2348 #endif
2349                                 "    End Property{0}" +
2350                                 "End Structure{0}", NewLine), code);
2351                 }
2352
2353                 [Test]
2354                 public override void PropertyMembersTypeAssembly ()
2355                 {
2356                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2357                                 false, false, Options);
2358                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2359                                 "Public Structure Test1{0}" +
2360                                 "    {0}" +
2361 #if NET_2_0
2362                                 "    Friend Overridable Property Name() As Integer{0}" +
2363 #else
2364                                 "    Friend Property Name As Integer{0}" +
2365 #endif
2366                                 "    End Property{0}" +
2367                                 "End Structure{0}", NewLine), code);
2368                 }
2369
2370                 [Test]
2371                 public override void PropertyParametersTest ()
2372                 {
2373                         string code = GeneratePropertyParameters (Options);
2374                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2375                                 "Public Structure Test1{0}" +
2376                                 "    {0}" +
2377                                 "    Public Overridable Property Name(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
2378                                 "    End Property{0}" +
2379                                 "End Structure{0}", NewLine), code);
2380                 }
2381
2382                 [Test]
2383                 public override void PropertyIndexerTest1 ()
2384                 {
2385                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
2386                                 false, false, true, Options);
2387                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2388                                 "Public Structure Test1{0}" +
2389                                 "    {0}" +
2390                                 "    Public Overridable Default Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
2391                                 "    End Property{0}" +
2392                                 "End Structure{0}", NewLine), code);
2393                 }
2394
2395                 [Test]
2396                 public override void PropertyIndexerTest2 ()
2397                 {
2398                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
2399                                 false, false, false, Options);
2400                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2401                                 "Public Structure Test1{0}" +
2402                                 "    {0}" +
2403 #if NET_2_0
2404                                 "    Public Overridable Property iTem() As Integer{0}" +
2405 #else
2406                                 "    Public Overridable Property iTem As Integer{0}" +
2407 #endif
2408                                 "    End Property{0}" +
2409                                 "End Structure{0}", NewLine), code);
2410                 }
2411
2412                 [Test]
2413                 public override void PropertyIndexerGetOnly ()
2414                 {
2415                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
2416                                 true, false, true, Options);
2417                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2418                                 "Public Structure Test1{0}" +
2419                                 "    {0}" +
2420                                 "    Protected Overridable Default ReadOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
2421                                 "        Get{0}" +
2422                                 "        End Get{0}" +
2423                                 "    End Property{0}" +
2424                                 "End Structure{0}", NewLine), code);
2425                 }
2426
2427                 [Test]
2428                 public override void PropertyIndexerSetOnly ()
2429                 {
2430                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
2431                                 false, true, true, Options);
2432                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2433                                 "Public Structure Test1{0}" +
2434                                 "    {0}" +
2435                                 "    Protected Overridable Default WriteOnly Property iTem(ByVal value1 As Object, ByRef value2 As Integer) As Integer{0}" +
2436                                 "        Set{0}" +
2437                                 "        End Set{0}" +
2438                                 "    End Property{0}" +
2439                                 "End Structure{0}", NewLine), code);
2440                 }
2441
2442                 [Test]
2443                 public override void PropertyImplementationTypes ()
2444                 {
2445                         string code = GeneratePropertyImplementationTypes (Options);
2446                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2447                                 "Public Structure Test1{0}" +
2448                                 "    {0}" +
2449 #if NET_2_0
2450                                 "    Public Overridable Property Name() As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
2451 #else
2452                                 "    Public Overridable Property Name As Integer Implements IPolicy.Name , IWhatever.Name{0}" +
2453 #endif
2454                                 "    End Property{0}" +
2455                                 "End Structure{0}", NewLine), code);
2456                 }
2457
2458                 [Test]
2459                 public override void PropertyOverloadsTest1 ()
2460                 {
2461                         string code = GeneratePropertyOverloads1 (Options);
2462                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2463                                 "Public Structure Test1{0}" +
2464                                 "    {0}" +
2465 #if NET_2_0
2466                                 "    Protected Overloads Overridable Property Name() As Integer{0}" +
2467 #else
2468                                 "    Protected Overloads Overridable Property Name As Integer{0}" +
2469 #endif
2470                                 "    End Property{0}" +
2471                                 "End Structure{0}", NewLine), code);
2472                 }
2473
2474                 [Test]
2475                 public override void PropertyOverloadsTest2 ()
2476                 {
2477                         string code = GeneratePropertyOverloads2 (Options);
2478                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2479                                 "Public Structure Test1{0}" +
2480                                 "    {0}" +
2481 #if NET_2_0
2482                                 "    Public Overloads Overridable Property Name() As Integer{0}" +
2483 #else
2484                                 "    Public Overloads Overridable Property Name As Integer{0}" +
2485 #endif
2486                                 "    End Property{0}" +
2487                                 "    {0}" +
2488                                 "    Private Overloads Property Name(ByVal value1 As Object) As Integer{0}" +
2489                                 "    End Property{0}" +
2490                                 "End Structure{0}", NewLine), code);
2491                 }
2492
2493                 [Test]
2494                 public override void PropertyOverloadsTest3 ()
2495                 {
2496                         string code = GeneratePropertyOverloads3 (Options);
2497                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2498                                 "Public Structure Test1{0}" +
2499                                 "    {0}" +
2500 #if NET_2_0
2501                                 "    Public Overridable Property Name() As Integer{0}" +
2502 #else
2503                                 "    Public Overridable Property Name As Integer{0}" +
2504 #endif
2505                                 "    End Property{0}" +
2506                                 "    {0}" +
2507                                 "    Property System_Int32_Name(ByVal value1 As Object) As Integer Implements Integer.Name{0}" +
2508                                 "    End Property{0}" +
2509                                 "End Structure{0}", NewLine), code);
2510                 }
2511
2512                 [Test]
2513                 public override void PropertyPrivateImplementationType ()
2514                 {
2515                         string code = GeneratePropertyPrivateImplementationType (Options);
2516                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2517                                 "Public Structure Test1{0}" +
2518                                 "    {0}" +
2519                                 "    Overridable Property System_Int32_Item(ByVal value1 As Object) As Integer Implements Integer.Item{0}" +
2520                                 "    End Property{0}" +
2521                                 "End Structure{0}", NewLine), code);
2522                 }
2523
2524                 [Test]
2525                 public override void PropertyImplementationTypeOrder ()
2526                 {
2527                         string code = GeneratePropertyImplementationTypeOrder (Options);
2528                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2529                                 "Public Structure Test1{0}" +
2530                                 "    {0}" +
2531                                 "    Overridable Property System_Int32_Item(ByVal value1 As Object) As Integer Implements IPolicy.Item{0}" +
2532                                 "    End Property{0}" +
2533                                 "End Structure{0}", NewLine), code);
2534                 }
2535
2536                 [Test]
2537                 public override void PropertyNewSlotTest ()
2538                 {
2539                         string code = GeneratePropertyMembersType (MemberAttributes.Private |
2540                                 MemberAttributes.New, true, true, Options);
2541                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2542                                 "Public Structure Test1{0}" +
2543                                 "    {0}" +
2544 #if NET_2_0
2545                                 "    Private Shadows Property Name() As Integer{0}" +
2546 #else
2547                                 "    Private Shadows Property Name As Integer{0}" +
2548 #endif
2549                                 "        Get{0}" +
2550                                 "        End Get{0}" +
2551                                 "        Set{0}" +
2552                                 "        End Set{0}" +
2553                                 "    End Property{0}" +
2554                                 "End Structure{0}", NewLine), code);
2555                 }
2556
2557                 [Test]
2558                 public override void MethodMembersTypeTest1 ()
2559                 {
2560                         string code = GenerateMethodMembersType1 (Options);
2561                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2562                                 "Public Structure Test1{0}" +
2563                                 "    {0}" +
2564                                 "    <A(),  _{0}" +
2565                                 "     B()>  _{0}" +
2566                                 "    Private Sub (){0}" +
2567                                 "    End Sub{0}" +
2568                                 "End Structure{0}", NewLine), code);
2569                 }
2570
2571                 [Test]
2572                 public override void MethodMembersTypeTest2 ()
2573                 {
2574                         string code = GenerateMethodMembersType2 (Options);
2575                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2576                                 "Public Structure Test1{0}" +
2577                                 "    {0}" +
2578                                 "    Public Overridable Function Something(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer) As Integer{0}" +
2579                                 "    End Function{0}" +
2580                                 "End Structure{0}", NewLine), code);
2581                 }
2582
2583                 [Test]
2584                 public override void MethodMembersTypeTest3 ()
2585                 {
2586                         string code = GenerateMethodMembersType3 (Options);
2587                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2588                                 "Public Structure Test1{0}" +
2589                                 "    {0}" +
2590 #if NET_2_0
2591                                 "    Public Overridable Function Something(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef __exception As Integer) As Integer{0}" +
2592 #else
2593                                 "    Public Overridable Function Something(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef  As Integer) As Integer{0}" +
2594 #endif
2595                                 "    End Function{0}" +
2596                                 "End Structure{0}", NewLine), code);
2597                 }
2598
2599                 [Test]
2600                 public override void MethodImplementationTypes ()
2601                 {
2602                         string code = GenerateMethodImplementationTypes (Options);
2603                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2604                                 "Public Structure Test1{0}" +
2605                                 "    {0}" +
2606 #if NET_2_0
2607                                 "    Friend Overridable Function Execute() As Integer Implements IPolicy.Execute , IWhatever.Execute{0}" +
2608 #else
2609                                 "    Friend Function Execute() As Integer Implements IPolicy.Execute , IWhatever.Execute{0}" +
2610 #endif
2611                                 "    End Function{0}" +
2612                                 "End Structure{0}", NewLine), code);
2613                 }
2614
2615                 [Test]
2616                 public override void MethodOverloadsTest1 ()
2617                 {
2618                         string code = GenerateMethodOverloads1 (Options);
2619                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2620                                 "Public Structure Test1{0}" +
2621                                 "    {0}" +
2622 #if NET_2_0
2623                                 "    Friend Overloads Overridable Function Execute() As Integer{0}" +
2624 #else
2625                                 "    Friend Overloads Function Execute() As Integer{0}" +
2626 #endif
2627                                 "    End Function{0}" +
2628                                 "End Structure{0}", NewLine), code);
2629                 }
2630
2631                 [Test]
2632                 public override void MethodOverloadsTest2 ()
2633                 {
2634                         string code = GenerateMethodOverloads2 (Options);
2635                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2636                                 "Public Structure Test1{0}" +
2637                                 "    {0}" +
2638                                 "    Public Overloads Overridable Sub Execute(){0}" +
2639                                 "    End Sub{0}" +
2640                                 "    {0}" +
2641                                 "    Private Overloads Function Execute(ByVal value1 As Object) As Integer{0}" +
2642                                 "    End Function{0}" +
2643                                 "End Structure{0}", NewLine), code);
2644                 }
2645
2646                 [Test]
2647                 public override void MethodOverloadsTest3 ()
2648                 {
2649                         string code = GenerateMethodOverloads3 (Options);
2650                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2651                                 "Public Structure Test1{0}" +
2652                                 "    {0}" +
2653                                 "    Public Overridable Sub Execute(){0}" +
2654                                 "    End Sub{0}" +
2655                                 "    {0}" +
2656                                 "    Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
2657                                 "    End Function{0}" +
2658                                 "End Structure{0}", NewLine), code);
2659                 }
2660
2661                 [Test]
2662                 public override void MethodPrivateImplementationType ()
2663                 {
2664                         string code = GenerateMethodPrivateImplementationType (Options);
2665                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2666                                 "Public Structure Test1{0}" +
2667                                 "    {0}" +
2668                                 "    Overridable Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements Integer.Execute{0}" +
2669                                 "    End Function{0}" +
2670                                 "End Structure{0}", NewLine), code);
2671                 }
2672
2673                 [Test]
2674                 public override void MethodImplementationTypeOrder ()
2675                 {
2676                         string code = GenerateMethodImplementationTypeOrder (Options);
2677                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2678                                 "Public Structure Test1{0}" +
2679                                 "    {0}" +
2680                                 "    Overridable Function System_Int32_Execute(ByVal value1 As Object) As Integer Implements IPolicy.Execute{0}" +
2681                                 "    End Function{0}" +
2682                                 "End Structure{0}", NewLine), code);
2683                 }
2684
2685                 [Test]
2686                 public override void MethodReturnTypeAttributes ()
2687                 {
2688                         string code = GenerateMethodReturnTypeAttributes (Options);
2689                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2690                                 "Public Structure Test1{0}" +
2691                                 "    {0}" +
2692                                 "    <A(),  _{0}" +
2693                                 "     B()>  _{0}" +
2694                                 "    Public Overridable Function Execute() As <C(A1:=false, A2:=true), D()> Integer{0}" +
2695                                 "    End Function{0}" +
2696                                 "End Structure{0}", NewLine), code);
2697                 }
2698
2699                 [Test]
2700                 public override void MethodNewSlotTest ()
2701                 {
2702                         string code = GenerateMethodNewSlot (Options);
2703                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2704                                 "Public Structure Test1{0}" +
2705                                 "    {0}" +
2706                                 "    Public Shadows Overridable Function Execute() As Integer{0}" +
2707                                 "    End Function{0}" +
2708                                 "End Structure{0}", NewLine), code);
2709                 }
2710
2711                 [Test]
2712                 public override void ConstructorAttributesTest ()
2713                 {
2714                         // FIXME: updated to reflect mbas workaround
2715                         string code = GenerateConstructorAttributes (Options);
2716                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2717                                 "Public Structure Test1{0}" +
2718                                 "    {0}" +
2719                                 "    <A(),  _{0}" +
2720                                 "     B()>  _{0}" +
2721                                 "    Private Sub New(){0}" +
2722 #if !NET_2_0
2723                                 "        MyBase.New(){0}" +
2724 #endif
2725                                 "    End Sub{0}" +
2726                                 "End Structure{0}", NewLine), code);
2727                 }
2728
2729                 [Test]
2730                 public override void ConstructorParametersTest ()
2731                 {
2732                         // FIXME: updated to reflect mbas workaround
2733                         string code = GenerateConstructorParameters (Options);
2734                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2735                                 "Public Structure Test1{0}" +
2736                                 "    {0}" +
2737                                 "    Public Sub New(ByVal value1 As Object, ByVal value2 As Object, ByRef index As Integer, ByRef count As Integer){0}" +
2738 #if !NET_2_0
2739                                 "        MyBase.New(){0}" +
2740 #endif
2741                                 "    End Sub{0}" +
2742                                 "End Structure{0}", NewLine), code);
2743                 }
2744
2745                 [Test]
2746                 public override void ConstructorParameterAttributesTest ()
2747                 {
2748                         // FIXME: updated to reflect mbas workaround
2749                         string code = GenerateConstructorParameterAttributes (Options);
2750                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2751                                 "Public Structure Test1{0}" +
2752                                 "    {0}" +
2753                                 "    Private Sub New(<A(), B()> ByVal value As Object, <C(A1:=false, A2:=true), D()> ByRef index As Integer){0}" +
2754 #if !NET_2_0
2755                                 "        MyBase.New(){0}" +
2756 #endif
2757                                 "    End Sub{0}" +
2758                                 "End Structure{0}", NewLine), code);
2759                 }
2760
2761                 [Test]
2762                 public override void BaseConstructorSingleArg ()
2763                 {
2764                         string code = GenerateBaseConstructor (false, Options);
2765                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2766                                 "Public Structure Test1{0}" +
2767                                 "    {0}" +
2768                                 "    Protected Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
2769                                 "        MyBase.New(value1){0}" +
2770                                 "    End Sub{0}" +
2771                                 "End Structure{0}", NewLine), code);
2772                 }
2773
2774                 [Test]
2775                 public override void BaseConstructorMultipleArgs ()
2776                 {
2777                         string code = GenerateBaseConstructor (true, Options);
2778                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2779                                 "Public Structure Test1{0}" +
2780                                 "    {0}" +
2781                                 "    Protected Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
2782                                 "        MyBase.New(value1, value2){0}" +
2783                                 "    End Sub{0}" +
2784                                 "End Structure{0}", NewLine), code);
2785                 }
2786
2787                 [Test]
2788                 public override void ChainedConstructorSingleArg ()
2789                 {
2790                         string code = GenerateChainedConstructor (false, Options);
2791                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2792                                 "Public Structure Test1{0}" +
2793                                 "    {0}" +
2794                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
2795                                 "        Me.New(value1){0}" +
2796                                 "    End Sub{0}" +
2797                                 "End Structure{0}", NewLine), code);
2798                 }
2799
2800                 [Test]
2801                 public override void ChainedConstructorMultipleArgs ()
2802                 {
2803                         string code = GenerateChainedConstructor (true, Options);
2804                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2805                                 "Public Structure Test1{0}" +
2806                                 "    {0}" +
2807                                 "    Public Sub New(ByVal value1 As Object, ByRef value2 As Integer){0}" +
2808                                 "        Me.New(value1, value2){0}" +
2809                                 "    End Sub{0}" +
2810                                 "End Structure{0}", NewLine), code);
2811                 }
2812
2813                 [Test]
2814                 public override void TypeConstructorTest ()
2815                 {
2816                         string code = GenerateTypeConstructor (Options);
2817                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2818                                 "Public Structure Test1{0}" +
2819                                 "    {0}" +
2820 #if NET_2_0
2821                                 "    <A(),  _{0}" +
2822                                 "     B()>  _{0}" +
2823 #endif
2824                                 "    Shared Sub New(){0}" +
2825                                 "    End Sub{0}" +
2826                                 "End Structure{0}", NewLine), code);
2827                 }
2828
2829                 [Test]
2830                 public override void EntryPointMethodTest ()
2831                 {
2832                         string code = GenerateEntryPointMethod (Options);
2833                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2834                                 "Public Structure Test1{0}" +
2835                                 "    {0}" +
2836 #if NET_2_0
2837                                 "    <A()>  _{0}" +
2838 #endif
2839                                 "    Public Shared Sub Main(){0}" +
2840                                 "        Dim x As Test.InnerType{0}" +
2841                                 "    End Sub{0}" +
2842                                 "End Structure{0}", NewLine), code);
2843                 }
2844         }
2845
2846         [TestFixture]
2847         public class CodeGeneratorFromTypeTest_Enum : CodeGeneratorFromTypeTestBase
2848         {
2849                 private CodeTypeDeclaration _typeDeclaration;
2850                 private ICodeGenerator _codeGenerator;
2851
2852                 protected override ICodeGenerator CodeGenerator
2853                 {
2854                         get { return _codeGenerator; }
2855                 }
2856
2857                 protected override CodeTypeDeclaration TypeDeclaration
2858                 {
2859                         get { return _typeDeclaration; }
2860                 }
2861
2862                 [SetUp]
2863                 public override void SetUp ()
2864                 {
2865                         base.SetUp ();
2866                         _typeDeclaration = new CodeTypeDeclaration ();
2867                         _typeDeclaration.IsEnum = true;
2868
2869                         CodeDomProvider provider = new VBCodeProvider ();
2870                         _codeGenerator = provider.CreateGenerator ();
2871                 }
2872
2873                 [Test]
2874                 public override void DefaultTypeTest ()
2875                 {
2876                         string code = GenerateDefaultType (Options);
2877                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2878                                 "Public Enum {0}" +
2879                                 "End Enum{0}", NewLine), code);
2880                 }
2881
2882                 [Test]
2883                 [ExpectedException (typeof (NullReferenceException))]
2884                 public override void NullTypeTest ()
2885                 {
2886                         GenerateNullType (Options);
2887                 }
2888
2889                 [Test]
2890                 public override void SimpleTypeTest ()
2891                 {
2892                         string code = GenerateSimpleType (Options);
2893                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2894                                 "Public Enum Test1{0}" +
2895                                 "End Enum{0}", NewLine), code);
2896                 }
2897
2898                 [Test]
2899                 public override void DerivedTypeTest ()
2900                 {
2901                         string code = GenerateDerivedType (Options);
2902                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2903 #if NET_2_0
2904                                 "Friend Enum Test1 As Integer{0}" +
2905 #else
2906                                 "Enum Test1 As Integer{0}" +
2907 #endif
2908                                 "End Enum{0}", NewLine), code);
2909                 }
2910
2911                 [Test]
2912                 public override void AttributesAndTypeTest ()
2913                 {
2914                         string code = GenerateAttributesAndType (Options);
2915                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2916                                 "<A(),  _{0}" +
2917                                 " B()>  _{0}" +
2918                                 "Public Enum Test1{0}" +
2919                                 "End Enum{0}", NewLine), code);
2920                 }
2921
2922                 [Test]
2923                 public override void EventMembersTypeTest1 ()
2924                 {
2925                         string code = GenerateEventMembersType1 (Options);
2926                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2927                                 "Public Enum Test1{0}" +
2928                                 "    {0}" +
2929                                 "End Enum{0}", NewLine), code);
2930                 }
2931
2932                 [Test]
2933                 public override void EventMembersTypeTest2 ()
2934                 {
2935                         string code = GenerateEventMembersType2 (Options);
2936                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2937                                 "Public Enum Test1{0}" +
2938                                 "    {0}" +
2939                                 "End Enum{0}", NewLine), code);
2940                 }
2941
2942                 [Test]
2943                 public override void EventImplementationTypes ()
2944                 {
2945                         string code = GenerateEventImplementationTypes (Options);
2946                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2947                                 "Public Enum Test1{0}" +
2948                                 "    {0}" +
2949                                 "End Enum{0}", NewLine), code);
2950                 }
2951
2952                 [Test]
2953                 public override void EventPrivateImplementationType ()
2954                 {
2955                         string code = GenerateEventPrivateImplementationType (Options);
2956                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2957                                 "Public Enum Test1{0}" +
2958                                 "    {0}" +
2959                                 "End Enum{0}", NewLine), code);
2960                 }
2961
2962                 [Test]
2963                 public override void EventImplementationTypeOrder ()
2964                 {
2965                         string code = GenerateEventImplementationTypeOrder (Options);
2966                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2967                                 "Public Enum Test1{0}" +
2968                                 "    {0}" +
2969                                 "End Enum{0}", NewLine), code);
2970                 }
2971
2972                 [Test]
2973                 public override void FieldMembersAttributesTest ()
2974                 {
2975                         string code = GenerateFieldMembersAttributes (Options);
2976                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2977                                 "Public Enum Test1{0}" +
2978                                 "    {0}" +
2979                                 "    <A(),  _{0}" +
2980                                 "     B()>  _{0}" +
2981                                 "    {0}" +
2982                                 "End Enum{0}", NewLine), code);
2983                 }
2984
2985                 [Test]
2986                 public override void FieldMembersTypeTest ()
2987                 {
2988                         string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
2989                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2990                                 "Public Enum Test1{0}" +
2991                                 "    {0}" +
2992                                 "    Name = 2{0}" +
2993                                 "End Enum{0}", NewLine), code);
2994                 }
2995
2996                 [Test]
2997                 public override void FieldNewSlotTest ()
2998                 {
2999                         string code = GenerateFieldMembersType (MemberAttributes.Assembly |
3000                                 MemberAttributes.New, Options);
3001                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3002                                 "Public Enum Test1{0}" +
3003                                 "    {0}" +
3004                                 "    Name = 2{0}" +
3005                                 "End Enum{0}", NewLine), code);
3006                 }
3007
3008                 [Test]
3009                 public override void PropertyMembersTypeTest1 ()
3010                 {
3011                         string code = GeneratePropertyMembersAttributes (Options);
3012                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3013                                 "Public Enum Test1{0}" +
3014                                 "    {0}" +
3015                                 "End Enum{0}", NewLine), code);
3016                 }
3017
3018                 [Test]
3019                 public override void PropertyMembersTypeTest2 ()
3020                 {
3021                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
3022                                 false, false, 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 PropertyMembersTypeGetOnly ()
3031                 {
3032                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
3033                                 true, 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 PropertyMembersTypeSetOnly ()
3042                 {
3043                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
3044                                 false, true, 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 PropertyMembersTypeGetSet ()
3053                 {
3054                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
3055                                 true, 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 PropertyMembersTypeFamilyOrAssembly ()
3064                 {
3065                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
3066                                 false, false, 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 PropertyMembersTypeAssembly ()
3075                 {
3076                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
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 PropertyParametersTest ()
3086                 {
3087                         string code = GeneratePropertyParameters (Options);
3088                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3089                                 "Public Enum Test1{0}" +
3090                                 "    {0}" +
3091                                 "End Enum{0}", NewLine), code);
3092                 }
3093
3094                 [Test]
3095                 public override void PropertyIndexerTest1 ()
3096                 {
3097                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
3098                                 false, false, true, 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 PropertyIndexerTest2 ()
3107                 {
3108                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
3109                                 false, false, false, 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 PropertyIndexerGetOnly ()
3118                 {
3119                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
3120                                 true, false, true, 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 PropertyIndexerSetOnly ()
3129                 {
3130                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
3131                                 false, true, 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 PropertyImplementationTypes ()
3140                 {
3141                         string code = GeneratePropertyImplementationTypes (Options);
3142                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3143                                 "Public Enum Test1{0}" +
3144                                 "    {0}" +
3145                                 "End Enum{0}", NewLine), code);
3146                 }
3147
3148                 [Test]
3149                 public override void PropertyOverloadsTest1 ()
3150                 {
3151                         string code = GeneratePropertyOverloads1 (Options);
3152                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3153                                 "Public Enum Test1{0}" +
3154                                 "    {0}" +
3155                                 "End Enum{0}", NewLine), code);
3156                 }
3157
3158                 [Test]
3159                 public override void PropertyOverloadsTest2 ()
3160                 {
3161                         string code = GeneratePropertyOverloads2 (Options);
3162                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3163                                 "Public Enum Test1{0}" +
3164                                 "    {0}" +
3165                                 "    {0}" +
3166                                 "End Enum{0}", NewLine), code);
3167                 }
3168
3169                 [Test]
3170                 public override void PropertyOverloadsTest3 ()
3171                 {
3172                         string code = GeneratePropertyOverloads3 (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 PropertyPrivateImplementationType ()
3182                 {
3183                         string code = GeneratePropertyPrivateImplementationType (Options);
3184                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3185                                 "Public Enum Test1{0}" +
3186                                 "    {0}" +
3187                                 "End Enum{0}", NewLine), code);
3188                 }
3189
3190                 [Test]
3191                 public override void PropertyImplementationTypeOrder ()
3192                 {
3193                         string code = GeneratePropertyImplementationTypeOrder (Options);
3194                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3195                                 "Public Enum Test1{0}" +
3196                                 "    {0}" +
3197                                 "End Enum{0}", NewLine), code);
3198                 }
3199
3200                 [Test]
3201                 public override void PropertyNewSlotTest ()
3202                 {
3203                         string code = GeneratePropertyMembersType (MemberAttributes.Private |
3204                                 MemberAttributes.New, true, true, 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 MethodMembersTypeTest1 ()
3213                 {
3214                         string code = GenerateMethodMembersType1 (Options);
3215                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3216                                 "Public Enum Test1{0}" +
3217                                 "    {0}" +
3218                                 "End Enum{0}", NewLine), code);
3219                 }
3220
3221                 [Test]
3222                 public override void MethodMembersTypeTest2 ()
3223                 {
3224                         string code = GenerateMethodMembersType2 (Options);
3225                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3226                                 "Public Enum Test1{0}" +
3227                                 "    {0}" +
3228                                 "End Enum{0}", NewLine), code);
3229                 }
3230
3231                 [Test]
3232                 public override void MethodMembersTypeTest3 ()
3233                 {
3234                         string code = GenerateMethodMembersType3 (Options);
3235                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3236                                 "Public Enum Test1{0}" +
3237                                 "    {0}" +
3238                                 "End Enum{0}", NewLine), code);
3239                 }
3240
3241                 [Test]
3242                 public override void MethodImplementationTypes ()
3243                 {
3244                         string code = GenerateMethodImplementationTypes (Options);
3245                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3246                                 "Public Enum Test1{0}" +
3247                                 "    {0}" +
3248                                 "End Enum{0}", NewLine), code);
3249                 }
3250
3251                 [Test]
3252                 public override void MethodOverloadsTest1 ()
3253                 {
3254                         string code = GenerateMethodOverloads1 (Options);
3255                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3256                                 "Public Enum Test1{0}" +
3257                                 "    {0}" +
3258                                 "End Enum{0}", NewLine), code);
3259                 }
3260
3261                 [Test]
3262                 public override void MethodOverloadsTest2 ()
3263                 {
3264                         string code = GenerateMethodOverloads2 (Options);
3265                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3266                                 "Public Enum Test1{0}" +
3267                                 "    {0}" +
3268                                 "    {0}" +
3269                                 "End Enum{0}", NewLine), code);
3270                 }
3271
3272                 [Test]
3273                 public override void MethodOverloadsTest3 ()
3274                 {
3275                         string code = GenerateMethodOverloads3 (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 MethodPrivateImplementationType ()
3285                 {
3286                         string code = GenerateMethodPrivateImplementationType (Options);
3287                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3288                                 "Public Enum Test1{0}" +
3289                                 "    {0}" +
3290                                 "End Enum{0}", NewLine), code);
3291                 }
3292
3293                 [Test]
3294                 public override void MethodImplementationTypeOrder ()
3295                 {
3296                         string code = GenerateMethodImplementationTypeOrder (Options);
3297                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3298                                 "Public Enum Test1{0}" +
3299                                 "    {0}" +
3300                                 "End Enum{0}", NewLine), code);
3301                 }
3302
3303                 [Test]
3304                 public override void MethodReturnTypeAttributes ()
3305                 {
3306                         string code = GenerateMethodReturnTypeAttributes (Options);
3307                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3308                                 "Public Enum Test1{0}" +
3309                                 "    {0}" +
3310                                 "End Enum{0}", NewLine), code);
3311                 }
3312
3313                 [Test]
3314                 public override void MethodNewSlotTest ()
3315                 {
3316                         string code = GenerateMethodNewSlot (Options);
3317                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3318                                 "Public Enum Test1{0}" +
3319                                 "    {0}" +
3320                                 "End Enum{0}", NewLine), code);
3321                 }
3322
3323                 [Test]
3324                 public override void ConstructorAttributesTest ()
3325                 {
3326                         string code = GenerateConstructorAttributes (Options);
3327                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3328                                 "Public Enum Test1{0}" +
3329                                 "    {0}" +
3330                                 "End Enum{0}", NewLine), code);
3331                 }
3332
3333                 [Test]
3334                 public override void ConstructorParametersTest ()
3335                 {
3336                         string code = GenerateConstructorParameters (Options);
3337                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3338                                 "Public Enum Test1{0}" +
3339                                 "    {0}" +
3340                                 "End Enum{0}", NewLine), code);
3341                 }
3342
3343                 [Test]
3344                 public override void ConstructorParameterAttributesTest ()
3345                 {
3346                         string code = GenerateConstructorParameterAttributes (Options);
3347                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3348                                 "Public Enum Test1{0}" +
3349                                 "    {0}" +
3350                                 "End Enum{0}", NewLine), code);
3351                 }
3352
3353                 [Test]
3354                 public override void BaseConstructorSingleArg ()
3355                 {
3356                         string code = GenerateBaseConstructor (false, Options);
3357                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3358                                 "Public Enum Test1{0}" +
3359                                 "    {0}" +
3360                                 "End Enum{0}", NewLine), code);
3361                 }
3362
3363                 [Test]
3364                 public override void BaseConstructorMultipleArgs ()
3365                 {
3366                         string code = GenerateBaseConstructor (true, Options);
3367                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3368                                 "Public Enum Test1{0}" +
3369                                 "    {0}" +
3370                                 "End Enum{0}", NewLine), code);
3371                 }
3372
3373                 [Test]
3374                 public override void ChainedConstructorSingleArg ()
3375                 {
3376                         string code = GenerateChainedConstructor (false, Options);
3377                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3378                                 "Public Enum Test1{0}" +
3379                                 "    {0}" +
3380                                 "End Enum{0}", NewLine), code);
3381                 }
3382
3383                 [Test]
3384                 public override void ChainedConstructorMultipleArgs ()
3385                 {
3386                         string code = GenerateChainedConstructor (true, Options);
3387                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3388                                 "Public Enum Test1{0}" +
3389                                 "    {0}" +
3390                                 "End Enum{0}", NewLine), code);
3391                 }
3392
3393                 [Test]
3394                 public override void TypeConstructorTest ()
3395                 {
3396                         string code = GenerateTypeConstructor (Options);
3397                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3398                                 "Public Enum Test1{0}" +
3399                                 "    {0}" +
3400                                 "End Enum{0}", NewLine), code);
3401                 }
3402
3403                 [Test]
3404                 public override void EntryPointMethodTest ()
3405                 {
3406                         string code = GenerateEntryPointMethod (Options);
3407                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3408                                 "Public Enum Test1{0}" +
3409                                 "    {0}" +
3410 #if NET_2_0
3411                                 "    <A()>  _{0}" +
3412 #endif
3413                                 "    Public Shared Sub Main(){0}" +
3414                                 "        Dim x As Test.InnerType{0}" +
3415                                 "    End Sub{0}" +
3416                                 "End Enum{0}", NewLine), code);
3417                 }
3418         }
3419 }