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