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

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