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
 926         [TestFixture]
 927         public class CodeGeneratorFromTypeTest_Delegate : CodeGeneratorFromTypeTestBase
 928         {
 929                 private CodeTypeDeclaration _typeDeclaration;
 930                 private ICodeGenerator _codeGenerator;
 931
 932                 #region Override implementation of CodeGeneratorTestBase
 933
 934                 protected override ICodeGenerator CodeGenerator
 935                 {
 936                         get { return _codeGenerator; }
 937                 }
 938
 939                 [SetUp]
 940                 public override void SetUp ()
 941                 {
 942                         base.SetUp ();
 943                         _typeDeclaration = new CodeTypeDelegate ();
 944
 945                         CodeDomProvider provider = new CSharpCodeProvider ();
 946                         _codeGenerator = provider.CreateGenerator ();
 947                 }
 948
 949                 #endregion Override implementation of CodeGeneratorTestBase
 950
 951                 #region Override implementation of CodeGeneratorFromTypeTestBase
 952
 953                 protected override CodeTypeDeclaration TypeDeclaration
 954                 {
 955                         get { return _typeDeclaration; }
 956                 }
 957
 958                 [Test]
 959                 public override void DefaultTypeTest ()
 960                 {
 961                         string code = GenerateDefaultType (Options);
 962                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 963                                 "public delegate void ();{0}", NewLine), code);
 964                 }
 965
 966                 [Test]
 967                 [ExpectedException (typeof (NullReferenceException))]
 968                 public override void NullTypeTest ()
 969                 {
 970                         GenerateNullType (Options);
 971                 }
 972
 973                 [Test]
 974                 public override void SimpleTypeTest ()
 975                 {
 976                         string code = GenerateSimpleType (Options);
 977                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 978                                 "public delegate void Test1();{0}", NewLine), code);
 979                 }
 980
 981                 [Test]
 982                 public override void DerivedTypeTest ()
 983                 {
 984                         string code = GenerateDerivedType (Options);
 985                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 986                                 "delegate void Test1();{0}", NewLine), code);
 987                 }
 988
 989                 [Test]
 990                 public override void AttributesAndTypeTest ()
 991                 {
 992                         CodeTypeDelegate delegateDecl = new CodeTypeDelegate ();
 993                         delegateDecl.ReturnType = new CodeTypeReference (typeof (int));
 994
 995                         _typeDeclaration = delegateDecl;
 996
 997                         string code = GenerateAttributesAndType (Options);
 998                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 999                                 "[A()]{0}" +
1000                                 "[B()]{0}" +
1001                                 "public delegate int Test1();{0}", NewLine), code);
1002                 }
1003
1004                 [Test]
1005                 public override void EventMembersTypeTest1 ()
1006                 {
1007                         string code = GenerateEventMembersType1 (Options);
1008                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1009                                 "public delegate void Test1();{0}{0}", NewLine), code);
1010                 }
1011
1012                 [Test]
1013                 public override void EventMembersTypeTest2 ()
1014                 {
1015                         string code = GenerateEventMembersType2 (Options);
1016                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1017                                 "public delegate void Test1();{0}{0}", NewLine), code);
1018                 }
1019
1020                 [Test]
1021                 public override void EventImplementationTypes ()
1022                 {
1023                         string code = GenerateEventImplementationTypes (Options);
1024                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1025                                 "public delegate void Test1();{0}{0}", NewLine), code);
1026                 }
1027
1028                 /// <summary>
1029                 /// Ensure no access modifiers are output if PrivateImplementationType
1030                 /// is set.
1031                 /// </summary>
1032                 [Test]
1033                 public override void EventPrivateImplementationType ()
1034                 {
1035                         string code = GenerateEventPrivateImplementationType (Options);
1036                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1037                                 "public delegate void Test1();{0}{0}", NewLine), code);
1038                 }
1039
1040                 /// <summary>
1041                 /// If both ImplementationTypes and PrivateImplementationType are set,
1042                 /// then only ImplementationTypes are output.
1043                 /// </summary>
1044                 [Test]
1045                 public override void EventImplementationTypeOrder ()
1046                 {
1047                         string code = GenerateEventImplementationTypeOrder (Options);
1048                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1049                                 "public delegate void Test1();{0}{0}", NewLine), code);
1050                 }
1051
1052                 [Test]
1053                 public override void FieldMembersAttributesTest ()
1054                 {
1055                         string code = GenerateFieldMembersAttributes (Options);
1056                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1057                                 "public delegate void Test1();{0}{0}", NewLine), code);
1058                 }
1059
1060                 [Test]
1061                 public override void FieldMembersTypeTest ()
1062                 {
1063                         string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
1064                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1065                                 "public delegate void Test1();{0}{0}", NewLine), code);
1066                 }
1067
1068                 [Test]
1069                 public override void FieldNewSlotTest ()
1070                 {
1071                         string code = GenerateFieldMembersType (MemberAttributes.Assembly |
1072                                 MemberAttributes.New, Options);
1073                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1074                                 "public delegate void Test1();{0}{0}", NewLine), code);
1075                 }
1076
1077                 [Test]
1078                 public override void PropertyMembersTypeTest1 ()
1079                 {
1080                         string code = GeneratePropertyMembersAttributes (Options);
1081                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1082                                 "public delegate void Test1();{0}{0}", NewLine), code);
1083                 }
1084
1085                 [Test]
1086                 public override void PropertyMembersTypeTest2 ()
1087                 {
1088                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
1089                                 false, false, Options);
1090                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1091                                 "public delegate void Test1();{0}{0}", NewLine), code);
1092                 }
1093
1094                 [Test]
1095                 public override void PropertyMembersTypeGetOnly ()
1096                 {
1097                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1098                                 true, false, Options);
1099                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1100                                 "public delegate void Test1();{0}{0}", NewLine), code);
1101                 }
1102
1103                 [Test]
1104                 public override void PropertyMembersTypeSetOnly ()
1105                 {
1106                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1107                                 false, true, Options);
1108                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1109                                 "public delegate void Test1();{0}{0}", NewLine), code);
1110                 }
1111
1112                 [Test]
1113                 public override void PropertyMembersTypeGetSet ()
1114                 {
1115                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1116                                 true, true, Options);
1117                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1118                                 "public delegate void Test1();{0}{0}", NewLine), code);
1119                 }
1120
1121                 [Test]
1122                 public override void PropertyMembersTypeFamilyOrAssembly ()
1123                 {
1124                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
1125                                 false, false, Options);
1126                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1127                                 "public delegate void Test1();{0}{0}", NewLine), code);
1128                 }
1129
1130                 [Test]
1131                 public override void PropertyMembersTypeAssembly ()
1132                 {
1133                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1134                                 false, false, Options);
1135                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1136                                 "public delegate void Test1();{0}{0}", NewLine), code);
1137                 }
1138
1139                 [Test]
1140                 public override void PropertyParametersTest ()
1141                 {
1142                         string code = GeneratePropertyParameters (Options);
1143                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1144                                 "public delegate void Test1();{0}{0}", NewLine), code);
1145                 }
1146
1147                 [Test]
1148                 public override void PropertyIndexerTest1 ()
1149                 {
1150                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
1151                                 false, false, true, Options);
1152                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1153                                 "public delegate void Test1();{0}{0}", NewLine), code);
1154                 }
1155
1156                 [Test]
1157                 public override void PropertyIndexerTest2 ()
1158                 {
1159                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
1160                                 false, false, false, Options);
1161                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1162                                 "public delegate void Test1();{0}{0}", NewLine), code);
1163                 }
1164
1165                 [Test]
1166                 public override void PropertyIndexerGetOnly ()
1167                 {
1168                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
1169                                 true, false, true, Options);
1170                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1171                                 "public delegate void Test1();{0}{0}", NewLine), code);
1172                 }
1173
1174                 [Test]
1175                 public override void PropertyIndexerSetOnly ()
1176                 {
1177                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
1178                                 false, true, true, Options);
1179                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1180                                 "public delegate void Test1();{0}{0}", NewLine), code);
1181                 }
1182
1183                 [Test]
1184                 public override void PropertyImplementationTypes ()
1185                 {
1186                         string code = GeneratePropertyImplementationTypes (Options);
1187                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1188                                 "public delegate void Test1();{0}{0}", NewLine), code);
1189                 }
1190
1191                 [Test]
1192                 public override void PropertyOverloadsTest1 ()
1193                 {
1194                         string code = GeneratePropertyOverloads1 (Options);
1195                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1196                                 "public delegate void Test1();{0}{0}", NewLine), code);
1197                 }
1198
1199                 [Test]
1200                 public override void PropertyOverloadsTest2 ()
1201                 {
1202                         string code = GeneratePropertyOverloads2 (Options);
1203                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1204                                 "public delegate void Test1();{0}{0}{0}", NewLine), code);
1205                 }
1206
1207                 [Test]
1208                 public override void PropertyOverloadsTest3 ()
1209                 {
1210                         string code = GeneratePropertyOverloads3 (Options);
1211                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1212                                 "public delegate void Test1();{0}{0}{0}", NewLine), code);
1213                 }
1214
1215                 [Test]
1216                 public override void PropertyPrivateImplementationType ()
1217                 {
1218                         string code = GeneratePropertyPrivateImplementationType (Options);
1219                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1220                                 "public delegate void Test1();{0}{0}", NewLine), code);
1221                 }
1222
1223                 [Test]
1224                 public override void PropertyImplementationTypeOrder ()
1225                 {
1226                         string code = GeneratePropertyImplementationTypeOrder (Options);
1227                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1228                                 "public delegate void Test1();{0}{0}", NewLine), code);
1229                 }
1230
1231                 [Test]
1232                 public override void PropertyNewSlotTest ()
1233                 {
1234                         string code = GeneratePropertyMembersType (MemberAttributes.Private |
1235                                 MemberAttributes.New, true, true, Options);
1236                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1237                                 "public delegate void Test1();{0}{0}", NewLine), code);
1238                 }
1239
1240                 [Test]
1241                 public override void MethodMembersTypeTest1 ()
1242                 {
1243                         string code = GenerateMethodMembersType1 (Options);
1244                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1245                                 "public delegate void Test1();{0}{0}", NewLine), code);
1246                 }
1247
1248                 [Test]
1249                 public override void MethodMembersTypeTest2 ()
1250                 {
1251                         string code = GenerateMethodMembersType2 (Options);
1252                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1253                                 "public delegate void Test1();{0}{0}", NewLine), code);
1254                 }
1255
1256                 [Test]
1257                 public override void MethodMembersTypeTest3 ()
1258                 {
1259                         string code = GenerateMethodMembersType3 (Options);
1260                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1261                                 "public delegate void Test1();{0}{0}", NewLine), code);
1262                 }
1263
1264                 [Test]
1265                 public override void MethodImplementationTypes ()
1266                 {
1267                         string code = GenerateMethodImplementationTypes (Options);
1268                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1269                                 "public delegate void Test1();{0}{0}", NewLine), code);
1270                 }
1271
1272                 [Test]
1273                 public override void MethodOverloadsTest1 ()
1274                 {
1275                         string code = GenerateMethodOverloads1 (Options);
1276                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1277                                 "public delegate void Test1();{0}{0}", NewLine), code);
1278                 }
1279
1280                 [Test]
1281                 public override void MethodOverloadsTest2 ()
1282                 {
1283                         string code = GenerateMethodOverloads2 (Options);
1284                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1285                                 "public delegate void Test1();{0}{0}{0}", NewLine), code);
1286                 }
1287
1288                 [Test]
1289                 public override void MethodOverloadsTest3 ()
1290                 {
1291                         string code = GenerateMethodOverloads3 (Options);
1292                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1293                                 "public delegate void Test1();{0}{0}{0}", NewLine), code);
1294                 }
1295
1296                 [Test]
1297                 public override void MethodPrivateImplementationType ()
1298                 {
1299                         string code = GenerateMethodPrivateImplementationType (Options);
1300                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1301                                 "public delegate void Test1();{0}{0}", NewLine), code);
1302                 }
1303
1304                 [Test]
1305                 public override void MethodImplementationTypeOrder ()
1306                 {
1307                         string code = GenerateMethodImplementationTypeOrder (Options);
1308                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1309                                 "public delegate void Test1();{0}{0}", NewLine), code);
1310                 }
1311
1312                 [Test]
1313                 public override void MethodReturnTypeAttributes ()
1314                 {
1315                         string code = GenerateMethodReturnTypeAttributes (Options);
1316                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1317                                 "public delegate void Test1();{0}{0}", NewLine), code);
1318                 }
1319
1320                 [Test]
1321                 public override void MethodNewSlotTest ()
1322                 {
1323                         string code = GenerateMethodNewSlot (Options);
1324                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1325                                 "public delegate void Test1();{0}{0}", NewLine), code);
1326                 }
1327
1328                 [Test]
1329                 public override void ConstructorAttributesTest ()
1330                 {
1331                         string code = GenerateConstructorAttributes (Options);
1332                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1333                                 "public delegate void Test1();{0}{0}", NewLine), code);
1334                 }
1335
1336                 [Test]
1337                 public override void ConstructorParametersTest ()
1338                 {
1339                         string code = GenerateConstructorParameters (Options);
1340                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1341                                 "public delegate void Test1();{0}{0}", NewLine), code);
1342                 }
1343
1344                 [Test]
1345                 public override void ConstructorParameterAttributesTest ()
1346                 {
1347                         string code = GenerateConstructorParameterAttributes (Options);
1348                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1349                                 "public delegate void Test1();{0}{0}", NewLine), code);
1350                 }
1351
1352                 [Test]
1353                 public override void BaseConstructorSingleArg ()
1354                 {
1355                         string code = GenerateBaseConstructor (false, Options);
1356                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1357                                 "public delegate void Test1();{0}{0}", NewLine), code);
1358                 }
1359
1360                 [Test]
1361                 public override void BaseConstructorMultipleArgs ()
1362                 {
1363                         string code = GenerateBaseConstructor (true, Options);
1364                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1365                                 "public delegate void Test1();{0}{0}", NewLine), code);
1366                 }
1367
1368                 [Test]
1369                 public override void ChainedConstructorSingleArg ()
1370                 {
1371                         string code = GenerateChainedConstructor (false, Options);
1372                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1373                                 "public delegate void Test1();{0}{0}", NewLine), code);
1374                 }
1375
1376                 [Test]
1377                 public override void ChainedConstructorMultipleArgs ()
1378                 {
1379                         string code = GenerateChainedConstructor (true, Options);
1380                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1381                                 "public delegate void Test1();{0}{0}", NewLine), code);
1382                 }
1383
1384                 [Test]
1385                 public override void TypeConstructorTest ()
1386                 {
1387                         string code = GenerateTypeConstructor (Options);
1388                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1389                                 "public delegate void Test1();{0}{0}", NewLine), code);
1390                 }
1391
1392                 [Test]
1393                 public override void EntryPointMethodTest ()
1394                 {
1395                         string code = GenerateEntryPointMethod (Options);
1396                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1397                                 "public delegate void Test1();{0}{0}" +
1398 #if NET_2_0
1399                                 "[A()]{0}" +
1400                                 "public static int Main() {{{0}" +
1401 #else
1402                                 "public static void Main() {{{0}" +
1403 #endif
1404                                 "    Test.InnerType x;{0}" +
1405                                 "}}{0}", NewLine), code);
1406                 }
1407
1408                 #endregion Override implementation of CodeGeneratorFromTypeTestBase
1409         }
1410
1411         [TestFixture]
1412         public class CodeGeneratorFromTypeTest_Interface : CodeGeneratorFromTypeTestBase
1413         {
1414                 private CodeTypeDeclaration _typeDeclaration;
1415                 private ICodeGenerator _codeGenerator;
1416
1417                 #region Override implementation of CodeGeneratorTestBase
1418
1419                 protected override ICodeGenerator CodeGenerator
1420                 {
1421                         get { return _codeGenerator; }
1422                 }
1423
1424                 [SetUp]
1425                 public override void SetUp ()
1426                 {
1427                         base.SetUp ();
1428                         _typeDeclaration = new CodeTypeDeclaration ();
1429                         _typeDeclaration.IsInterface = true;
1430
1431                         CodeDomProvider provider = new CSharpCodeProvider ();
1432                         _codeGenerator = provider.CreateGenerator ();
1433                 }
1434
1435                 #endregion Override implementation of CodeGeneratorTestBase
1436
1437                 #region Override implementation of CodeGeneratorFromTypeTestBase
1438
1439                 protected override CodeTypeDeclaration TypeDeclaration
1440                 {
1441                         get { return _typeDeclaration; }
1442                 }
1443
1444                 [Test]
1445                 public override void DefaultTypeTest ()
1446                 {
1447                         string code = GenerateDefaultType (Options);
1448                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1449                                 "public interface  {{{0}" +
1450                                 "}}{0}", NewLine), code);
1451                 }
1452
1453                 [Test]
1454                 public void DefaultTypeTest_C ()
1455                 {
1456                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
1457                         options.BracingStyle = "C";
1458
1459                         string code = GenerateDefaultType (options);
1460                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1461                                 "public interface {0}" +
1462                                 "{{{0}" +
1463                                 "}}{0}", NewLine), code);
1464                 }
1465
1466                 [Test]
1467                 [ExpectedException (typeof (NullReferenceException))]
1468                 public override void NullTypeTest ()
1469                 {
1470                         GenerateNullType (Options);
1471                 }
1472
1473                 [Test]
1474                 public override void SimpleTypeTest ()
1475                 {
1476                         string code = GenerateSimpleType (Options);
1477                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1478                                 "public interface Test1 {{{0}" +
1479                                 "}}{0}", NewLine), code);
1480                 }
1481
1482                 [Test]
1483                 public void SimpleTypeTest_C ()
1484                 {
1485                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
1486                         options.BracingStyle = "C";
1487
1488                         string code = GenerateSimpleType (options);
1489                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1490                                 "public interface Test1{0}" +
1491                                 "{{{0}" +
1492                                 "}}{0}", NewLine), code);
1493                 }
1494
1495                 [Test]
1496                 public override void DerivedTypeTest ()
1497                 {
1498                         string code = GenerateDerivedType (Options);
1499                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1500 #if NET_2_0
1501                                 "internal interface Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
1502 #else
1503                                 "interface Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
1504 #endif
1505                                 "}}{0}", NewLine), code);
1506                 }
1507
1508                 [Test]
1509                 public override void AttributesAndTypeTest ()
1510                 {
1511                         string code = GenerateAttributesAndType (Options);
1512                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1513                                 "[A()]{0}" +
1514                                 "[B()]{0}" +
1515                                 "public interface Test1 {{{0}" +
1516                                 "}}{0}", NewLine), code);
1517                 }
1518
1519                 [Test]
1520                 public override void EventMembersTypeTest1 ()
1521                 {
1522                         string code = GenerateEventMembersType1 (Options);
1523                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1524                                 "public interface Test1 {{{0}" +
1525                                 "    {0}" +
1526                                 "    [A()]{0}" +
1527                                 "    [B()]{0}" +
1528                                 "    private event void ;{0}" +
1529                                 "}}{0}", NewLine), code);
1530                 }
1531
1532                 [Test]
1533                 public override void EventMembersTypeTest2 ()
1534                 {
1535                         string code = GenerateEventMembersType2 (Options);
1536                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1537                                 "public interface Test1 {{{0}" +
1538                                 "    {0}" +
1539                                 "    public event int Click;{0}" +
1540                                 "}}{0}", NewLine), code);
1541                 }
1542
1543                 [Test]
1544                 public override void EventImplementationTypes ()
1545                 {
1546                         string code = GenerateEventImplementationTypes (Options);
1547                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1548                                 "public interface Test1 {{{0}" +
1549                                 "    {0}" +
1550 #if NET_2_0
1551                                 "    internal event int Click;{0}" +
1552 #else
1553                                 "    /*FamANDAssem*/ internal event int Click;{0}" +
1554 #endif
1555                                 "}}{0}", NewLine), code);
1556                 }
1557
1558                 [Test]
1559                 public override void EventPrivateImplementationType ()
1560                 {
1561                         string code = GenerateEventPrivateImplementationType (Options);
1562                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1563                                 "public interface Test1 {{{0}" +
1564                                 "    {0}" +
1565                                 "    event int System.Int32.Click;{0}" +
1566                                 "}}{0}", NewLine), code);
1567                 }
1568
1569                 [Test]
1570                 public override void EventImplementationTypeOrder ()
1571                 {
1572                         string code = GenerateEventImplementationTypeOrder (Options);
1573                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1574                                 "public interface Test1 {{{0}" +
1575                                 "    {0}" +
1576                                 "    event int System.Int32.Click;{0}" +
1577                                 "}}{0}", NewLine), code);
1578                 }
1579
1580                 [Test]
1581                 public override void FieldMembersAttributesTest ()
1582                 {
1583                         string code = GenerateFieldMembersAttributes (Options);
1584                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1585                                 "public interface Test1 {{{0}" +
1586                                 "    {0}" +
1587                                 "}}{0}", NewLine), code);
1588                 }
1589
1590                 [Test]
1591                 public override void FieldMembersTypeTest ()
1592                 {
1593                         string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
1594                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1595                                 "public interface Test1 {{{0}" +
1596                                 "    {0}" +
1597                                 "}}{0}", NewLine), code);
1598                 }
1599
1600                 [Test]
1601                 public override void FieldNewSlotTest ()
1602                 {
1603                         string code = GenerateFieldMembersType (MemberAttributes.Assembly |
1604                                 MemberAttributes.New, Options);
1605                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1606                                 "public interface Test1 {{{0}" +
1607                                 "    {0}" +
1608                                 "}}{0}", NewLine), code);
1609                 }
1610
1611                 [Test]
1612                 public override void PropertyMembersTypeTest1 ()
1613                 {
1614                         string code = GeneratePropertyMembersAttributes (Options);
1615                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1616                                 "public interface Test1 {{{0}" +
1617                                 "    {0}" +
1618                                 "    [A()]{0}" +
1619                                 "    [B()]{0}" +
1620                                 "    void  {{{0}" +
1621                                 "    }}{0}" +
1622                                 "}}{0}", NewLine), code);
1623                 }
1624
1625                 [Test]
1626                 public override void PropertyMembersTypeTest2 ()
1627                 {
1628                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
1629                                 false, false, Options);
1630                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1631                                 "public interface Test1 {{{0}" +
1632                                 "    {0}" +
1633                                 "    int Name {{{0}" +
1634                                 "    }}{0}" +
1635                                 "}}{0}", NewLine), code);
1636                 }
1637
1638                 [Test]
1639                 public override void PropertyMembersTypeGetOnly ()
1640                 {
1641                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1642                                 true, false, Options);
1643                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1644                                 "public interface Test1 {{{0}" +
1645                                 "    {0}" +
1646                                 "    int Name {{{0}" +
1647                                 "        get;{0}" +
1648                                 "    }}{0}" +
1649                                 "}}{0}", NewLine), code);
1650                 }
1651
1652                 [Test]
1653                 public override void PropertyMembersTypeSetOnly ()
1654                 {
1655                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1656                                 false, true, Options);
1657                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1658                                 "public interface Test1 {{{0}" +
1659                                 "    {0}" +
1660                                 "    int Name {{{0}" +
1661                                 "        set;{0}" +
1662                                 "    }}{0}" +
1663                                 "}}{0}", NewLine), code);
1664                 }
1665
1666                 [Test]
1667                 public override void PropertyMembersTypeGetSet ()
1668                 {
1669                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1670                                 true, true, Options);
1671                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1672                                 "public interface Test1 {{{0}" +
1673                                 "    {0}" +
1674                                 "    int Name {{{0}" +
1675                                 "        get;{0}" +
1676                                 "        set;{0}" +
1677                                 "    }}{0}" +
1678                                 "}}{0}", NewLine), code);
1679                 }
1680
1681                 [Test]
1682                 public void PropertyMembersTypeGetSet_C ()
1683                 {
1684                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
1685                         options.BracingStyle = "C";
1686
1687                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
1688                                 true, true, options);
1689                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1690                                 "public interface Test1{0}" +
1691                                 "{{{0}" +
1692                                 "    {0}" +
1693                                 "    int Name{0}" +
1694                                 "    {{{0}" +
1695                                 "        get;{0}" +
1696                                 "        set;{0}" +
1697                                 "    }}{0}" +
1698                                 "}}{0}", NewLine), code);
1699                 }
1700
1701                 [Test]
1702                 public override void PropertyMembersTypeFamilyOrAssembly ()
1703                 {
1704                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
1705                                 false, false, Options);
1706                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1707                                 "public interface Test1 {{{0}" +
1708                                 "    {0}" +
1709                                 "    int Name {{{0}" +
1710                                 "    }}{0}" +
1711                                 "}}{0}", NewLine), code);
1712                 }
1713
1714                 [Test]
1715                 public override void PropertyMembersTypeAssembly ()
1716                 {
1717                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1718                                 false, false, Options);
1719                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1720                                 "public interface Test1 {{{0}" +
1721                                 "    {0}" +
1722                                 "    int Name {{{0}" +
1723                                 "    }}{0}" +
1724                                 "}}{0}", NewLine), code);
1725                 }
1726
1727                 [Test]
1728                 public override void PropertyParametersTest ()
1729                 {
1730                         string code = GeneratePropertyParameters (Options);
1731                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1732                                 "public interface Test1 {{{0}" +
1733                                 "    {0}" +
1734                                 "    int Name {{{0}" +
1735                                 "    }}{0}" +
1736                                 "}}{0}", NewLine), code);
1737                 }
1738
1739                 [Test]
1740                 public override void PropertyIndexerTest1 ()
1741                 {
1742                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
1743                                 false, false, true, Options);
1744                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1745                                 "public interface Test1 {{{0}" +
1746                                 "    {0}" +
1747                                 "    int this[object value1, ref int value2] {{{0}" +
1748                                 "    }}{0}" +
1749                                 "}}{0}", NewLine), code);
1750                 }
1751
1752                 [Test]
1753                 public override void PropertyIndexerTest2 ()
1754                 {
1755                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
1756                                 false, false, false, Options);
1757                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1758                                 "public interface Test1 {{{0}" +
1759                                 "    {0}" +
1760                                 "    int iTem {{{0}" +
1761                                 "    }}{0}" +
1762                                 "}}{0}", NewLine), code);
1763                 }
1764
1765                 [Test]
1766                 public override void PropertyIndexerGetOnly ()
1767                 {
1768                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
1769                                 true, false, true, Options);
1770                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1771                                 "public interface Test1 {{{0}" +
1772                                 "    {0}" +
1773                                 "    int this[object value1, ref int value2] {{{0}" +
1774                                 "        get;{0}" +
1775                                 "    }}{0}" +
1776                                 "}}{0}", NewLine), code);
1777                 }
1778
1779                 [Test]
1780                 public override void PropertyIndexerSetOnly ()
1781                 {
1782                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
1783                                 false, true, true, Options);
1784                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1785                                 "public interface Test1 {{{0}" +
1786                                 "    {0}" +
1787                                 "    int this[object value1, ref int value2] {{{0}" +
1788                                 "        set;{0}" +
1789                                 "    }}{0}" +
1790                                 "}}{0}", NewLine), code);
1791                 }
1792
1793                 [Test]
1794                 public override void PropertyImplementationTypes ()
1795                 {
1796                         string code = GeneratePropertyImplementationTypes (Options);
1797                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1798                                 "public interface Test1 {{{0}" +
1799                                 "    {0}" +
1800                                 "    int Name {{{0}" +
1801                                 "    }}{0}" +
1802                                 "}}{0}", NewLine), code);
1803                 }
1804
1805                 [Test]
1806                 public override void PropertyOverloadsTest1 ()
1807                 {
1808                         string code = GeneratePropertyOverloads1 (Options);
1809                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1810                                 "public interface Test1 {{{0}" +
1811                                 "    {0}" +
1812                                 "    int Name {{{0}" +
1813                                 "    }}{0}" +
1814                                 "}}{0}", NewLine), code);
1815                 }
1816
1817                 [Test]
1818                 public override void PropertyOverloadsTest2 ()
1819                 {
1820                         string code = GeneratePropertyOverloads2 (Options);
1821                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1822                                 "public interface Test1 {{{0}" +
1823                                 "    {0}" +
1824                                 "    int Name {{{0}" +
1825                                 "    }}{0}" +
1826                                 "    {0}" +
1827                                 "    int Name {{{0}" +
1828                                 "    }}{0}" +
1829                                 "}}{0}", NewLine), code);
1830                 }
1831
1832                 [Test]
1833                 public override void PropertyOverloadsTest3 ()
1834                 {
1835                         string code = GeneratePropertyOverloads3 (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 PropertyPrivateImplementationType ()
1849                 {
1850                         string code = GeneratePropertyPrivateImplementationType (Options);
1851                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1852                                 "public interface Test1 {{{0}" +
1853                                 "    {0}" +
1854                                 "    int this[object value1] {{{0}" +
1855                                 "    }}{0}" +
1856                                 "}}{0}", NewLine), code);
1857                 }
1858
1859                 [Test]
1860                 public override void PropertyImplementationTypeOrder ()
1861                 {
1862                         string code = GeneratePropertyImplementationTypeOrder (Options);
1863                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1864                                 "public interface Test1 {{{0}" +
1865                                 "    {0}" +
1866                                 "    int this[object value1] {{{0}" +
1867                                 "    }}{0}" +
1868                                 "}}{0}", NewLine), code);
1869                 }
1870
1871                 [Test]
1872                 public override void PropertyNewSlotTest ()
1873                 {
1874                         string code = GeneratePropertyMembersType (MemberAttributes.Private |
1875                                 MemberAttributes.New, true, true, Options);
1876                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1877                                 "public interface Test1 {{{0}" +
1878                                 "    {0}" +
1879                                 "    new int Name {{{0}" +
1880                                 "        get;{0}" +
1881                                 "        set;{0}" +
1882                                 "    }}{0}" +
1883                                 "}}{0}", NewLine), code);
1884                 }
1885
1886                 [Test]
1887                 public override void MethodMembersTypeTest1 ()
1888                 {
1889                         string code = GenerateMethodMembersType1 (Options);
1890                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1891                                 "public interface Test1 {{{0}" +
1892                                 "    {0}" +
1893                                 "    [A()]{0}" +
1894                                 "    [B()]{0}" +
1895                                 "    void ();{0}" +
1896                                 "}}{0}", NewLine), code);
1897                 }
1898
1899                 [Test]
1900                 public void MethodMembersTypeTest1_C ()
1901                 {
1902                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
1903                         options.BracingStyle = "C";
1904
1905                         string code = GenerateMethodMembersType1 (options);
1906                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1907                                 "public interface Test1{0}" +
1908                                 "{{{0}" +
1909                                 "    {0}" +
1910                                 "    [A()]{0}" +
1911                                 "    [B()]{0}" +
1912                                 "    void ();{0}" +
1913                                 "}}{0}", NewLine), code);
1914                 }
1915
1916                 [Test]
1917                 public override void MethodMembersTypeTest2 ()
1918                 {
1919                         string code = GenerateMethodMembersType2 (Options);
1920                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1921                                 "public interface Test1 {{{0}" +
1922                                 "    {0}" +
1923                                 "    int Something(object value1, object value2, out int index, ref int count);{0}" +
1924                                 "}}{0}", NewLine), code);
1925                 }
1926
1927                 [Test]
1928                 public override void MethodMembersTypeTest3 ()
1929                 {
1930                         string code = GenerateMethodMembersType3 (Options);
1931                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1932                                 "public interface Test1 {{{0}" +
1933                                 "    {0}" +
1934                                 "    int Something([A()] [B()] object value, [C(A1=false, A2=true)] [D()] out int );{0}" +
1935                                 "}}{0}", NewLine), code);
1936                 }
1937
1938                 [Test]
1939                 public override void MethodImplementationTypes ()
1940                 {
1941                         string code = GenerateMethodImplementationTypes (Options);
1942                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1943                                 "public interface Test1 {{{0}" +
1944                                 "    {0}" +
1945                                 "    int Execute();{0}" +
1946                                 "}}{0}", NewLine), code);
1947                 }
1948
1949                 [Test]
1950                 public override void MethodOverloadsTest1 ()
1951                 {
1952                         string code = GenerateMethodOverloads1 (Options);
1953                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1954                                 "public interface Test1 {{{0}" +
1955                                 "    {0}" +
1956                                 "    int Execute();{0}" +
1957                                 "}}{0}", NewLine), code);
1958                 }
1959
1960                 [Test]
1961                 public override void MethodOverloadsTest2 ()
1962                 {
1963                         string code = GenerateMethodOverloads2 (Options);
1964                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1965                                 "public interface Test1 {{{0}" +
1966                                 "    {0}" +
1967                                 "    void Execute();{0}" +
1968                                 "    {0}" +
1969                                 "    int Execute(object value1);{0}" +
1970                                 "}}{0}", NewLine), code);
1971                 }
1972
1973                 [Test]
1974                 public override void MethodOverloadsTest3 ()
1975                 {
1976                         string code = GenerateMethodOverloads3 (Options);
1977                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1978                                 "public interface Test1 {{{0}" +
1979                                 "    {0}" +
1980                                 "    void Execute();{0}" +
1981                                 "    {0}" +
1982                                 "    int System.Int32.Execute(object value1);{0}" +
1983                                 "}}{0}", NewLine), code);
1984                 }
1985
1986                 [Test]
1987                 public override void MethodPrivateImplementationType ()
1988                 {
1989                         string code = GenerateMethodPrivateImplementationType (Options);
1990                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1991                                 "public interface Test1 {{{0}" +
1992                                 "    {0}" +
1993                                 "    int System.Int32.Execute(object value1);{0}" +
1994                                 "}}{0}", NewLine), code);
1995                 }
1996
1997                 [Test]
1998                 public override void MethodImplementationTypeOrder ()
1999                 {
2000                         string code = GenerateMethodImplementationTypeOrder (Options);
2001                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2002                                 "public interface Test1 {{{0}" +
2003                                 "    {0}" +
2004                                 "    int System.Int32.Execute(object value1);{0}" +
2005                                 "}}{0}", NewLine), code);
2006                 }
2007
2008                 [Test]
2009                 public override void MethodReturnTypeAttributes ()
2010                 {
2011                         string code = GenerateMethodReturnTypeAttributes (Options);
2012                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2013                                 "public interface Test1 {{{0}" +
2014                                 "    {0}" +
2015                                 "    [A()]{0}" +
2016                                 "    [B()]{0}" +
2017                                 "    [return: C(A1=false, A2=true)]{0}" +
2018                                 "    [return: D()]{0}" +
2019                                 "    int Execute();{0}" +
2020                                 "}}{0}", NewLine), code);
2021                 }
2022
2023                 [Test]
2024                 public override void MethodNewSlotTest ()
2025                 {
2026                         string code = GenerateMethodNewSlot (Options);
2027                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2028                                 "public interface Test1 {{{0}" +
2029                                 "    {0}" +
2030                                 "    new int Execute();{0}" +
2031                                 "}}{0}", NewLine), code);
2032                 }
2033
2034                 [Test]
2035                 public override void ConstructorAttributesTest ()
2036                 {
2037                         string code = GenerateConstructorAttributes (Options);
2038                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2039                                 "public interface Test1 {{{0}" +
2040                                 "    {0}" +
2041                                 "}}{0}", NewLine), code);
2042                 }
2043
2044                 [Test]
2045                 public void ConstructorAttributesTest_C ()
2046                 {
2047                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
2048                         options.BracingStyle = "C";
2049
2050                         string code = GenerateConstructorAttributes (options);
2051                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2052                                 "public interface Test1{0}" +
2053                                 "{{{0}" +
2054                                 "    {0}" +
2055                                 "}}{0}", NewLine), code);
2056                 }
2057
2058                 [Test]
2059                 public override void ConstructorParametersTest ()
2060                 {
2061                         string code = GenerateConstructorParameters (Options);
2062                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2063                                 "public interface Test1 {{{0}" +
2064                                 "    {0}" +
2065                                 "}}{0}", NewLine), code);
2066                 }
2067
2068                 [Test]
2069                 public override void ConstructorParameterAttributesTest ()
2070                 {
2071                         string code = GenerateConstructorParameterAttributes (Options);
2072                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2073                                 "public interface Test1 {{{0}" +
2074                                 "    {0}" +
2075                                 "}}{0}", NewLine), code, "#1");
2076                 }
2077
2078                 [Test]
2079                 public override void BaseConstructorSingleArg ()
2080                 {
2081                         string code = GenerateBaseConstructor (false, Options);
2082                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2083                                 "public interface Test1 {{{0}" +
2084                                 "    {0}" +
2085                                 "}}{0}", NewLine), code);
2086                 }
2087
2088                 [Test]
2089                 public override void BaseConstructorMultipleArgs ()
2090                 {
2091                         string code = GenerateBaseConstructor (true, Options);
2092                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2093                                 "public interface Test1 {{{0}" +
2094                                 "    {0}" +
2095                                 "}}{0}", NewLine), code);
2096                 }
2097
2098                 [Test]
2099                 public override void ChainedConstructorSingleArg ()
2100                 {
2101                         string code = GenerateChainedConstructor (false, Options);
2102                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2103                                 "public interface Test1 {{{0}" +
2104                                 "    {0}" +
2105                                 "}}{0}", NewLine), code);
2106                 }
2107
2108                 [Test]
2109                 public override void ChainedConstructorMultipleArgs ()
2110                 {
2111                         string code = GenerateChainedConstructor (true, Options);
2112                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2113                                 "public interface Test1 {{{0}" +
2114                                 "    {0}" +
2115                                 "}}{0}", NewLine), code);
2116                 }
2117
2118                 [Test]
2119                 public override void TypeConstructorTest ()
2120                 {
2121                         string code = GenerateTypeConstructor (Options);
2122                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2123                                 "public interface Test1 {{{0}" +
2124                                 "    {0}" +
2125                                 "}}{0}", NewLine), code);
2126                 }
2127
2128                 [Test]
2129                 public void TypeConstructorTest_C ()
2130                 {
2131                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
2132                         options.BracingStyle = "C";
2133
2134                         string code = GenerateTypeConstructor (options);
2135                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2136                                 "public interface Test1{0}" +
2137                                 "{{{0}" +
2138                                 "    {0}" +
2139                                 "}}{0}", NewLine), code);
2140                 }
2141
2142                 [Test]
2143                 public override void EntryPointMethodTest ()
2144                 {
2145                         string code = GenerateEntryPointMethod (Options);
2146                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2147                                 "public interface Test1 {{{0}" +
2148                                 "    {0}" +
2149 #if NET_2_0
2150                                 "    [A()]{0}" +
2151                                 "    public static int Main() {{{0}" +
2152 #else
2153                                 "    public static void Main() {{{0}" +
2154 #endif
2155                                 "        Test.InnerType x;{0}" +
2156                                 "    }}{0}" +
2157                                 "}}{0}", NewLine), code);
2158                 }
2159
2160                 #endregion Override implementation of CodeGeneratorFromTypeTestBase
2161         }
2162
2163         [TestFixture]
2164         public class CodeGeneratorFromTypeTest_Struct : CodeGeneratorFromTypeTestBase
2165         {
2166                 private CodeTypeDeclaration _typeDeclaration;
2167                 private ICodeGenerator _codeGenerator;
2168
2169                 #region Override implementation of CodeGeneratorTestBase
2170
2171                 protected override ICodeGenerator CodeGenerator
2172                 {
2173                         get { return _codeGenerator; }
2174                 }
2175
2176                 [SetUp]
2177                 public override void SetUp ()
2178                 {
2179                         base.SetUp ();
2180                         _typeDeclaration = new CodeTypeDeclaration ();
2181                         _typeDeclaration.IsStruct = true;
2182
2183                         CodeDomProvider provider = new CSharpCodeProvider ();
2184                         _codeGenerator = provider.CreateGenerator ();
2185                 }
2186
2187                 #endregion Override implementation of CodeGeneratorTestBase
2188
2189                 #region Override implementation of CodeGeneratorFromTypeTestBase
2190
2191                 protected override CodeTypeDeclaration TypeDeclaration
2192                 {
2193                         get { return _typeDeclaration; }
2194                 }
2195
2196                 [Test]
2197                 public override void DefaultTypeTest ()
2198                 {
2199                         string code = GenerateDefaultType (Options);
2200                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2201                                 "public struct  {{{0}" +
2202                                 "}}{0}", NewLine), code);
2203                 }
2204
2205                 [Test]
2206                 public void DefaultTypeTest_C ()
2207                 {
2208                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
2209                         options.BracingStyle = "C";
2210
2211                         string code = GenerateDefaultType (options);
2212                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2213                                 "public struct {0}" +
2214                                 "{{{0}" +
2215                                 "}}{0}", NewLine), code);
2216                 }
2217
2218                 [Test]
2219                 [ExpectedException (typeof (NullReferenceException))]
2220                 public override void NullTypeTest ()
2221                 {
2222                         GenerateNullType (Options);
2223                 }
2224
2225                 [Test]
2226                 public override void SimpleTypeTest ()
2227                 {
2228                         string code = GenerateSimpleType (Options);
2229                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2230                                 "public struct Test1 {{{0}" +
2231                                 "}}{0}", NewLine), code);
2232                 }
2233
2234                 [Test]
2235                 public void SimpleTypeTest_C ()
2236                 {
2237                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
2238                         options.BracingStyle = "C";
2239
2240                         string code = GenerateSimpleType (options);
2241                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2242                                 "public struct Test1{0}" +
2243                                 "{{{0}" +
2244                                 "}}{0}", NewLine), code);
2245                 }
2246
2247                 [Test]
2248                 public override void DerivedTypeTest ()
2249                 {
2250                         string code = GenerateDerivedType (Options);
2251                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2252 #if NET_2_0
2253                                 "internal struct Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
2254 #else
2255                                 "struct Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
2256 #endif
2257                                 "}}{0}", NewLine), code);
2258                 }
2259
2260                 [Test]
2261                 public override void AttributesAndTypeTest ()
2262                 {
2263                         string code = GenerateAttributesAndType (Options);
2264                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2265                                 "[A()]{0}" +
2266                                 "[B()]{0}" +
2267                                 "public struct Test1 {{{0}" +
2268                                 "}}{0}", NewLine), code);
2269                 }
2270
2271                 [Test]
2272                 public override void EventMembersTypeTest1 ()
2273                 {
2274                         string code = GenerateEventMembersType1 (Options);
2275                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2276                                 "public struct Test1 {{{0}" +
2277                                 "    {0}" +
2278                                 "    [A()]{0}" +
2279                                 "    [B()]{0}" +
2280                                 "    private event void ;{0}" +
2281                                 "}}{0}", NewLine), code);
2282                 }
2283
2284                 [Test]
2285                 public override void EventMembersTypeTest2 ()
2286                 {
2287                         string code = GenerateEventMembersType2 (Options);
2288                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2289                                 "public struct Test1 {{{0}" +
2290                                 "    {0}" +
2291                                 "    public event int Click;{0}" +
2292                                 "}}{0}", NewLine), code);
2293                 }
2294
2295                 [Test]
2296                 public override void EventImplementationTypes ()
2297                 {
2298                         string code = GenerateEventImplementationTypes (Options);
2299                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2300                                 "public struct Test1 {{{0}" +
2301                                 "    {0}" +
2302 #if NET_2_0
2303                                 "    internal event int Click;{0}" +
2304 #else
2305                                 "    /*FamANDAssem*/ internal event int Click;{0}" +
2306 #endif
2307                                 "}}{0}", NewLine), code);
2308                 }
2309
2310                 [Test]
2311                 public override void EventPrivateImplementationType ()
2312                 {
2313                         string code = GenerateEventPrivateImplementationType (Options);
2314                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2315                                 "public struct Test1 {{{0}" +
2316                                 "    {0}" +
2317                                 "    event int System.Int32.Click;{0}" +
2318                                 "}}{0}", NewLine), code);
2319                 }
2320
2321                 [Test]
2322                 public override void EventImplementationTypeOrder ()
2323                 {
2324                         string code = GenerateEventImplementationTypeOrder (Options);
2325                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2326                                 "public struct Test1 {{{0}" +
2327                                 "    {0}" +
2328                                 "    event int System.Int32.Click;{0}" +
2329                                 "}}{0}", NewLine), code);
2330                 }
2331
2332                 [Test]
2333                 public override void FieldMembersAttributesTest ()
2334                 {
2335                         string code = GenerateFieldMembersAttributes (Options);
2336                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2337                                 "public struct Test1 {{{0}" +
2338                                 "    {0}" +
2339                                 "    [A()]{0}" +
2340                                 "    [B()]{0}" +
2341                                 "    private void ;{0}" +
2342                                 "}}{0}", NewLine), code);
2343                 }
2344
2345                 [Test]
2346                 public override void FieldMembersTypeTest ()
2347                 {
2348                         string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
2349                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2350                                 "public struct Test1 {{{0}" +
2351                                 "    {0}" +
2352                                 "    public int Name = 2;{0}" +
2353                                 "}}{0}", NewLine), code);
2354                 }
2355
2356                 [Test]
2357                 public override void FieldNewSlotTest ()
2358                 {
2359                         string code = GenerateFieldMembersType (MemberAttributes.Assembly |
2360                                 MemberAttributes.New, Options);
2361                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2362                                 "public struct Test1 {{{0}" +
2363                                 "    {0}" +
2364                                 "    internal new int Name = 2;{0}" +
2365                                 "}}{0}", NewLine), code);
2366                 }
2367
2368                 [Test]
2369                 public override void PropertyMembersTypeTest1 ()
2370                 {
2371                         string code = GeneratePropertyMembersAttributes (Options);
2372                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2373                                 "public struct Test1 {{{0}" +
2374                                 "    {0}" +
2375                                 "    [A()]{0}" +
2376                                 "    [B()]{0}" +
2377                                 "    private void  {{{0}" +
2378                                 "    }}{0}" +
2379                                 "}}{0}", NewLine), code);
2380                 }
2381
2382                 [Test]
2383                 public override void PropertyMembersTypeTest2 ()
2384                 {
2385                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
2386                                 false, false, Options);
2387                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2388                                 "public struct Test1 {{{0}" +
2389                                 "    {0}" +
2390                                 "    public virtual int Name {{{0}" +
2391                                 "    }}{0}" +
2392                                 "}}{0}", NewLine), code);
2393                 }
2394
2395                 [Test]
2396                 public override void PropertyMembersTypeGetOnly ()
2397                 {
2398                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
2399                                 true, false, Options);
2400                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2401                                 "public struct Test1 {{{0}" +
2402                                 "    {0}" +
2403                                 "    protected virtual int Name {{{0}" +
2404                                 "        get {{{0}" +
2405                                 "        }}{0}" +
2406                                 "    }}{0}" +
2407                                 "}}{0}", NewLine), code);
2408                 }
2409
2410                 [Test]
2411                 public override void PropertyMembersTypeSetOnly ()
2412                 {
2413                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2414                                 false, true, Options);
2415                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2416                                 "public struct Test1 {{{0}" +
2417                                 "    {0}" +
2418 #if NET_2_0
2419                                 "    internal virtual int Name {{{0}" +
2420 #else
2421                                 "    internal int Name {{{0}" +
2422 #endif
2423                                 "        set {{{0}" +
2424                                 "        }}{0}" +
2425                                 "    }}{0}" +
2426                                 "}}{0}", NewLine), code);
2427                 }
2428
2429                 [Test]
2430                 public override void PropertyMembersTypeGetSet ()
2431                 {
2432                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
2433                                 true, true, Options);
2434                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2435                                 "public struct Test1 {{{0}" +
2436                                 "    {0}" +
2437                                 "    protected virtual int Name {{{0}" +
2438                                 "        get {{{0}" +
2439                                 "        }}{0}" +
2440                                 "        set {{{0}" +
2441                                 "        }}{0}" +
2442                                 "    }}{0}" +
2443                                 "}}{0}", NewLine), code);
2444                 }
2445
2446                 [Test]
2447                 public void PropertyMembersTypeGetSet_C ()
2448                 {
2449                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
2450                         options.BracingStyle = "C";
2451
2452                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
2453                                 true, true, options);
2454                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2455                                 "public struct Test1{0}" +
2456                                 "{{{0}" +
2457                                 "    {0}" +
2458                                 "    protected virtual int Name{0}" +
2459                                 "    {{{0}" +
2460                                 "        get{0}" +
2461                                 "        {{{0}" +
2462                                 "        }}{0}" +
2463                                 "        set{0}" +
2464                                 "        {{{0}" +
2465                                 "        }}{0}" +
2466                                 "    }}{0}" +
2467                                 "}}{0}", NewLine), code);
2468                 }
2469
2470                 [Test]
2471                 public override void PropertyMembersTypeFamilyOrAssembly ()
2472                 {
2473                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
2474                                 false, false, Options);
2475                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2476                                 "public struct Test1 {{{0}" +
2477                                 "    {0}" +
2478                                 "    protected internal int Name {{{0}" +
2479                                 "    }}{0}" +
2480                                 "}}{0}", NewLine), code);
2481                 }
2482
2483                 [Test]
2484                 public override void PropertyMembersTypeAssembly ()
2485                 {
2486                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2487                                 false, false, Options);
2488                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2489                                 "public struct Test1 {{{0}" +
2490                                 "    {0}" +
2491 #if NET_2_0
2492                                 "    internal virtual int Name {{{0}" +
2493 #else
2494                                 "    internal int Name {{{0}" +
2495 #endif
2496                                 "    }}{0}" +
2497                                 "}}{0}", NewLine), code);
2498                 }
2499
2500                 [Test]
2501                 public override void PropertyParametersTest ()
2502                 {
2503                         string code = GeneratePropertyParameters (Options);
2504                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2505                                 "public struct Test1 {{{0}" +
2506                                 "    {0}" +
2507                                 "    public virtual int Name {{{0}" +
2508                                 "    }}{0}" +
2509                                 "}}{0}", NewLine), code);
2510                 }
2511
2512                 [Test]
2513                 public override void PropertyIndexerTest1 ()
2514                 {
2515                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
2516                                 false, false, true, Options);
2517                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2518                                 "public struct Test1 {{{0}" +
2519                                 "    {0}" +
2520                                 "    public virtual int this[object value1, ref int value2] {{{0}" +
2521                                 "    }}{0}" +
2522                                 "}}{0}", NewLine), code);
2523                 }
2524
2525                 [Test]
2526                 public override void PropertyIndexerTest2 ()
2527                 {
2528                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
2529                                 false, false, false, Options);
2530                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2531                                 "public struct Test1 {{{0}" +
2532                                 "    {0}" +
2533                                 "    public virtual int iTem {{{0}" +
2534                                 "    }}{0}" +
2535                                 "}}{0}", NewLine), code);
2536                 }
2537
2538                 [Test]
2539                 public override void PropertyIndexerGetOnly ()
2540                 {
2541                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
2542                                 true, false, true, Options);
2543                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2544                                 "public struct Test1 {{{0}" +
2545                                 "    {0}" +
2546                                 "    protected virtual int this[object value1, ref int value2] {{{0}" +
2547                                 "        get {{{0}" +
2548                                 "        }}{0}" +
2549                                 "    }}{0}" +
2550                                 "}}{0}", NewLine), code);
2551                 }
2552
2553                 [Test]
2554                 public override void PropertyIndexerSetOnly ()
2555                 {
2556                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
2557                                 false, true, 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                                 "        set {{{0}" +
2563                                 "        }}{0}" +
2564                                 "    }}{0}" +
2565                                 "}}{0}", NewLine), code);
2566                 }
2567
2568                 [Test]
2569                 public override void PropertyImplementationTypes ()
2570                 {
2571                         string code = GeneratePropertyImplementationTypes (Options);
2572                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2573                                 "public struct Test1 {{{0}" +
2574                                 "    {0}" +
2575                                 "    public virtual int Name {{{0}" +
2576                                 "    }}{0}" +
2577                                 "}}{0}", NewLine), code);
2578                 }
2579
2580                 [Test]
2581                 public override void PropertyOverloadsTest1 ()
2582                 {
2583                         string code = GeneratePropertyOverloads1 (Options);
2584                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2585                                 "public struct Test1 {{{0}" +
2586                                 "    {0}" +
2587                                 "    protected virtual int Name {{{0}" +
2588                                 "    }}{0}" +
2589                                 "}}{0}", NewLine), code);
2590                 }
2591
2592                 [Test]
2593                 public override void PropertyOverloadsTest2 ()
2594                 {
2595                         string code = GeneratePropertyOverloads2 (Options);
2596                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2597                                 "public struct Test1 {{{0}" +
2598                                 "    {0}" +
2599                                 "    public virtual int Name {{{0}" +
2600                                 "    }}{0}" +
2601                                 "    {0}" +
2602                                 "    private int Name {{{0}" +
2603                                 "    }}{0}" +
2604                                 "}}{0}", NewLine), code);
2605                 }
2606
2607                 [Test]
2608                 public override void PropertyOverloadsTest3 ()
2609                 {
2610                         string code = GeneratePropertyOverloads3 (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                                 "    int System.Int32.Name {{{0}" +
2618                                 "    }}{0}" +
2619                                 "}}{0}", NewLine), code);
2620                 }
2621
2622                 [Test]
2623                 public override void PropertyPrivateImplementationType ()
2624                 {
2625                         string code = GeneratePropertyPrivateImplementationType (Options);
2626                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2627                                 "public struct Test1 {{{0}" +
2628                                 "    {0}" +
2629                                 "    int System.Int32.this[object value1] {{{0}" +
2630                                 "    }}{0}" +
2631                                 "}}{0}", NewLine), code);
2632                 }
2633
2634                 [Test]
2635                 public override void PropertyImplementationTypeOrder ()
2636                 {
2637                         string code = GeneratePropertyImplementationTypeOrder (Options);
2638                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2639                                 "public struct Test1 {{{0}" +
2640                                 "    {0}" +
2641                                 "    int System.Int32.this[object value1] {{{0}" +
2642                                 "    }}{0}" +
2643                                 "}}{0}", NewLine), code);
2644                 }
2645
2646                 [Test]
2647                 public override void PropertyNewSlotTest ()
2648                 {
2649                         string code = GeneratePropertyMembersType (MemberAttributes.Private |
2650                                 MemberAttributes.New, true, true, Options);
2651                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2652                                 "public struct Test1 {{{0}" +
2653                                 "    {0}" +
2654                                 "    private new int Name {{{0}" +
2655                                 "        get {{{0}" +
2656                                 "        }}{0}" +
2657                                 "        set {{{0}" +
2658                                 "        }}{0}" +
2659                                 "    }}{0}" +
2660                                 "}}{0}", NewLine), code);
2661                 }
2662
2663                 [Test]
2664                 public override void MethodMembersTypeTest1 ()
2665                 {
2666                         string code = GenerateMethodMembersType1 (Options);
2667                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2668                                 "public struct Test1 {{{0}" +
2669                                 "    {0}" +
2670                                 "    [A()]{0}" +
2671                                 "    [B()]{0}" +
2672                                 "    private void () {{{0}" +
2673                                 "    }}{0}" +
2674                                 "}}{0}", NewLine), code);
2675                 }
2676
2677                 [Test]
2678                 public void MethodMembersTypeTest1_C ()
2679                 {
2680                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
2681                         options.BracingStyle = "C";
2682
2683                         string code = GenerateMethodMembersType1 (options);
2684                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2685                                 "public struct Test1{0}" +
2686                                 "{{{0}" +
2687                                 "    {0}" +
2688                                 "    [A()]{0}" +
2689                                 "    [B()]{0}" +
2690                                 "    private void (){0}" +
2691                                 "    {{{0}" +
2692                                 "    }}{0}" +
2693                                 "}}{0}", NewLine), code);
2694                 }
2695
2696                 [Test]
2697                 public override void MethodMembersTypeTest2 ()
2698                 {
2699                         string code = GenerateMethodMembersType2 (Options);
2700                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2701                                 "public struct Test1 {{{0}" +
2702                                 "    {0}" +
2703                                 "    public virtual int Something(object value1, object value2, out int index, ref int count) {{{0}" +
2704                                 "    }}{0}" +
2705                                 "}}{0}", NewLine), code);
2706                 }
2707
2708                 [Test]
2709                 public override void MethodMembersTypeTest3 ()
2710                 {
2711                         string code = GenerateMethodMembersType3 (Options);
2712                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2713                                 "public struct Test1 {{{0}" +
2714                                 "    {0}" +
2715                                 "    public virtual int Something([A()] [B()] object value, [C(A1=false, A2=true)] [D()] out int ) {{{0}" +
2716                                 "    }}{0}" +
2717                                 "}}{0}", NewLine), code);
2718                 }
2719
2720                 [Test]
2721                 public override void MethodImplementationTypes ()
2722                 {
2723                         string code = GenerateMethodImplementationTypes (Options);
2724                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2725                                 "public struct Test1 {{{0}" +
2726                                 "    {0}" +
2727 #if NET_2_0
2728                                 "    internal virtual int Execute() {{{0}" +
2729 #else
2730                                 "    internal int Execute() {{{0}" +
2731 #endif
2732                                 "    }}{0}" +
2733                                 "}}{0}", NewLine), code);
2734                 }
2735
2736                 [Test]
2737                 public override void MethodOverloadsTest1 ()
2738                 {
2739                         string code = GenerateMethodOverloads1 (Options);
2740                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2741                                 "public struct Test1 {{{0}" +
2742                                 "    {0}" +
2743 #if NET_2_0
2744                                 "    internal virtual int Execute() {{{0}" +
2745 #else
2746                                 "    internal int Execute() {{{0}" +
2747 #endif
2748                                 "    }}{0}" +
2749                                 "}}{0}", NewLine), code);
2750                 }
2751
2752                 [Test]
2753                 public override void MethodOverloadsTest2 ()
2754                 {
2755                         string code = GenerateMethodOverloads2 (Options);
2756                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2757                                 "public struct Test1 {{{0}" +
2758                                 "    {0}" +
2759                                 "    public virtual void Execute() {{{0}" +
2760                                 "    }}{0}" +
2761                                 "    {0}" +
2762                                 "    private int Execute(object value1) {{{0}" +
2763                                 "    }}{0}" +
2764                                 "}}{0}", NewLine), code);
2765                 }
2766
2767                 [Test]
2768                 public override void MethodOverloadsTest3 ()
2769                 {
2770                         string code = GenerateMethodOverloads3 (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                                 "    int System.Int32.Execute(object value1) {{{0}" +
2778                                 "    }}{0}" +
2779                                 "}}{0}", NewLine), code);
2780                 }
2781
2782                 [Test]
2783                 public override void MethodPrivateImplementationType ()
2784                 {
2785                         string code = GenerateMethodPrivateImplementationType (Options);
2786                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2787                                 "public struct Test1 {{{0}" +
2788                                 "    {0}" +
2789                                 "    int System.Int32.Execute(object value1) {{{0}" +
2790                                 "    }}{0}" +
2791                                 "}}{0}", NewLine), code);
2792                 }
2793
2794                 [Test]
2795                 public override void MethodImplementationTypeOrder ()
2796                 {
2797                         string code = GenerateMethodImplementationTypeOrder (Options);
2798                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2799                                 "public struct Test1 {{{0}" +
2800                                 "    {0}" +
2801                                 "    int System.Int32.Execute(object value1) {{{0}" +
2802                                 "    }}{0}" +
2803                                 "}}{0}", NewLine), code);
2804                 }
2805
2806                 [Test]
2807                 public override void MethodReturnTypeAttributes ()
2808                 {
2809                         string code = GenerateMethodReturnTypeAttributes (Options);
2810                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2811                                 "public struct Test1 {{{0}" +
2812                                 "    {0}" +
2813                                 "    [A()]{0}" +
2814                                 "    [B()]{0}" +
2815                                 "    [return: C(A1=false, A2=true)]{0}" +
2816                                 "    [return: D()]{0}" +
2817                                 "    public virtual int Execute() {{{0}" +
2818                                 "    }}{0}" +
2819                                 "}}{0}", NewLine), code);
2820                 }
2821
2822                 [Test]
2823                 public override void MethodNewSlotTest ()
2824                 {
2825                         string code = GenerateMethodNewSlot (Options);
2826                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2827                                 "public struct Test1 {{{0}" +
2828                                 "    {0}" +
2829                                 "    public new virtual int Execute() {{{0}" +
2830                                 "    }}{0}" +
2831                                 "}}{0}", NewLine), code);
2832                 }
2833
2834                 [Test]
2835                 public override void ConstructorAttributesTest ()
2836                 {
2837                         string code = GenerateConstructorAttributes (Options);
2838                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2839                                 "public struct Test1 {{{0}" +
2840                                 "    {0}" +
2841                                 "    [A()]{0}" +
2842                                 "    [B()]{0}" +
2843                                 "    private Test1() {{{0}" +
2844                                 "    }}{0}" +
2845                                 "}}{0}", NewLine), code);
2846                 }
2847
2848                 [Test]
2849                 public void ConstructorAttributesTest_C ()
2850                 {
2851                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
2852                         options.BracingStyle = "C";
2853
2854                         string code = GenerateConstructorAttributes (options);
2855                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2856                                 "public struct Test1{0}" +
2857                                 "{{{0}" +
2858                                 "    {0}" +
2859                                 "    [A()]{0}" +
2860                                 "    [B()]{0}" +
2861                                 "    private Test1(){0}" +
2862                                 "    {{{0}" +
2863                                 "    }}{0}" +
2864                                 "}}{0}", NewLine), code);
2865                 }
2866
2867                 [Test]
2868                 public override void ConstructorParametersTest ()
2869                 {
2870                         string code = GenerateConstructorParameters (Options);
2871                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2872                                 "public struct Test1 {{{0}" +
2873                                 "    {0}" +
2874                                 "    public Test1(object value1, object value2, out int index, ref int count) {{{0}" +
2875                                 "    }}{0}" +
2876                                 "}}{0}", NewLine), code);
2877                 }
2878
2879                 [Test]
2880                 public override void ConstructorParameterAttributesTest ()
2881                 {
2882                         string code = GenerateConstructorParameterAttributes (Options);
2883                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2884                                 "public struct Test1 {{{0}" +
2885                                 "    {0}" +
2886                                 "    private Test1([A()] [B()] object value, [C(A1=false, A2=true)] [D()] out int index) {{{0}" +
2887                                 "    }}{0}" +
2888                                 "}}{0}", NewLine), code);
2889                 }
2890
2891                 [Test]
2892                 public override void BaseConstructorSingleArg ()
2893                 {
2894                         string code = GenerateBaseConstructor (false, Options);
2895                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2896                                 "public struct Test1 {{{0}" +
2897                                 "    {0}" +
2898                                 "    protected Test1(object value1, out int value2) : {0}" +
2899                                 "            base(value1) {{{0}" +
2900                                 "    }}{0}" +
2901                                 "}}{0}", NewLine), code);
2902                 }
2903
2904                 [Test]
2905                 public override void BaseConstructorMultipleArgs ()
2906                 {
2907                         string code = GenerateBaseConstructor (true, Options);
2908                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2909                                 "public struct Test1 {{{0}" +
2910                                 "    {0}" +
2911                                 "    protected Test1(object value1, out int value2) : {0}" +
2912                                 "            base(value1, value2) {{{0}" +
2913                                 "    }}{0}" +
2914                                 "}}{0}", NewLine), code);
2915                 }
2916
2917                 [Test]
2918                 public override void ChainedConstructorSingleArg ()
2919                 {
2920                         string code = GenerateChainedConstructor (false, Options);
2921                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2922                                 "public struct Test1 {{{0}" +
2923                                 "    {0}" +
2924                                 "    public Test1(object value1, out int value2) : {0}" +
2925                                 "            base(value3) : {0}" +
2926                                 "            this(value1) {{{0}" +
2927                                 "    }}{0}" +
2928                                 "}}{0}", NewLine), code);
2929                 }
2930
2931                 [Test]
2932                 public override void ChainedConstructorMultipleArgs ()
2933                 {
2934                         string code = GenerateChainedConstructor (true, Options);
2935                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2936                                 "public struct Test1 {{{0}" +
2937                                 "    {0}" +
2938                                 "    public Test1(object value1, out int value2) : {0}" +
2939                                 "            base(value3) : {0}" +
2940                                 "            this(value1, value2) {{{0}" +
2941                                 "    }}{0}" +
2942                                 "}}{0}", NewLine), code);
2943                 }
2944
2945                 [Test]
2946                 public override void TypeConstructorTest ()
2947                 {
2948                         string code = GenerateTypeConstructor (Options);
2949                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2950                                 "public struct Test1 {{{0}" +
2951                                 "    {0}" +
2952 #if NET_2_0
2953                                 "    [A()]{0}" +
2954                                 "    [B()]{0}" +
2955 #endif
2956                                 "    static Test1() {{{0}" +
2957                                 "    }}{0}" +
2958                                 "}}{0}", NewLine), code, "#1");
2959                 }
2960
2961                 [Test]
2962                 public void TypeConstructorTest_C ()
2963                 {
2964                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
2965                         options.BracingStyle = "C";
2966
2967                         string code = GenerateTypeConstructor (options);
2968                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2969                                 "public struct Test1{0}" +
2970                                 "{{{0}" +
2971                                 "    {0}" +
2972 #if NET_2_0
2973                                 "    [A()]{0}" +
2974                                 "    [B()]{0}" +
2975 #endif
2976                                 "    static Test1(){0}" +
2977                                 "    {{{0}" +
2978                                 "    }}{0}" +
2979                                 "}}{0}", NewLine), code, "#2");
2980                 }
2981
2982                 [Test]
2983                 public override void EntryPointMethodTest ()
2984                 {
2985                         string code = GenerateEntryPointMethod (Options);
2986                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2987                                 "public struct Test1 {{{0}" +
2988                                 "    {0}" +
2989 #if NET_2_0
2990                                 "    [A()]{0}" +
2991                                 "    public static int Main() {{{0}" +
2992 #else
2993                                 "    public static void Main() {{{0}" +
2994 #endif
2995                                 "        Test.InnerType x;{0}" +
2996                                 "    }}{0}" +
2997                                 "}}{0}", NewLine), code);
2998                 }
2999
3000                 #endregion Override implementation of CodeGeneratorFromTypeTestBase
3001         }
3002
3003         [TestFixture]
3004         public class CodeGeneratorFromTypeTest_Enum : CodeGeneratorFromTypeTestBase
3005         {
3006                 private CodeTypeDeclaration _typeDeclaration;
3007                 private ICodeGenerator _codeGenerator;
3008
3009                 #region Override implementation of CodeGeneratorTestBase
3010
3011                 protected override ICodeGenerator CodeGenerator
3012                 {
3013                         get { return _codeGenerator; }
3014                 }
3015
3016                 [SetUp]
3017                 public override void SetUp ()
3018                 {
3019                         base.SetUp ();
3020                         _typeDeclaration = new CodeTypeDeclaration ();
3021                         _typeDeclaration.IsEnum = true;
3022
3023                         CodeDomProvider provider = new CSharpCodeProvider ();
3024                         _codeGenerator = provider.CreateGenerator ();
3025                 }
3026
3027                 #endregion Override implementation of CodeGeneratorTestBase
3028
3029                 #region Override implementation of CodeGeneratorFromTypeTestBase
3030
3031                 protected override CodeTypeDeclaration TypeDeclaration
3032                 {
3033                         get { return _typeDeclaration; }
3034                 }
3035
3036                 [Test]
3037                 public override void DefaultTypeTest ()
3038                 {
3039                         string code = GenerateDefaultType (Options);
3040                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3041                                 "public enum  {{{0}" +
3042                                 "}}{0}", NewLine), code);
3043                 }
3044
3045                 [Test]
3046                 public void DefaultTypeTest_C ()
3047                 {
3048                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
3049                         options.BracingStyle = "C";
3050
3051                         string code = GenerateDefaultType (options);
3052                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3053                                 "public enum {0}" +
3054                                 "{{{0}" +
3055                                 "}}{0}", NewLine), code);
3056                 }
3057
3058                 [Test]
3059                 [ExpectedException (typeof (NullReferenceException))]
3060                 public override void NullTypeTest ()
3061                 {
3062                         GenerateNullType (Options);
3063                 }
3064
3065                 [Test]
3066                 public override void SimpleTypeTest ()
3067                 {
3068                         string code = GenerateSimpleType (Options);
3069                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3070                                 "public enum Test1 {{{0}" +
3071                                 "}}{0}", NewLine), code);
3072                 }
3073
3074                 [Test]
3075                 public void SimpleTypeTest_C ()
3076                 {
3077                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
3078                         options.BracingStyle = "C";
3079
3080                         string code = GenerateSimpleType (options);
3081                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3082                                 "public enum Test1{0}" +
3083                                 "{{{0}" +
3084                                 "}}{0}", NewLine), code);
3085                 }
3086
3087                 [Test]
3088                 public override void DerivedTypeTest ()
3089                 {
3090                         string code = GenerateDerivedType (Options);
3091                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3092 #if NET_2_0
3093                                 "internal enum Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
3094 #else
3095                                 "enum Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
3096 #endif
3097                                 "}}{0}", NewLine), code);
3098                 }
3099
3100                 [Test]
3101                 public override void AttributesAndTypeTest ()
3102                 {
3103                         string code = GenerateAttributesAndType (Options);
3104                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3105                                 "[A()]{0}" +
3106                                 "[B()]{0}" +
3107                                 "public enum Test1 {{{0}" +
3108                                 "}}{0}", NewLine), code);
3109                 }
3110
3111                 [Test]
3112                 public override void EventMembersTypeTest1 ()
3113                 {
3114                         string code = GenerateEventMembersType1 (Options);
3115                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3116                                 "public enum Test1 {{{0}" +
3117                                 "    {0}" +
3118                                 "}}{0}", NewLine), code);
3119                 }
3120
3121                 [Test]
3122                 public override void EventMembersTypeTest2 ()
3123                 {
3124                         string code = GenerateEventMembersType2 (Options);
3125                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3126                                 "public enum Test1 {{{0}" +
3127                                 "    {0}" +
3128                                 "}}{0}", NewLine), code);
3129                 }
3130
3131                 [Test]
3132                 public override void EventImplementationTypes ()
3133                 {
3134                         string code = GenerateEventImplementationTypes (Options);
3135                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3136                                 "public enum Test1 {{{0}" +
3137                                 "    {0}" +
3138                                 "}}{0}", NewLine), code);
3139                 }
3140
3141                 [Test]
3142                 public override void EventPrivateImplementationType ()
3143                 {
3144                         string code = GenerateEventPrivateImplementationType (Options);
3145                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3146                                 "public enum Test1 {{{0}" +
3147                                 "    {0}" +
3148                                 "}}{0}", NewLine), code);
3149                 }
3150
3151                 [Test]
3152                 public override void EventImplementationTypeOrder ()
3153                 {
3154                         string code = GenerateEventImplementationTypeOrder (Options);
3155                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3156                                 "public enum Test1 {{{0}" +
3157                                 "    {0}" +
3158                                 "}}{0}", NewLine), code);
3159                 }
3160
3161                 [Test]
3162                 public override void FieldMembersAttributesTest ()
3163                 {
3164                         string code = GenerateFieldMembersAttributes (Options);
3165                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3166                                 "public enum Test1 {{{0}" +
3167                                 "    {0}" +
3168                                 "    [A()]{0}" +
3169                                 "    [B()]{0}" +
3170                                 "    ,{0}" +
3171                                 "}}{0}", NewLine), code);
3172                 }
3173
3174                 [Test]
3175                 public override void FieldMembersTypeTest ()
3176                 {
3177                         string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
3178                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3179                                 "public enum Test1 {{{0}" +
3180                                 "    {0}" +
3181                                 "    Name = 2,{0}" +
3182                                 "}}{0}", NewLine), code);
3183                 }
3184
3185                 [Test]
3186                 public override void FieldNewSlotTest ()
3187                 {
3188                         string code = GenerateFieldMembersType (MemberAttributes.Assembly |
3189                                 MemberAttributes.New, Options);
3190                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3191                                 "public enum Test1 {{{0}" +
3192                                 "    {0}" +
3193                                 "    Name = 2,{0}" +
3194                                 "}}{0}", NewLine), code);
3195                 }
3196
3197                 [Test]
3198                 public override void PropertyMembersTypeTest1 ()
3199                 {
3200                         string code = GeneratePropertyMembersAttributes (Options);
3201                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3202                                 "public enum Test1 {{{0}" +
3203                                 "    {0}" +
3204                                 "}}{0}", NewLine), code);
3205                 }
3206
3207                 [Test]
3208                 public override void PropertyMembersTypeTest2 ()
3209                 {
3210                         string code = GeneratePropertyMembersType (MemberAttributes.Public,
3211                                 false, false, Options);
3212                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3213                                 "public enum Test1 {{{0}" +
3214                                 "    {0}" +
3215                                 "}}{0}", NewLine), code);
3216                 }
3217
3218                 [Test]
3219                 public override void PropertyMembersTypeGetOnly ()
3220                 {
3221                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
3222                                 true, false, Options);
3223                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3224                                 "public enum Test1 {{{0}" +
3225                                 "    {0}" +
3226                                 "}}{0}", NewLine), code);
3227                 }
3228
3229                 [Test]
3230                 public override void PropertyMembersTypeSetOnly ()
3231                 {
3232                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
3233                                 false, true, Options);
3234                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3235                                 "public enum Test1 {{{0}" +
3236                                 "    {0}" +
3237                                 "}}{0}", NewLine), code);
3238                 }
3239
3240                 [Test]
3241                 public override void PropertyMembersTypeGetSet ()
3242                 {
3243                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
3244                                 true, true, Options);
3245                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3246                                 "public enum Test1 {{{0}" +
3247                                 "    {0}" +
3248                                 "}}{0}", NewLine), code);
3249                 }
3250
3251                 [Test]
3252                 public void PropertyMembersTypeGetSet_C ()
3253                 {
3254                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
3255                         options.BracingStyle = "C";
3256
3257                         string code = GeneratePropertyMembersType (MemberAttributes.Family,
3258                                 true, true, options);
3259                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3260                                 "public enum Test1{0}" +
3261                                 "{{{0}" +
3262                                 "    {0}" +
3263                                 "}}{0}", NewLine), code);
3264                 }
3265
3266                 [Test]
3267                 public override void PropertyMembersTypeFamilyOrAssembly ()
3268                 {
3269                         string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
3270                                 false, false, Options);
3271                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3272                                 "public enum Test1 {{{0}" +
3273                                 "    {0}" +
3274                                 "}}{0}", NewLine), code);
3275                 }
3276
3277                 [Test]
3278                 public override void PropertyMembersTypeAssembly ()
3279                 {
3280                         string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
3281                                 false, false, Options);
3282                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3283                                 "public enum Test1 {{{0}" +
3284                                 "    {0}" +
3285                                 "}}{0}", NewLine), code);
3286                 }
3287
3288                 [Test]
3289                 public override void PropertyParametersTest ()
3290                 {
3291                         string code = GeneratePropertyParameters (Options);
3292                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3293                                 "public enum Test1 {{{0}" +
3294                                 "    {0}" +
3295                                 "}}{0}", NewLine), code);
3296                 }
3297
3298                 [Test]
3299                 public override void PropertyIndexerTest1 ()
3300                 {
3301                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
3302                                 false, false, true, Options);
3303                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3304                                 "public enum Test1 {{{0}" +
3305                                 "    {0}" +
3306                                 "}}{0}", NewLine), code);
3307                 }
3308
3309                 [Test]
3310                 public override void PropertyIndexerTest2 ()
3311                 {
3312                         string code = GeneratePropertyIndexer (MemberAttributes.Public,
3313                                 false, false, false, Options);
3314                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3315                                 "public enum Test1 {{{0}" +
3316                                 "    {0}" +
3317                                 "}}{0}", NewLine), code);
3318                 }
3319
3320                 [Test]
3321                 public override void PropertyIndexerGetOnly ()
3322                 {
3323                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
3324                                 true, false, true, Options);
3325                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3326                                 "public enum Test1 {{{0}" +
3327                                 "    {0}" +
3328                                 "}}{0}", NewLine), code);
3329                 }
3330
3331                 [Test]
3332                 public override void PropertyIndexerSetOnly ()
3333                 {
3334                         string code = GeneratePropertyIndexer (MemberAttributes.Family,
3335                                 false, true, true, Options);
3336                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3337                                 "public enum Test1 {{{0}" +
3338                                 "    {0}" +
3339                                 "}}{0}", NewLine), code);
3340                 }
3341
3342                 [Test]
3343                 public override void PropertyImplementationTypes ()
3344                 {
3345                         string code = GeneratePropertyImplementationTypes (Options);
3346                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3347                                 "public enum Test1 {{{0}" +
3348                                 "    {0}" +
3349                                 "}}{0}", NewLine), code);
3350                 }
3351
3352                 [Test]
3353                 public override void PropertyOverloadsTest1 ()
3354                 {
3355                         string code = GeneratePropertyOverloads1 (Options);
3356                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3357                                 "public enum Test1 {{{0}" +
3358                                 "    {0}" +
3359                                 "}}{0}", NewLine), code);
3360                 }
3361
3362                 [Test]
3363                 public override void PropertyOverloadsTest2 ()
3364                 {
3365                         string code = GeneratePropertyOverloads2 (Options);
3366                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3367                                 "public enum Test1 {{{0}" +
3368                                 "    {0}" +
3369                                 "    {0}" +
3370                                 "}}{0}", NewLine), code);
3371                 }
3372
3373                 [Test]
3374                 public override void PropertyOverloadsTest3 ()
3375                 {
3376                         string code = GeneratePropertyOverloads3 (Options);
3377                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3378                                 "public enum Test1 {{{0}" +
3379                                 "    {0}" +
3380                                 "    {0}" +
3381                                 "}}{0}", NewLine), code);
3382                 }
3383
3384                 [Test]
3385                 public override void PropertyPrivateImplementationType ()
3386                 {
3387                         string code = GeneratePropertyPrivateImplementationType (Options);
3388                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3389                                 "public enum Test1 {{{0}" +
3390                                 "    {0}" +
3391                                 "}}{0}", NewLine), code);
3392                 }
3393
3394                 [Test]
3395                 public override void PropertyImplementationTypeOrder ()
3396                 {
3397                         string code = GeneratePropertyImplementationTypeOrder (Options);
3398                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3399                                 "public enum Test1 {{{0}" +
3400                                 "    {0}" +
3401                                 "}}{0}", NewLine), code);
3402                 }
3403
3404                 [Test]
3405                 public override void PropertyNewSlotTest ()
3406                 {
3407                         string code = GeneratePropertyMembersType (MemberAttributes.Private |
3408                                 MemberAttributes.New, true, true, Options);
3409                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3410                                 "public enum Test1 {{{0}" +
3411                                 "    {0}" +
3412                                 "}}{0}", NewLine), code);
3413                 }
3414
3415                 [Test]
3416                 public override void MethodMembersTypeTest1 ()
3417                 {
3418                         string code = GenerateMethodMembersType1 (Options);
3419                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3420                                 "public enum Test1 {{{0}" +
3421                                 "    {0}" +
3422                                 "}}{0}", NewLine), code);
3423                 }
3424
3425                 [Test]
3426                 public override void MethodMembersTypeTest2 ()
3427                 {
3428                         string code = GenerateMethodMembersType2 (Options);
3429                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3430                                 "public enum Test1 {{{0}" +
3431                                 "    {0}" +
3432                                 "}}{0}", NewLine), code);
3433                 }
3434
3435                 [Test]
3436                 public override void MethodMembersTypeTest3 ()
3437                 {
3438                         string code = GenerateMethodMembersType3 (Options);
3439                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3440                                 "public enum Test1 {{{0}" +
3441                                 "    {0}" +
3442                                 "}}{0}", NewLine), code);
3443                 }
3444
3445                 [Test]
3446                 public override void MethodImplementationTypes ()
3447                 {
3448                         string code = GenerateMethodImplementationTypes (Options);
3449                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3450                                 "public enum Test1 {{{0}" +
3451                                 "    {0}" +
3452                                 "}}{0}", NewLine), code);
3453                 }
3454
3455                 [Test]
3456                 public override void MethodOverloadsTest1 ()
3457                 {
3458                         string code = GenerateMethodOverloads1 (Options);
3459                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3460                                 "public enum Test1 {{{0}" +
3461                                 "    {0}" +
3462                                 "}}{0}", NewLine), code);
3463                 }
3464
3465                 [Test]
3466                 public override void MethodOverloadsTest2 ()
3467                 {
3468                         string code = GenerateMethodOverloads2 (Options);
3469                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3470                                 "public enum Test1 {{{0}" +
3471                                 "    {0}" +
3472                                 "    {0}" +
3473                                 "}}{0}", NewLine), code);
3474                 }
3475
3476                 [Test]
3477                 public override void MethodOverloadsTest3 ()
3478                 {
3479                         string code = GenerateMethodOverloads3 (Options);
3480                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3481                                 "public enum Test1 {{{0}" +
3482                                 "    {0}" +
3483                                 "    {0}" +
3484                                 "}}{0}", NewLine), code);
3485                 }
3486
3487                 [Test]
3488                 public override void MethodPrivateImplementationType ()
3489                 {
3490                         string code = GenerateMethodPrivateImplementationType (Options);
3491                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3492                                 "public enum Test1 {{{0}" +
3493                                 "    {0}" +
3494                                 "}}{0}", NewLine), code);
3495                 }
3496
3497                 [Test]
3498                 public override void MethodImplementationTypeOrder ()
3499                 {
3500                         string code = GenerateMethodImplementationTypeOrder (Options);
3501                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3502                                 "public enum Test1 {{{0}" +
3503                                 "    {0}" +
3504                                 "}}{0}", NewLine), code);
3505                 }
3506
3507                 [Test]
3508                 public override void MethodNewSlotTest ()
3509                 {
3510                         string code = GenerateMethodNewSlot (Options);
3511                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3512                                 "public enum Test1 {{{0}" +
3513                                 "    {0}" +
3514                                 "}}{0}", NewLine), code);
3515                 }
3516
3517                 [Test]
3518                 public override void MethodReturnTypeAttributes ()
3519                 {
3520                         string code = GenerateMethodReturnTypeAttributes (Options);
3521                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3522                                 "public enum Test1 {{{0}" +
3523                                 "    {0}" +
3524                                 "}}{0}", NewLine), code);
3525                 }
3526
3527                 [Test]
3528                 public override void ConstructorAttributesTest ()
3529                 {
3530                         string code = GenerateConstructorAttributes (Options);
3531                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3532                                 "public enum Test1 {{{0}" +
3533                                 "    {0}" +
3534                                 "}}{0}", NewLine), code);
3535                 }
3536
3537                 [Test]
3538                 public void ConstructorAttributesTest_C ()
3539                 {
3540                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
3541                         options.BracingStyle = "C";
3542
3543                         string code = GenerateConstructorAttributes (options);
3544                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3545                                 "public enum Test1{0}" +
3546                                 "{{{0}" +
3547                                 "    {0}" +
3548                                 "}}{0}", NewLine), code);
3549                 }
3550
3551                 [Test]
3552                 public override void ConstructorParametersTest ()
3553                 {
3554                         string code = GenerateConstructorParameters (Options);
3555                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3556                                 "public enum Test1 {{{0}" +
3557                                 "    {0}" +
3558                                 "}}{0}", NewLine), code);
3559                 }
3560
3561                 [Test]
3562                 public override void ConstructorParameterAttributesTest ()
3563                 {
3564                         string code = GenerateConstructorParameterAttributes (Options);
3565                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3566                                 "public enum Test1 {{{0}" +
3567                                 "    {0}" +
3568                                 "}}{0}", NewLine), code);
3569                 }
3570
3571                 [Test]
3572                 public override void BaseConstructorSingleArg ()
3573                 {
3574                         string code = GenerateBaseConstructor (false, Options);
3575                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3576                                 "public enum Test1 {{{0}" +
3577                                 "    {0}" +
3578                                 "}}{0}", NewLine), code);
3579                 }
3580
3581                 [Test]
3582                 public override void BaseConstructorMultipleArgs ()
3583                 {
3584                         string code = GenerateBaseConstructor (true, Options);
3585                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3586                                 "public enum Test1 {{{0}" +
3587                                 "    {0}" +
3588                                 "}}{0}", NewLine), code);
3589                 }
3590
3591                 [Test]
3592                 public override void ChainedConstructorSingleArg ()
3593                 {
3594                         string code = GenerateChainedConstructor (false, Options);
3595                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3596                                 "public enum Test1 {{{0}" +
3597                                 "    {0}" +
3598                                 "}}{0}", NewLine), code);
3599                 }
3600
3601                 [Test]
3602                 public override void ChainedConstructorMultipleArgs ()
3603                 {
3604                         string code = GenerateChainedConstructor (true, Options);
3605                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3606                                 "public enum Test1 {{{0}" +
3607                                 "    {0}" +
3608                                 "}}{0}", NewLine), code);
3609                 }
3610
3611                 [Test]
3612                 public override void TypeConstructorTest ()
3613                 {
3614                         string code = GenerateTypeConstructor (Options);
3615                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3616                                 "public enum Test1 {{{0}" +
3617                                 "    {0}" +
3618                                 "}}{0}", NewLine), code);
3619                 }
3620
3621                 [Test]
3622                 public void TypeConstructorTest_C ()
3623                 {
3624                         CodeGeneratorOptions options = new CodeGeneratorOptions ();
3625                         options.BracingStyle = "C";
3626
3627                         string code = GenerateTypeConstructor (options);
3628                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3629                                 "public enum Test1{0}" +
3630                                 "{{{0}" +
3631                                 "    {0}" +
3632                                 "}}{0}", NewLine), code);
3633                 }
3634
3635                 [Test]
3636                 public override void EntryPointMethodTest ()
3637                 {
3638                         string code = GenerateEntryPointMethod (Options);
3639                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3640                                 "public enum Test1 {{{0}" +
3641                                 "    {0}" +
3642 #if NET_2_0
3643                                 "    [A()]{0}" +
3644                                 "    public static int Main() {{{0}" +
3645 #else
3646                                 "    public static void Main() {{{0}" +
3647 #endif
3648                                 "        Test.InnerType x;{0}" +
3649                                 "    }}{0}" +
3650                                 "}}{0}", NewLine), code);
3651                 }
3652
3653                 #endregion Override implementation of CodeGeneratorFromTypeTestBase
3654         }
3655 }