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

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