mcs/class/corlib/Test/System.Reflection.Emit/TypeBuilderTest.cs

   1
   2 //
   3 // TypeBuilderTest.cs - NUnit Test Cases for the TypeBuilder class
   4 //
   5 // Zoltan Varga (vargaz@freemail.hu)
   6 //
   7 // (C) Ximian, Inc.  http://www.ximian.com
   8 //
   9 // TODO:
  10 //  - implement a mechnanism for easier testing of null argument exceptions
  11 //  - with overloaded methods like DefineNestedType (), check the defaults
  12 //    on the shorter versions.
  13 //  - ToString on enums with the flags attribute set should print all
  14 //    values which match, e.g. 0 == AutoLayou,AnsiClass,NotPublic
  15 //
  16
  17 using System;
  18 using System.Threading;
  19 using System.Reflection;
  20 using System.Reflection.Emit;
  21 using System.Security;
  22 using System.Security.Permissions;
  23 using System.Runtime.InteropServices;
  24 using NUnit.Framework;
  25
  26 namespace MonoTests.System.Reflection.Emit
  27 {
  28
  29 [TestFixture]
  30 public class TypeBuilderTest : Assertion
  31 {
  32         private interface AnInterface {
  33         }
  34
  35         private AssemblyBuilder assembly;
  36
  37         private ModuleBuilder module;
  38
  39         static string ASSEMBLY_NAME = "MonoTests.System.Reflection.Emit.TypeBuilderTest";
  40
  41         [SetUp]
  42         protected void SetUp () {
  43                 AssemblyName assemblyName = new AssemblyName();
  44                 assemblyName.Name = ASSEMBLY_NAME;
  45
  46                 assembly =
  47                         Thread.GetDomain().DefineDynamicAssembly(
  48                                 assemblyName, AssemblyBuilderAccess.RunAndSave, "c:\\");
  49
  50                 module = assembly.DefineDynamicModule("module1");
  51         }
  52
  53         static int typeIndexer = 0;
  54
  55         // Return a unique type name
  56         private string genTypeName () {
  57                 return "t" + (typeIndexer ++);
  58         }
  59
  60         private string nullName () {
  61                 return String.Format ("{0}", (char)0);
  62         }
  63
  64         [Test]
  65         public void TestAssembly () {
  66                 TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
  67                 AssertEquals ("Assembly works",
  68                                           tb.Assembly, assembly);
  69         }
  70
  71         [Test]
  72         public void TestAssemblyQualifiedName () {
  73                 TypeBuilder tb = module.DefineType ("A.B.C.D", TypeAttributes.Public);
  74
  75                 AssertEquals ("AssemblyQualifiedName works",
  76                                           tb.AssemblyQualifiedName, "A.B.C.D, " + assembly.GetName ().FullName);
  77         }
  78
  79         [Test]
  80         public void TestAttributes () {
  81                 TypeAttributes attrs = TypeAttributes.Public | TypeAttributes.BeforeFieldInit;
  82                 TypeBuilder tb = module.DefineType (genTypeName (), attrs);
  83
  84                 AssertEquals ("Attributes works",
  85                                           tb.Attributes, attrs);
  86         }
  87
  88         [Test]
  89         public void TestBaseTypeClass () {
  90                 TypeAttributes attrs = TypeAttributes.Public;
  91                 TypeBuilder tb = module.DefineType (genTypeName (), attrs);
  92                 AssertEquals ("BaseType defaults to Object",
  93                                           tb.BaseType, typeof (object));
  94
  95                 TypeBuilder tb2 = module.DefineType (genTypeName (), attrs, tb);
  96                 AssertEquals ("BaseType works",
  97                                           tb2.BaseType, tb);
  98         }
  99
 100         [Test]
 101         public void TestBaseTypeInterface ()
 102         {
 103                 TypeBuilder tb3 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
 104                 AssertEquals ("Interfaces should default to no base type", null, tb3.BaseType);
 105         }
 106
 107         [Test]
 108         public void TestDeclaringType () {
 109                 TypeAttributes attrs = 0;
 110                 TypeBuilder tb = module.DefineType (genTypeName (), attrs);
 111
 112                 AssertEquals ("Has no declaring type",
 113                                           null, tb.DeclaringType);
 114
 115                 attrs = TypeAttributes.NestedPublic;
 116                 TypeBuilder tb2 = tb.DefineNestedType (genTypeName (), attrs);
 117                 TypeBuilder tb3 = tb2.DefineNestedType (genTypeName (), attrs);
 118                 AssertEquals ("DeclaringType works",
 119                                           tb, tb3.DeclaringType.DeclaringType);
 120         }
 121
 122         [Test]
 123         public void TestFullName () {
 124                 string name = genTypeName ();
 125                 TypeAttributes attrs = 0;
 126                 TypeBuilder tb = module.DefineType (name, attrs);
 127                 AssertEquals ("FullName works",
 128                                           name, tb.FullName);
 129
 130                 string name2 = genTypeName ();
 131                 attrs = TypeAttributes.NestedPublic;
 132                 TypeBuilder tb2 = tb.DefineNestedType (name2, attrs);
 133
 134                 string name3 = genTypeName ();
 135                 attrs = TypeAttributes.NestedPublic;
 136                 TypeBuilder tb3 = tb2.DefineNestedType (name3, attrs);
 137
 138                 AssertEquals ("FullName works on nested types",
 139                                           name + "+" + name2 + "+" + name3, tb3.FullName);
 140         }
 141
 142         [Test]
 143         [ExpectedException (typeof(NotSupportedException))]
 144         public void TestGUIDIncomplete () {
 145                 TypeBuilder tb = module.DefineType (genTypeName ());
 146                 Guid g = tb.GUID;
 147         }
 148
 149         [Test]
 150         public void TestGUIDComplete ()
 151         {
 152                 TypeBuilder tb = module.DefineType (genTypeName ());
 153                 tb.CreateType ();
 154                 Assert(tb.GUID != Guid.Empty);
 155         }
 156
 157         [Test]
 158         public void TestFixedGUIDComplete ()
 159         {
 160                 TypeBuilder tb = module.DefineType (genTypeName ());
 161
 162                 Guid guid = Guid.NewGuid ();
 163
 164                 ConstructorInfo guidCtor = typeof(GuidAttribute).GetConstructor(
 165                         new Type[] {typeof(string)});
 166
 167                 CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (guidCtor,
 168                         new object[] { guid.ToString("D") }, new FieldInfo[0], new object[0]);
 169
 170                 tb.SetCustomAttribute (caBuilder);
 171                 tb.CreateType ();
 172                 AssertEquals (guid, tb.GUID);
 173         }
 174
 175         [Test]
 176         [ExpectedException (typeof(NotSupportedException))]
 177         public void TestHasElementType () {
 178                 // According to the MSDN docs, this member works, but in reality, it
 179                 // returns a NotSupportedException
 180                 TypeBuilder tb = module.DefineType (genTypeName ());
 181                 bool b = tb.HasElementType;
 182         }
 183
 184         [Test]
 185         public void TestIsAbstract () {
 186                 TypeBuilder tb = module.DefineType (genTypeName ());
 187                 AssertEquals ("",
 188                                           false, tb.IsAbstract);
 189
 190                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Abstract);
 191                 AssertEquals ("",
 192                                           true, tb2.IsAbstract);
 193         }
 194
 195         [Test]
 196         public void TestIsAnsiClass () {
 197                 TypeBuilder tb = module.DefineType (genTypeName ());
 198                 AssertEquals ("",
 199                                           true, tb.IsAnsiClass);
 200
 201                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.UnicodeClass);
 202                 AssertEquals ("",
 203                                           false, tb2.IsAnsiClass);
 204         }
 205
 206         [Test]
 207         public void TestIsArray () {
 208                 // How can a TypeBuilder be an array ?
 209                 string name = genTypeName ();
 210                 TypeBuilder tb = module.DefineType (name);
 211                 AssertEquals ("IsArray works",
 212                                           false, tb.IsArray);
 213         }
 214
 215         [Test]
 216         public void TestIsAutoClass () {
 217                 TypeBuilder tb = module.DefineType (genTypeName ());
 218                 AssertEquals ("",
 219                                           false, tb.IsAutoClass);
 220
 221                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.AutoClass);
 222                 AssertEquals ("",
 223                                           true, tb2.IsAutoClass);
 224         }
 225
 226         [Test]
 227         public void TestIsAutoLayout () {
 228                 TypeBuilder tb = module.DefineType (genTypeName ());
 229                 AssertEquals ("AutoLayout defaults to true",
 230                                           true, tb.IsAutoLayout);
 231
 232                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.ExplicitLayout);
 233                 AssertEquals ("",
 234                                           false, tb2.IsAutoLayout);
 235         }
 236
 237         [Test]
 238         public void TestIsByRef () {
 239                 // How can a TypeBuilder be ByRef ?
 240                 TypeBuilder tb = module.DefineType (genTypeName ());
 241                 AssertEquals ("IsByRef works",
 242                                           false, tb.IsByRef);
 243         }
 244
 245         [Test]
 246         public void TestIsClass () {
 247                 TypeBuilder tb = module.DefineType (genTypeName ());
 248                 AssertEquals ("Most types are classes",
 249                                           true, tb.IsClass);
 250
 251                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
 252                 AssertEquals ("Interfaces are not classes",
 253                                           false, tb2.IsClass);
 254
 255                 TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (ValueType));
 256                 AssertEquals ("value types are not classes",
 257                                           false, tb3.IsClass);
 258
 259                 TypeBuilder tb4 = module.DefineType (genTypeName (), 0, typeof (Enum));
 260                 AssertEquals ("enums are not classes",
 261                                           false, tb4.IsClass);
 262         }
 263
 264         [Test]
 265         public void TestIsCOMObject () {
 266                 TypeBuilder tb = module.DefineType (genTypeName ());
 267                 AssertEquals ("Probably not", false, tb.IsCOMObject);
 268
 269                 tb = module.DefineType (genTypeName (), TypeAttributes.Import);
 270                 AssertEquals ("type with Import attribute is COM object",
 271                         true, tb.IsCOMObject);
 272         }
 273
 274         [Test]
 275         public void TestIsContextful () {
 276                 TypeBuilder tb = module.DefineType (genTypeName ());
 277                 AssertEquals (false, tb.IsContextful);
 278
 279                 TypeBuilder tb2 = module.DefineType (genTypeName (), 0, typeof (ContextBoundObject));
 280                 AssertEquals (true, tb2.IsContextful);
 281         }
 282
 283         [Test]
 284         public void TestIsEnum () {
 285                 TypeBuilder tb = module.DefineType (genTypeName ());
 286                 AssertEquals (false, tb.IsEnum);
 287
 288                 // This returns true under both mono and MS .NET ???
 289                 TypeBuilder tb2 = module.DefineType (genTypeName (), 0, typeof (ValueType));
 290                 AssertEquals ("value types are not necessary enums",
 291                         false, tb2.IsEnum);
 292
 293                 TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (Enum));
 294                 AssertEquals ("enums are enums", true, tb3.IsEnum);
 295         }
 296
 297         [Test]
 298         public void TestIsExplicitLayout () {
 299                 TypeBuilder tb = module.DefineType (genTypeName ());
 300                 AssertEquals ("ExplicitLayout defaults to false",
 301                         false, tb.IsExplicitLayout);
 302
 303                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.ExplicitLayout);
 304                 AssertEquals (true, tb2.IsExplicitLayout);
 305         }
 306
 307         [Test]
 308         public void TestIsImport () {
 309                 // How can this be true ?
 310                 TypeBuilder tb = module.DefineType (genTypeName ());
 311                 AssertEquals (false, tb.IsImport);
 312         }
 313
 314         [Test]
 315         public void TestIsInterface () {
 316                 TypeBuilder tb = module.DefineType (genTypeName ());
 317                 AssertEquals ("Most types are not interfaces",
 318                         false, tb.IsInterface);
 319
 320                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
 321                 AssertEquals ("Interfaces are interfaces",
 322                         true, tb2.IsInterface);
 323
 324                 TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (ValueType));
 325                 AssertEquals ("value types are not interfaces",
 326                         false, tb3.IsInterface);
 327         }
 328
 329         [Test]
 330         public void TestIsLayoutSequential () {
 331                 TypeBuilder tb = module.DefineType (genTypeName ());
 332                 AssertEquals ("SequentialLayout defaults to false",
 333                         false, tb.IsLayoutSequential);
 334
 335                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.SequentialLayout);
 336                 AssertEquals (true, tb2.IsLayoutSequential);
 337         }
 338
 339         [Test]
 340         public void TestIsMarshalByRef () {
 341                 TypeBuilder tb = module.DefineType (genTypeName ());
 342                 AssertEquals (false, tb.IsMarshalByRef);
 343
 344                 TypeBuilder tb2 = module.DefineType (genTypeName (), 0, typeof (MarshalByRefObject));
 345                 AssertEquals (true, tb2.IsMarshalByRef);
 346
 347                 TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (ContextBoundObject));
 348                 AssertEquals (true, tb3.IsMarshalByRef);
 349         }
 350
 351         // TODO: Visibility properties
 352
 353         [Test]
 354         public void TestIsPointer () {
 355                 // How can this be true?
 356                 TypeBuilder tb = module.DefineType (genTypeName ());
 357                 AssertEquals (false, tb.IsPointer);
 358         }
 359
 360         [Test]
 361         public void TestIsPrimitive () {
 362                 TypeBuilder tb = module.DefineType ("int");
 363                 AssertEquals (false, tb.IsPrimitive);
 364         }
 365
 366         [Test]
 367         public void IsSealed () {
 368                 TypeBuilder tb = module.DefineType (genTypeName ());
 369                 AssertEquals ("Sealed defaults to false",
 370                         false, tb.IsSealed);
 371
 372                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Sealed);
 373                 AssertEquals ("IsSealed works", true, tb2.IsSealed);
 374         }
 375
 376         [Test]
 377         public void IsSerializable () {
 378                 TypeBuilder tb = module.DefineType (genTypeName ());
 379                 AssertEquals (false, tb.IsSerializable);
 380
 381                 ConstructorInfo[] ctors = typeof (SerializableAttribute).GetConstructors (BindingFlags.Instance | BindingFlags.Public);
 382                 Assert ("SerializableAttribute should have more than 0 public instance ctors",
 383                         ctors.Length > 0);
 384
 385                 tb.SetCustomAttribute (new CustomAttributeBuilder (ctors[0], new object[0]));
 386                 Type createdType = tb.CreateType ();
 387
 388                 assembly.Save ("TestAssembly.dll");
 389                 AssertEquals (true, createdType.IsSerializable);
 390         }
 391
 392         [Test]
 393         public void TestIsSpecialName () {
 394                 TypeBuilder tb = module.DefineType (genTypeName ());
 395                 AssertEquals ("SpecialName defaults to false",
 396                         false, tb.IsSpecialName);
 397
 398                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.SpecialName);
 399                 AssertEquals ("IsSpecialName works",
 400                         true, tb2.IsSpecialName);
 401         }
 402
 403         [Test]
 404         public void TestIsUnicodeClass () {
 405                 TypeBuilder tb = module.DefineType (genTypeName ());
 406                 AssertEquals (false, tb.IsUnicodeClass);
 407
 408                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.UnicodeClass);
 409                 AssertEquals (true, tb2.IsUnicodeClass);
 410         }
 411
 412         [Test]
 413         public void TestIsValueType () {
 414                 TypeBuilder tb = module.DefineType (genTypeName ());
 415                 AssertEquals ("Most types are not value types",
 416                         false, tb.IsValueType);
 417
 418                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
 419                 AssertEquals ("Interfaces are not value types",
 420                         false, tb2.IsValueType);
 421
 422                 TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (ValueType));
 423                 AssertEquals ("value types are value types",
 424                         true, tb3.IsValueType);
 425
 426                 TypeBuilder tb4 = module.DefineType (genTypeName (), 0, typeof (Enum));
 427                 AssertEquals ("enums are value types",
 428                         true, tb4.IsValueType);
 429         }
 430
 431         [Test]
 432         public void TestMemberType () {
 433                 TypeBuilder tb = module.DefineType (genTypeName ());
 434                 AssertEquals ("A type is a type",
 435                         MemberTypes.TypeInfo, tb.MemberType);
 436         }
 437
 438         [Test]
 439         public void TestModule () {
 440                 TypeBuilder tb = module.DefineType (genTypeName ());
 441                 AssertEquals ("Module works", module, tb.Module);
 442         }
 443
 444         [Test]
 445         public void TestName () {
 446                 TypeBuilder tb = module.DefineType ("A");
 447                 AssertEquals ("A", tb.Name);
 448
 449                 TypeBuilder tb2 = module.DefineType ("A.B.C.D.E");
 450                 AssertEquals ("E", tb2.Name);
 451
 452                 TypeBuilder tb3 = tb2.DefineNestedType ("A");
 453                 AssertEquals ("A", tb3.Name);
 454
 455                 /* Is .E a valid name ?
 456                 TypeBuilder tb4 = module.DefineType (".E");
 457                 AssertEquals ("",
 458                                           "E", tb4.Name);
 459                 */
 460         }
 461
 462         [Test]
 463         public void TestNamespace () {
 464                 TypeBuilder tb = module.DefineType ("A");
 465                 AssertEquals ("", tb.Namespace);
 466
 467                 TypeBuilder tb2 = module.DefineType ("A.B.C.D.E");
 468                 AssertEquals ("A.B.C.D", tb2.Namespace);
 469
 470                 TypeBuilder tb3 = tb2.DefineNestedType ("A");
 471                 AssertEquals ("", tb3.Namespace);
 472
 473                 /* Is .E a valid name ?
 474                 TypeBuilder tb4 = module.DefineType (".E");
 475                 AssertEquals ("",
 476                                           "E", tb4.Name);
 477                 */
 478         }
 479
 480         [Test]
 481         public void TestPackingSize () {
 482                 TypeBuilder tb = module.DefineType (genTypeName ());
 483                 AssertEquals (PackingSize.Unspecified, tb.PackingSize);
 484
 485                 TypeBuilder tb2 = module.DefineType (genTypeName (), 0, typeof (object),
 486                         PackingSize.Size16, 16);
 487                 AssertEquals (PackingSize.Size16, tb2.PackingSize);
 488         }
 489
 490         [Test]
 491         public void TestReflectedType () {
 492                 // It is the same as DeclaringType, but why?
 493                 TypeBuilder tb = module.DefineType (genTypeName ());
 494                 AssertEquals (null, tb.ReflectedType);
 495
 496                 TypeBuilder tb2 = tb.DefineNestedType (genTypeName ());
 497                 AssertEquals (tb, tb2.ReflectedType);
 498         }
 499
 500         [Test]
 501         [ExpectedException (typeof(ArgumentNullException))]
 502         public void TestSetParentNull ()
 503         {
 504                 TypeBuilder tb = module.DefineType (genTypeName ());
 505                 tb.SetParent (null);
 506         }
 507
 508         [Test]
 509         public void TestSetParentIncomplete ()
 510         {
 511                 TypeBuilder tb = module.DefineType (genTypeName ());
 512                 tb.SetParent (typeof(Attribute));
 513                 AssertEquals (typeof(Attribute), tb.BaseType);
 514         }
 515
 516         [Test]
 517         [ExpectedException (typeof(InvalidOperationException))]
 518         public void TestSetParentComplete ()
 519         {
 520                 TypeBuilder tb = module.DefineType (genTypeName ());
 521                 tb.CreateType ();
 522                 tb.SetParent (typeof(Attribute));
 523         }
 524
 525         [Test]
 526         public void TestSize () {
 527                 {
 528                         TypeBuilder tb = module.DefineType (genTypeName ());
 529                         AssertEquals (0, tb.Size);
 530                         tb.CreateType ();
 531                         AssertEquals (0, tb.Size);
 532                 }
 533
 534                 {
 535                         TypeBuilder tb = module.DefineType (genTypeName (), 0, typeof (object),
 536                                 PackingSize.Size16, 32);
 537                         AssertEquals (32, tb.Size);
 538                 }
 539         }
 540
 541         [Test]
 542         [ExpectedException (typeof(NotSupportedException))]
 543         public void TestTypeHandle () {
 544                 TypeBuilder tb = module.DefineType (genTypeName ());
 545                 RuntimeTypeHandle handle = tb.TypeHandle;
 546         }
 547
 548         [Test]
 549         [ExpectedException (typeof(NotSupportedException))]
 550         public void TestTypeInitializerIncomplete ()
 551         {
 552                 TypeBuilder tb = module.DefineType (genTypeName ());
 553                 ConstructorInfo cb = tb.TypeInitializer;
 554         }
 555
 556         [Test]
 557         public void TestTypeInitializerComplete ()
 558         {
 559                 TypeBuilder tb = module.DefineType (genTypeName ());
 560                 tb.CreateType ();
 561                 ConstructorInfo cb = tb.TypeInitializer;
 562         }
 563
 564         [Test]
 565         public void TestTypeToken () {
 566                 TypeBuilder tb = module.DefineType (genTypeName ());
 567                 TypeToken token = tb.TypeToken;
 568         }
 569
 570         [Test]
 571         public void TestUnderlyingSystemType () {
 572                 {
 573                         TypeBuilder tb = module.DefineType (genTypeName ());
 574                         AssertEquals ("For non-enums this equals itself",
 575                                                   tb, tb.UnderlyingSystemType);
 576                 }
 577                 {
 578                         TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
 579                         AssertEquals (tb, tb.UnderlyingSystemType);
 580                 }
 581                 {
 582                         TypeBuilder tb = module.DefineType (genTypeName (), 0, typeof (ValueType));
 583                         AssertEquals (tb, tb.UnderlyingSystemType);
 584                 }
 585
 586                 {
 587                         TypeBuilder tb = module.DefineType (genTypeName (), 0, typeof (Enum));
 588                         try {
 589                                 Type t = tb.UnderlyingSystemType;
 590                                 Fail ();
 591                         }
 592                         catch (InvalidOperationException) {
 593                         }
 594
 595                         tb.DefineField ("val", typeof (int), 0);
 596                         AssertEquals (typeof (int), tb.UnderlyingSystemType);
 597                 }
 598         }
 599
 600         [Test]
 601         public void TestAddInterfaceImplementation () {
 602                 TypeBuilder tb = module.DefineType (genTypeName ());
 603                 try {
 604                         tb.AddInterfaceImplementation (null);
 605                         Fail ();
 606                 }
 607                 catch (ArgumentNullException) {
 608                 }
 609
 610                 tb.AddInterfaceImplementation (typeof (AnInterface));
 611                 tb.AddInterfaceImplementation (typeof (AnInterface));
 612
 613                 Type t = tb.CreateType ();
 614                 AssertEquals ("Should merge identical interfaces",
 615                                           tb.GetInterfaces ().Length, 1);
 616
 617                 // Can not be called on a created type
 618                 try {
 619                         tb.AddInterfaceImplementation (typeof (AnInterface));
 620                         Fail ();
 621                 }
 622                 catch (InvalidOperationException) {
 623                 }
 624         }
 625
 626         [Test]
 627         public void TestCreateType () {
 628                 // TODO: LOTS OF TEST SHOULD GO THERE
 629                 TypeBuilder tb = module.DefineType (genTypeName ());
 630                 tb.CreateType ();
 631
 632                 // Can not be called on a created type
 633                 try {
 634                         tb.CreateType ();
 635                         Fail ();
 636                 }
 637                 catch (InvalidOperationException) {
 638                 }
 639         }
 640
 641         [Test]
 642         public void TestDefineConstructor () {
 643                 TypeBuilder tb = module.DefineType (genTypeName ());
 644
 645                 ConstructorBuilder cb = tb.DefineConstructor (0, 0, null);
 646                 cb.GetILGenerator ().Emit (OpCodes.Ret);
 647                 tb.CreateType ();
 648
 649                 // Can not be called on a created type
 650                 try {
 651                         tb.DefineConstructor (0, 0, null);
 652                         Fail ();
 653                 }
 654                 catch (InvalidOperationException) {
 655                 }
 656         }
 657
 658         [Test]
 659         public void TestDefineDefaultConstructor () {
 660                 TypeBuilder tb = module.DefineType (genTypeName ());
 661                 tb.DefineDefaultConstructor (0);
 662                 tb.CreateType ();
 663
 664                 // Can not be called on a created type, altough the MSDN docs does not mention this
 665                 try {
 666                         tb.DefineDefaultConstructor (0);
 667                         Fail ();
 668                 }
 669                 catch (InvalidOperationException) {
 670                 }
 671         }
 672
 673         [Test]
 674         [ExpectedException (typeof(NotSupportedException))]
 675         public void TestDefineDefaultConstructorParent () {
 676                 TypeBuilder tb = module.DefineType (genTypeName ());
 677                 tb.DefineConstructor (MethodAttributes.Public,
 678                         CallingConventions.Standard,
 679                         new Type[] { typeof(string) });
 680                 Type type = tb.CreateType ();
 681
 682                 // create TypeBuilder for type that derived from the
 683                 // previously created type (which has no default ctor)
 684                 tb = module.DefineType (genTypeName (), TypeAttributes.Class
 685                         | TypeAttributes.Public, type);
 686
 687                 // you cannot create a type with a default ctor that
 688                 // derives from a type without a default ctor
 689                 tb.CreateType ();
 690         }
 691
 692         [Test]
 693         public void TestDefineEvent () {
 694                 TypeBuilder tb = module.DefineType (genTypeName ());
 695
 696                 // Test invalid arguments
 697                 try {
 698                         tb.DefineEvent (null, 0, typeof (int));
 699                         Fail ();
 700                 }
 701                 catch (ArgumentNullException) {
 702                 }
 703
 704                 try {
 705                         tb.DefineEvent ("FOO", 0, null);
 706                         Fail ();
 707                 }
 708                 catch (ArgumentNullException) {
 709                 }
 710
 711                 try {
 712                         tb.DefineEvent ("", 0, typeof (int));
 713                         Fail ();
 714                 }
 715                 catch (ArgumentException) {
 716                 }
 717
 718                 tb.CreateType ();
 719                 // Can not be called on a created type
 720                 try {
 721                         tb.DefineEvent ("BAR", 0, typeof (int));
 722                         Fail ();
 723                 }
 724                 catch (InvalidOperationException) {
 725                 }
 726         }
 727
 728         [Test]
 729         public void TestDefineField () {
 730                 TypeBuilder tb = module.DefineType (genTypeName ());
 731
 732                 // Check invalid arguments
 733                 try {
 734                         tb.DefineField (null, typeof (int), 0);
 735                         Fail ();
 736                 }
 737                 catch (ArgumentNullException) {
 738                 }
 739
 740                 try {
 741                         tb.DefineField ("", typeof (int), 0);
 742                         Fail ();
 743                 }
 744                 catch (ArgumentException) {
 745                 }
 746
 747                 try {
 748                         // Strangely, 'A<NULL>' is accepted...
 749                         string name = String.Format ("{0}", (char)0);
 750                         tb.DefineField (name, typeof (int), 0);
 751                         Fail ("Names with embedded nulls should be rejected");
 752                 }
 753                 catch (ArgumentException) {
 754                 }
 755
 756                 try {
 757                         tb.DefineField ("A", typeof (void), 0);
 758                         Fail ();
 759                 }
 760                 catch (ArgumentException) {
 761                 }
 762
 763                 tb.CreateType ();
 764                 // Can not be called on a created type
 765                 try {
 766                         tb.DefineField ("B", typeof (int), 0);
 767                         Fail ();
 768                 }
 769                 catch (InvalidOperationException) {
 770                 }
 771         }
 772
 773         [Test]
 774         public void TestDefineInitializedData () {
 775                 TypeBuilder tb = module.DefineType (genTypeName ());
 776
 777                 // Check invalid arguments
 778                 try {
 779                         tb.DefineInitializedData (null, new byte[1], 0);
 780                         Fail ();
 781                 }
 782                 catch (ArgumentNullException) {
 783                 }
 784
 785                 try {
 786                         tb.DefineInitializedData ("FOO", null, 0);
 787                         Fail ();
 788                 }
 789                 catch (ArgumentNullException) {
 790                 }
 791
 792                 try {
 793                         tb.DefineInitializedData ("", new byte[1], 0);
 794                         Fail ();
 795                 }
 796                 catch (ArgumentException) {
 797                 }
 798
 799                 // The size of the data is less than or equal to zero ???
 800                 try {
 801                         tb.DefineInitializedData ("BAR", new byte[0], 0);
 802                         Fail ();
 803                 }
 804                 catch (ArgumentException) {
 805                 }
 806
 807                 try {
 808                         string name = String.Format ("{0}", (char)0);
 809                         tb.DefineInitializedData (name, new byte[1], 0);
 810                         Fail ("Names with embedded nulls should be rejected");
 811                 }
 812                 catch (ArgumentException) {
 813                 }
 814
 815                 tb.CreateType ();
 816
 817                 // Can not be called on a created type, altough the MSDN docs does not mention this
 818                 try {
 819                         tb.DefineInitializedData ("BAR2", new byte[1], 0);
 820                         Fail ();
 821                 }
 822                 catch (InvalidOperationException) {
 823                 }
 824         }
 825
 826         [Test]
 827         public void DefineUninitializedDataInvalidArgs () {
 828                 TypeBuilder tb = module.DefineType (genTypeName ());
 829
 830                 try {
 831                         tb.DefineUninitializedData (null, 1, 0);
 832                         Fail ();
 833                 }
 834                 catch (ArgumentNullException) {
 835                 }
 836
 837                 try {
 838                         tb.DefineUninitializedData ("", 1, 0);
 839                         Fail ();
 840                 }
 841                 catch (ArgumentException) {
 842                 }
 843
 844                 // The size of the data is less than or equal to zero ???
 845                 try {
 846                         tb.DefineUninitializedData ("BAR", 0, 0);
 847                         Fail ();
 848                 }
 849                 catch (ArgumentException) {
 850                 }
 851
 852                 try {
 853                         string name = String.Format ("{0}", (char)0);
 854                         tb.DefineUninitializedData (name, 1, 0);
 855                         Fail ("Names with embedded nulls should be rejected");
 856                 }
 857                 catch (ArgumentException) {
 858                 }
 859         }
 860
 861         [Test]
 862         [ExpectedException (typeof (InvalidOperationException))]
 863         public void DefineUninitializedDataAlreadyCreated () {
 864                 TypeBuilder tb = module.DefineType (genTypeName ());
 865                 tb.CreateType ();
 866
 867                 tb.DefineUninitializedData ("BAR2", 1, 0);
 868         }
 869
 870         [Test]
 871         public void DefineUninitializedData () {
 872                 TypeBuilder tb = module.DefineType (genTypeName ());
 873
 874                 tb.DefineUninitializedData ("foo", 4, FieldAttributes.Public);
 875
 876                 Type t = tb.CreateType ();
 877
 878                 object o = Activator.CreateInstance (t);
 879
 880                 FieldInfo fi = t.GetField ("foo");
 881
 882                 object fieldVal = fi.GetValue (o);
 883
 884                 IntPtr ptr = Marshal.AllocHGlobal (4);
 885                 Marshal.StructureToPtr (fieldVal, ptr, true);
 886                 Marshal.FreeHGlobal (ptr);
 887         }
 888
 889         [Test]
 890         public void TestDefineMethod () {
 891                 TypeBuilder tb = module.DefineType (genTypeName ());
 892
 893                 // Check invalid arguments
 894                 try {
 895                         tb.DefineMethod (null, 0, null, null);
 896                         Fail ();
 897                 }
 898                 catch (ArgumentNullException) {
 899                 }
 900
 901                 try {
 902                         tb.DefineMethod ("", 0, null, null);
 903                         Fail ();
 904                 }
 905                 catch (ArgumentException) {
 906                 }
 907
 908                 // Check non-virtual methods on an interface
 909                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
 910                 try {
 911                         tb2.DefineMethod ("FOO", MethodAttributes.Abstract, null, null);
 912                         Fail ();
 913                 }
 914                 catch (ArgumentException) {
 915                 }
 916
 917                 tb.CreateType ();
 918                 // Can not be called on a created type
 919                 try {
 920                         tb.DefineMethod ("bar", 0, null, null);
 921                         Fail ();
 922                 }
 923                 catch (InvalidOperationException) {
 924                 }
 925         }
 926
 927         // TODO: DefineMethodOverride
 928
 929         [Test]
 930         public void TestDefineNestedType () {
 931                 TypeBuilder tb = module.DefineType (genTypeName ());
 932
 933                 // Check invalid arguments
 934                 try {
 935                         tb.DefineNestedType (null);
 936                         Fail ("Should reject null name");
 937                 }
 938                 catch (ArgumentNullException) {
 939                 }
 940
 941                 try {
 942                         tb.DefineNestedType ("");
 943                         Fail ("Should reject empty name");
 944                 }
 945                 catch (ArgumentException) {
 946                 }
 947
 948                 try {
 949                         tb.DefineNestedType (nullName ());
 950                         Fail ("Should reject name with embedded 0s");
 951                 }
 952                 catch (ArgumentException) {
 953                 }
 954
 955                 // If I fix the code so this works then mcs breaks -> how can mcs
 956                 // works under MS .NET in the first place ???
 957                 /*
 958                 try {
 959                         tb.DefineNestedType ("AA", TypeAttributes.Public, null, null);
 960                         Fail ("Nested visibility must be specified.");
 961                 }
 962                 catch (ArgumentException) {
 963                 }
 964                 */
 965
 966                 try {
 967                         tb.DefineNestedType ("BB", TypeAttributes.NestedPublic, null,
 968                                                                  new Type[1]);
 969                         Fail ("Should reject empty interface");
 970                 }
 971                 catch (ArgumentException) {
 972                 }
 973
 974                 // I think this should reject non-interfaces, but it does not
 975                 tb.DefineNestedType ("BB", TypeAttributes.NestedPublic, null,
 976                                                          new Type[1] { typeof (object) });
 977
 978                 // Normal invocation
 979                 tb.DefineNestedType ("Nest");
 980
 981                 tb.CreateType ();
 982
 983                 // According to the MSDN docs, this cannnot be called after the type
 984                 // is created, but it works.
 985                 tb.DefineNestedType ("Nest2");
 986
 987                 // According to the MSDN docs, a Sealed class can't contain nested
 988                 // types, but this is not true
 989                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Sealed);
 990                 tb2.DefineNestedType ("AA");
 991
 992                 // According to the MSDN docs, interfaces can only contain interfaces,
 993                 // but this is not true
 994                 TypeBuilder tb3 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
 995
 996                 tb3.DefineNestedType ("AA");
 997
 998                 // Check shorter versions
 999                 {
1000                         TypeBuilder nested = tb.DefineNestedType ("N1");
1001
1002                         AssertEquals (nested.Name, "N1");
1003                         AssertEquals (nested.BaseType, typeof (object));
1004                         AssertEquals (nested.Attributes, TypeAttributes.NestedPrivate);
1005                         AssertEquals (nested.GetInterfaces ().Length, 0);
1006                 }
1007
1008                 // TODO:
1009         }
1010
1011         [Test]
1012         public void TestDefinePInvokeMethod () {
1013                 TypeBuilder tb = module.DefineType (genTypeName ());
1014
1015                 tb.DefinePInvokeMethod ("A", "B", "C", 0, 0, null, null, 0, 0);
1016
1017                 // Try invalid parameters
1018                 try {
1019                         tb.DefinePInvokeMethod (null, "B", "C", 0, 0, null, null, 0, 0);
1020                         Fail ();
1021                 }
1022                 catch (ArgumentNullException) {
1023                 }
1024                 // etc...
1025
1026                 // Try invalid attributes
1027                 try {
1028                         tb.DefinePInvokeMethod ("A2", "B", "C", MethodAttributes.Abstract, 0, null, null, 0, 0);
1029                 }
1030                 catch (ArgumentException) {
1031                 }
1032
1033                 // Try an interface parent
1034                 TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
1035
1036                 try {
1037                         tb2.DefinePInvokeMethod ("A", "B", "C", 0, 0, null, null, 0, 0);
1038                 }
1039                 catch (ArgumentException) {
1040                 }
1041         }
1042
1043         [Test]
1044         public void TestDefineProperty () {
1045                 TypeBuilder tb = module.DefineType (genTypeName ());
1046
1047                 // Check null parameter types
1048                 try {
1049                         tb.DefineProperty ("A", 0, null, new Type[1]);
1050                 }
1051                 catch (ArgumentNullException) {
1052                 }
1053         }
1054
1055         [Test]
1056         [ExpectedException (typeof(NotSupportedException))]
1057         public void TestIsDefinedIncomplete () {
1058                 TypeBuilder tb = module.DefineType (genTypeName ());
1059                 tb.IsDefined (typeof (int), true);
1060         }
1061
1062         [Test]
1063         public void TestIsDefinedComplete () {
1064                 TypeBuilder tb = module.DefineType (genTypeName ());
1065
1066                 ConstructorInfo obsoleteCtor = typeof(ObsoleteAttribute).GetConstructor(
1067                         new Type[] {typeof(string)});
1068
1069                 CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (obsoleteCtor,
1070                         new object[] { "obsolete message" }, new FieldInfo[0], new object[0]);
1071
1072                 tb.SetCustomAttribute (caBuilder);
1073                 tb.CreateType ();
1074                 AssertEquals (true, tb.IsDefined (typeof(ObsoleteAttribute), false));
1075         }
1076
1077         [Test]
1078         [ExpectedException (typeof(NotSupportedException))]
1079         public void TestGetCustomAttributesIncomplete ()
1080         {
1081                 TypeBuilder tb = module.DefineType (genTypeName ());
1082                 tb.GetCustomAttributes (false);
1083         }
1084
1085         [Test]
1086         public void TestGetCustomAttributesComplete ()
1087         {
1088                 TypeBuilder tb = module.DefineType (genTypeName ());
1089
1090                 ConstructorInfo guidCtor = typeof(GuidAttribute).GetConstructor (
1091                         new Type[] { typeof(string) });
1092
1093                 CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (guidCtor,
1094                         new object[] { Guid.NewGuid ().ToString ("D") }, new FieldInfo[0], new object[0]);
1095
1096                 tb.SetCustomAttribute (caBuilder);
1097                 tb.CreateType ();
1098
1099                 AssertEquals (1, tb.GetCustomAttributes (false).Length);
1100         }
1101
1102         [Test]
1103         [ExpectedException (typeof(NotSupportedException))]
1104         public void TestGetCustomAttributesOfTypeIncomplete ()
1105         {
1106                 TypeBuilder tb = module.DefineType (genTypeName ());
1107                 tb.GetCustomAttributes (typeof(ObsoleteAttribute), false);
1108         }
1109
1110         [Test]
1111         public void TestGetCustomAttributesOfTypeComplete ()
1112         {
1113                 TypeBuilder tb = module.DefineType (genTypeName ());
1114
1115                 ConstructorInfo guidCtor = typeof(GuidAttribute).GetConstructor (
1116                         new Type[] { typeof(string) });
1117
1118                 CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (guidCtor,
1119                         new object[] { Guid.NewGuid ().ToString ("D") }, new FieldInfo[0], new object[0]);
1120
1121                 tb.SetCustomAttribute (caBuilder);
1122                 tb.CreateType ();
1123
1124                 AssertEquals (1, tb.GetCustomAttributes (typeof(GuidAttribute), false).Length);
1125                 AssertEquals (0, tb.GetCustomAttributes (typeof(ObsoleteAttribute), false).Length);
1126         }
1127
1128         [Test]
1129         [ExpectedException (typeof(ArgumentNullException))]
1130         public void TestGetCustomAttributesOfNullTypeComplete ()
1131         {
1132                 TypeBuilder tb = module.DefineType (genTypeName ());
1133                 tb.CreateType ();
1134                 tb.GetCustomAttributes (null, false);
1135         }
1136
1137         [Test]
1138         [ExpectedException (typeof(NotSupportedException))]
1139         [Ignore("mcs depends on this")]
1140         public void TestGetEventsIncomplete () {
1141                 TypeBuilder tb = module.DefineType (genTypeName ());
1142                 tb.GetEvents ();
1143         }
1144
1145         [Test]
1146         public void TestGetEventsComplete () {
1147                 TypeBuilder tb = module.DefineType (genTypeName ());
1148
1149                 MethodBuilder onclickMethod = tb.DefineMethod ("OnChange", MethodAttributes.Public,
1150                         typeof(void), new Type[] { typeof(Object) });
1151                 onclickMethod.GetILGenerator ().Emit (OpCodes.Ret);
1152
1153                 // create public event
1154                 EventBuilder eventbuilder = tb.DefineEvent ("Change", EventAttributes.None,
1155                         typeof(ResolveEventHandler));
1156                 eventbuilder.SetRaiseMethod (onclickMethod);
1157
1158                 Type emittedType = tb.CreateType ();
1159
1160                 AssertEquals (1, tb.GetEvents ().Length);
1161                 AssertEquals (tb.GetEvents ().Length, emittedType.GetEvents ().Length);
1162         }
1163
1164
1165         [Test]
1166         [ExpectedException (typeof(NotSupportedException))]
1167         [Ignore("mcs depends on this")]
1168         public void TestGetEventsFlagsIncomplete () {
1169                 TypeBuilder tb = module.DefineType (genTypeName ());
1170                 tb.GetEvents (BindingFlags.Public);
1171         }
1172
1173         [Test]
1174         public void TestGetEventsFlagsComplete () {
1175                 TypeBuilder tb = module.DefineType (genTypeName ());
1176
1177                 MethodBuilder onchangeMethod = tb.DefineMethod ("OnChange", MethodAttributes.Public,
1178                         typeof(void), new Type[] { typeof(Object) });
1179                 onchangeMethod.GetILGenerator ().Emit (OpCodes.Ret);
1180
1181                 // create public event
1182                 EventBuilder changeEvent = tb.DefineEvent ("Change", EventAttributes.None,
1183                         typeof(ResolveEventHandler));
1184                 changeEvent.SetRaiseMethod (onchangeMethod);
1185
1186                 // create non-public event
1187                 EventBuilder redoChangeEvent = tb.DefineEvent ("RedoChange", EventAttributes.None,
1188                         typeof(ResolveEventHandler));
1189
1190                 Type emittedType = tb.CreateType ();
1191
1192                 AssertEquals (1, tb.GetEvents (BindingFlags.Instance | BindingFlags.Public).Length);
1193                 AssertEquals (1, tb.GetEvents (BindingFlags.Instance | BindingFlags.NonPublic).Length);
1194                 AssertEquals (2, tb.GetEvents (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Length);
1195                 AssertEquals (tb.GetEvents (BindingFlags.Instance | BindingFlags.Public).Length,
1196                         emittedType.GetEvents (BindingFlags.Instance | BindingFlags.Public).Length);
1197                 AssertEquals (tb.GetEvents (BindingFlags.Instance | BindingFlags.NonPublic).Length,
1198                         emittedType.GetEvents (BindingFlags.Instance | BindingFlags.NonPublic).Length);
1199                 AssertEquals (tb.GetEvents (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Length,
1200                         emittedType.GetEvents (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Length);
1201         }
1202
1203         [Test]
1204         [ExpectedException (typeof(NotSupportedException))]
1205         [Ignore("mcs depends on this")]
1206         public void TestGetEventIncomplete () {
1207                 TypeBuilder tb = module.DefineType (genTypeName ());
1208                 tb.GetEvent ("FOO");
1209         }
1210
1211         [Test]
1212         public void TestGetEventComplete () {
1213                 TypeBuilder tb = module.DefineType (genTypeName ());
1214
1215                 MethodBuilder onclickMethod = tb.DefineMethod ("OnChange", MethodAttributes.Public,
1216                         typeof(void), new Type[] { typeof(Object) });
1217                 onclickMethod.GetILGenerator ().Emit (OpCodes.Ret);
1218
1219                 EventBuilder eventbuilder = tb.DefineEvent ("Change", EventAttributes.None,
1220                         typeof(ResolveEventHandler));
1221                 eventbuilder.SetRaiseMethod (onclickMethod);
1222
1223                 Type emittedType = tb.CreateType ();
1224
1225                 AssertNotNull (tb.GetEvent ("Change"));
1226                 AssertEquals (tb.GetEvent ("Change"), emittedType.GetEvent ("Change"));
1227                 AssertNull (tb.GetEvent ("NotChange"));
1228                 AssertEquals (tb.GetEvent ("NotChange"), emittedType.GetEvent ("NotChange"));
1229         }
1230
1231         [Test]
1232         [ExpectedException (typeof(NotSupportedException))]
1233         [Ignore("mcs depends on this")]
1234         public void TestGetEventFlagsIncomplete () {
1235                 TypeBuilder tb = module.DefineType (genTypeName ());
1236                 tb.GetEvent ("FOO", BindingFlags.Public);
1237         }
1238
1239         [Test]
1240         public void TestGetEventFlagsComplete () {
1241                 TypeBuilder tb = module.DefineType (genTypeName ());
1242
1243                 MethodBuilder onclickMethod = tb.DefineMethod ("OnChange", MethodAttributes.Public,
1244                         typeof(void), new Type[] { typeof(Object) });
1245                 onclickMethod.GetILGenerator ().Emit (OpCodes.Ret);
1246
1247                 EventBuilder eventbuilder = tb.DefineEvent ("Change", EventAttributes.None,
1248                         typeof(ResolveEventHandler));
1249                 eventbuilder.SetRaiseMethod (onclickMethod);
1250
1251                 Type emittedType = tb.CreateType ();
1252
1253                 AssertNotNull (tb.GetEvent ("Change", BindingFlags.Instance | BindingFlags.Public));
1254                 AssertEquals (tb.GetEvent ("Change", BindingFlags.Instance | BindingFlags.Public),
1255                         emittedType.GetEvent ("Change", BindingFlags.Instance | BindingFlags.Public));
1256                 AssertNull (tb.GetEvent ("Change", BindingFlags.Instance | BindingFlags.NonPublic));
1257                 AssertEquals (tb.GetEvent ("Change", BindingFlags.Instance | BindingFlags.NonPublic),
1258                         emittedType.GetEvent ("Change", BindingFlags.Instance | BindingFlags.NonPublic));
1259         }
1260
1261         [Test]
1262         [ExpectedException (typeof(NotSupportedException))]
1263         [Ignore("mcs depends on this")]
1264         public void TestGetFieldsIncomplete () {
1265                 TypeBuilder tb = module.DefineType (genTypeName ());
1266                 tb.GetFields ();
1267         }
1268
1269         [Test]
1270         public void TestGetFieldsComplete () {
1271                 TypeBuilder tb = module.DefineType (genTypeName ());
1272                 tb.DefineField ("TestField", typeof(int), FieldAttributes.Public);
1273
1274                 Type emittedType = tb.CreateType ();
1275
1276                 AssertEquals (1, tb.GetFields ().Length);
1277                 AssertEquals (tb.GetFields ().Length, emittedType.GetFields().Length);
1278         }
1279
1280         [Test]
1281         [ExpectedException (typeof(NotSupportedException))]
1282         [Ignore("mcs depends on this")]
1283         public void TestGetFieldsFlagsIncomplete () {
1284                 TypeBuilder tb = module.DefineType (genTypeName ());
1285                 tb.GetFields (BindingFlags.Instance | BindingFlags.Public);
1286         }
1287
1288         [Test]
1289         public void TestGetFieldsFlagsComplete () {
1290                 TypeBuilder tb = module.DefineType (genTypeName ());
1291                 tb.DefineField ("TestField", typeof(int), FieldAttributes.Public);
1292
1293                 Type emittedType = tb.CreateType ();
1294
1295                 AssertEquals (1, tb.GetFields (BindingFlags.Instance | BindingFlags.Public).Length);
1296                 AssertEquals (tb.GetFields (BindingFlags.Instance | BindingFlags.Public).Length,
1297                         emittedType.GetFields (BindingFlags.Instance | BindingFlags.Public).Length);
1298                 AssertEquals (0, tb.GetFields (BindingFlags.Instance | BindingFlags.NonPublic).Length);
1299                 AssertEquals (tb.GetFields (BindingFlags.Instance | BindingFlags.NonPublic).Length,
1300                         emittedType.GetFields (BindingFlags.Instance | BindingFlags.NonPublic).Length);
1301         }
1302
1303         [Test]
1304         [ExpectedException (typeof(NotSupportedException))]
1305         [Ignore("mcs depends on this")]
1306         public void TestGetFieldIncomplete () {
1307                 TypeBuilder tb = module.DefineType (genTypeName ());
1308                 tb.GetField ("test");
1309         }
1310
1311         [Test]
1312         public void TestGetFieldComplete () {
1313                 TypeBuilder tb = module.DefineType (genTypeName ());
1314                 tb.DefineField ("TestField", typeof(int), FieldAttributes.Public);
1315
1316                 Type emittedType = tb.CreateType ();
1317
1318                 AssertNotNull (tb.GetField ("TestField"));
1319                 AssertEquals (tb.GetField ("TestField").Name, emittedType.GetField ("TestField").Name);
1320                 AssertNull (tb.GetField ("TestOtherField"));
1321                 AssertEquals (tb.GetField ("TestOtherField").Name,
1322                         emittedType.GetField ("TestOtherField").Name);
1323         }
1324
1325         [Test]
1326         [ExpectedException (typeof(NotSupportedException))]
1327         [Ignore("mcs depends on this")]
1328         public void TestGetFieldFlagsIncomplete () {
1329                 TypeBuilder tb = module.DefineType (genTypeName ());
1330                 tb.GetField ("test", BindingFlags.Public);
1331         }
1332
1333         [Test]
1334         public void TestGetFieldFlagsComplete () {
1335                 TypeBuilder tb = module.DefineType (genTypeName ());
1336                 tb.DefineField ("TestField", typeof(int), FieldAttributes.Public);
1337
1338                 Type emittedType = tb.CreateType ();
1339
1340                 AssertNotNull (tb.GetField ("TestField", BindingFlags.Instance | BindingFlags.Public));
1341                 AssertEquals (tb.GetField ("TestField", BindingFlags.Instance | BindingFlags.Public).Name,
1342                         emittedType.GetField ("TestField", BindingFlags.Instance | BindingFlags.Public).Name);
1343                 AssertNull (tb.GetField ("TestField", BindingFlags.Instance | BindingFlags.NonPublic));
1344                 AssertEquals (tb.GetField ("TestField", BindingFlags.Instance | BindingFlags.NonPublic),
1345                         emittedType.GetField ("TestField", BindingFlags.Instance | BindingFlags.NonPublic));
1346         }
1347
1348         [Test]
1349         [ExpectedException (typeof(NotSupportedException))]
1350         [Ignore("mcs depends on this")]
1351         public void TestGetPropertiesIncomplete () {
1352                 TypeBuilder tb = module.DefineType (genTypeName ());
1353                 tb.GetProperties ();
1354         }
1355
1356         [Test]
1357         public void TestGetPropertiesComplete () {
1358                 TypeBuilder tb = module.DefineType (genTypeName ());
1359                 DefineStringProperty (tb, "CustomerName", "customerName", MethodAttributes.Public);
1360
1361                 Type emittedType = tb.CreateType ();
1362
1363                 AssertEquals (1, tb.GetProperties ().Length);
1364                 AssertEquals (tb.GetProperties ().Length, emittedType.GetProperties ().Length);
1365         }
1366
1367         [Test]
1368         [ExpectedException (typeof(NotSupportedException))]
1369         [Ignore("mcs depends on this")]
1370         public void TestGetPropertiesFlagsIncomplete () {
1371                 TypeBuilder tb = module.DefineType (genTypeName ());
1372                 tb.GetProperties (BindingFlags.Public);
1373         }
1374
1375         [Test]
1376         public void TestGetPropertiesFlagsComplete () {
1377                 TypeBuilder tb = module.DefineType (genTypeName ());
1378                 DefineStringProperty (tb, "CustomerName", "customerName", MethodAttributes.Public);
1379
1380                 Type emittedType = tb.CreateType ();
1381
1382                 AssertEquals (1, tb.GetProperties (BindingFlags.Instance | BindingFlags.Public).Length);
1383                 AssertEquals (tb.GetProperties (BindingFlags.Instance | BindingFlags.Public).Length,
1384                         emittedType.GetProperties (BindingFlags.Instance | BindingFlags.Public).Length);
1385                 AssertEquals (0, tb.GetProperties (BindingFlags.Instance | BindingFlags.NonPublic).Length);
1386                 AssertEquals (tb.GetProperties (BindingFlags.Instance | BindingFlags.NonPublic).Length,
1387                         emittedType.GetProperties (BindingFlags.Instance | BindingFlags.NonPublic).Length);
1388         }
1389
1390         [Test]
1391         [ExpectedException (typeof(NotSupportedException))]
1392         public void TestGetPropertyIncomplete () {
1393                 TypeBuilder tb = module.DefineType (genTypeName ());
1394                 tb.GetProperty ("test");
1395         }
1396
1397         [Test]
1398         public void TestGetPropertyComplete () {
1399                 TypeBuilder tb = module.DefineType (genTypeName ());
1400                 DefineStringProperty (tb, "CustomerName", "customerName", MethodAttributes.Public);
1401
1402                 Type emittedType = tb.CreateType ();
1403
1404                 AssertNotNull (emittedType.GetProperty ("CustomerName"));
1405                 AssertNull (emittedType.GetProperty ("OtherCustomerName"));
1406
1407                 try {
1408                         tb.GetProperty ("CustomerName");
1409                         Fail ();
1410                 } catch (NotSupportedException) {}
1411         }
1412
1413         [Test]
1414         [ExpectedException (typeof(NotSupportedException))]
1415         public void TestGetPropertyFlagsIncomplete () {
1416                 TypeBuilder tb = module.DefineType (genTypeName ());
1417                 tb.GetProperty ("test", BindingFlags.Public);
1418         }
1419
1420         [Test]
1421         public void TestGetPropertyFlagsComplete () {
1422                 TypeBuilder tb = module.DefineType (genTypeName ());
1423                 DefineStringProperty (tb, "CustomerName", "customerName", MethodAttributes.Public);
1424
1425                 Type emittedType = tb.CreateType ();
1426
1427                 AssertNotNull (emittedType.GetProperty ("CustomerName", BindingFlags.Instance |
1428                         BindingFlags.Public));
1429                 AssertNull (emittedType.GetProperty ("CustomerName", BindingFlags.Instance |
1430                         BindingFlags.NonPublic));
1431
1432                 try {
1433                         tb.GetProperty ("CustomerName", BindingFlags.Instance | BindingFlags.Public);
1434                         Fail ();
1435                 }
1436                 catch (NotSupportedException) { }
1437         }
1438
1439         [Test]
1440         [ExpectedException (typeof(NotSupportedException))]
1441         [Ignore("mcs depends on this")]
1442         public void TestGetMethodsIncomplete () {
1443                 TypeBuilder tb = module.DefineType (genTypeName ());
1444                 tb.GetMethods ();
1445         }
1446
1447         [Test]
1448         public void TestGetMethodsComplete () {
1449                 TypeBuilder tb = module.DefineType (genTypeName ());
1450                 MethodBuilder helloMethod = tb.DefineMethod ("HelloMethod",
1451                         MethodAttributes.Public, typeof(string), new Type[0]);
1452                 ILGenerator helloMethodIL = helloMethod.GetILGenerator ();
1453                 helloMethodIL.Emit (OpCodes.Ldstr, "Hi! ");
1454                 helloMethodIL.Emit (OpCodes.Ldarg_1);
1455                 MethodInfo infoMethod = typeof(string).GetMethod ("Concat",
1456                         new Type[] { typeof(string), typeof(string) });
1457                 helloMethodIL.Emit (OpCodes.Call, infoMethod);
1458                 helloMethodIL.Emit (OpCodes.Ret);
1459
1460                 Type emittedType = tb.CreateType ();
1461
1462                 AssertEquals (typeof(object).GetMethods (BindingFlags.Public | BindingFlags.Instance).Length + 1,
1463                         tb.GetMethods ().Length);
1464                 AssertEquals (tb.GetMethods ().Length, emittedType.GetMethods ().Length);
1465         }
1466
1467         [Test]
1468         [ExpectedException (typeof(NotSupportedException))]
1469         [Ignore("mcs depends on this")]
1470         public void TestGetMethodsFlagsIncomplete () {
1471                 TypeBuilder tb = module.DefineType (genTypeName ());
1472                 tb.GetMethods (BindingFlags.Public);
1473         }
1474
1475         [Test]
1476         public void TestGetMethodsFlagsComplete () {
1477                 TypeBuilder tb = module.DefineType (genTypeName ());
1478                 MethodBuilder helloMethod = tb.DefineMethod ("HelloMethod",
1479                         MethodAttributes.Public, typeof(string), new Type[0]);
1480                 ILGenerator helloMethodIL = helloMethod.GetILGenerator ();
1481                 helloMethodIL.Emit (OpCodes.Ldstr, "Hi! ");
1482                 helloMethodIL.Emit (OpCodes.Ldarg_1);
1483                 MethodInfo infoMethod = typeof(string).GetMethod ("Concat",
1484                         new Type[] { typeof(string), typeof(string) });
1485                 helloMethodIL.Emit (OpCodes.Call, infoMethod);
1486                 helloMethodIL.Emit (OpCodes.Ret);
1487
1488                 Type emittedType = tb.CreateType ();
1489
1490                 AssertEquals (1, tb.GetMethods (BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Length);
1491                 AssertEquals (tb.GetMethods (BindingFlags.Instance | BindingFlags.Public).Length,
1492                         emittedType.GetMethods (BindingFlags.Instance | BindingFlags.Public).Length);
1493                 AssertEquals (0, tb.GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).Length);
1494                 AssertEquals (tb.GetMethods (BindingFlags.Instance | BindingFlags.NonPublic).Length,
1495                         emittedType.GetMethods (BindingFlags.Instance | BindingFlags.NonPublic).Length);
1496         }
1497
1498         [Test]
1499         [ExpectedException (typeof(NotSupportedException))]
1500         public void TestGetMemberIncomplete () {
1501                 TypeBuilder tb = module.DefineType (genTypeName ());
1502                 tb.GetMember ("FOO", MemberTypes.All, BindingFlags.Public);
1503         }
1504
1505         [Test]
1506         public void TestGetMemberComplete () {
1507                 TypeBuilder tb = module.DefineType (genTypeName ());
1508                 tb.DefineField ("FOO", typeof(int), FieldAttributes.Private);
1509
1510                 Type emittedType = tb.CreateType ();
1511
1512                 AssertEquals (1, tb.GetMember ("FOO", MemberTypes.Field, BindingFlags.Instance | BindingFlags.NonPublic).Length);
1513                 AssertEquals (0, tb.GetMember ("FOO", MemberTypes.Field, BindingFlags.Instance | BindingFlags.Public).Length);
1514         }
1515
1516         [Test]
1517         [ExpectedException (typeof(NotSupportedException))]
1518         public void TestGetMembersIncomplete () {
1519                 TypeBuilder tb = module.DefineType (genTypeName ());
1520                 tb.GetMembers ();
1521         }
1522
1523         [Test]
1524         public void TestGetMembersComplete () {
1525                 TypeBuilder tb = module.DefineType (genTypeName ());
1526                 Type emittedType = tb.CreateType ();
1527
1528                 AssertEquals (tb.GetMembers ().Length, emittedType.GetMembers ().Length);
1529         }
1530
1531         [Test]
1532         [ExpectedException (typeof(NotSupportedException))]
1533         public void TestGetMembersFlagsIncomplete () {
1534                 TypeBuilder tb = module.DefineType (genTypeName ());
1535                 tb.GetMembers (BindingFlags.Public);
1536         }
1537
1538         [Test]
1539         public void TestGetMembersFlagsComplete () {
1540                 TypeBuilder tb = module.DefineType (genTypeName ());
1541                 tb.DefineField ("FOO", typeof(int), FieldAttributes.Public);
1542
1543                 Type emittedType = tb.CreateType ();
1544
1545                 Assert (tb.GetMembers (BindingFlags.Instance | BindingFlags.Public).Length != 0);
1546                 AssertEquals (tb.GetMembers (BindingFlags.Instance | BindingFlags.Public).Length,
1547                         emittedType.GetMembers (BindingFlags.Instance | BindingFlags.Public).Length);
1548                 AssertEquals (tb.GetMembers (BindingFlags.Instance | BindingFlags.NonPublic).Length,
1549                         emittedType.GetMembers (BindingFlags.Instance | BindingFlags.NonPublic).Length);
1550         }
1551
1552         [Test]
1553         [ExpectedException (typeof(NotSupportedException))]
1554         public void TestGetInterfaceIncomplete () {
1555                 TypeBuilder tb = module.DefineType (genTypeName ());
1556                 tb.GetInterface ("FOO", true);
1557         }
1558
1559         [Test]
1560         public void TestGetInterfaces () {
1561                 TypeBuilder tb = module.DefineType (genTypeName ());
1562                 Type[] interfaces = tb.GetInterfaces ();
1563                 AssertEquals (0, interfaces.Length);
1564
1565                 TypeBuilder tbInterface = module.DefineType (genTypeName (), TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract);
1566                 Type emittedInterface = tbInterface.CreateType ();
1567
1568                 tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof(object), new Type[] { emittedInterface });
1569                 interfaces = tb.GetInterfaces ();
1570                 AssertEquals (1, interfaces.Length);
1571         }
1572
1573         [Test]
1574         [ExpectedException (typeof (InvalidOperationException))]
1575         public void TestAddDeclarativeSecurityAlreadyCreated () {
1576                 TypeBuilder tb = module.DefineType (genTypeName ());
1577                 tb.CreateType ();
1578
1579                 PermissionSet set = new PermissionSet (PermissionState.Unrestricted);
1580                 tb.AddDeclarativeSecurity (SecurityAction.Demand, set);
1581         }
1582
1583         [Test]
1584         [ExpectedException (typeof (ArgumentNullException))]
1585         public void TestAddDeclarativeSecurityNullPermissionSet () {
1586                 TypeBuilder tb = module.DefineType (genTypeName ());
1587
1588                 tb.AddDeclarativeSecurity (SecurityAction.Demand, null);
1589         }
1590
1591         [Test]
1592         public void TestAddDeclarativeSecurityInvalidAction () {
1593                 TypeBuilder tb = module.DefineType (genTypeName ());
1594
1595                 SecurityAction[] actions = new SecurityAction [] {
1596                         SecurityAction.RequestMinimum,
1597                         SecurityAction.RequestOptional,
1598                         SecurityAction.RequestRefuse };
1599                 PermissionSet set = new PermissionSet (PermissionState.Unrestricted);
1600
1601                 foreach (SecurityAction action in actions) {
1602                         try {
1603                                 tb.AddDeclarativeSecurity (action, set);
1604                                 Fail ();
1605                         }
1606                         catch (ArgumentException) {
1607                         }
1608                 }
1609         }
1610
1611         [Test]
1612         [ExpectedException (typeof (InvalidOperationException))]
1613         public void TestAddDeclarativeSecurityDuplicateAction () {
1614                 TypeBuilder tb = module.DefineType (genTypeName ());
1615
1616                 PermissionSet set = new PermissionSet (PermissionState.Unrestricted);
1617                 tb.AddDeclarativeSecurity (SecurityAction.Demand, set);
1618                 tb.AddDeclarativeSecurity (SecurityAction.Demand, set);
1619         }
1620
1621         [Test]
1622         public void TestEnums () {
1623                 TypeAttributes typeAttrs = TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed;
1624                 TypeBuilder enumToCreate = module.DefineType(genTypeName (), typeAttrs,
1625                                                                                                          typeof(Enum));
1626                 enumToCreate.SetCustomAttribute (new CustomAttributeBuilder (typeof (FlagsAttribute).GetConstructors ()[0], new Type [0]));
1627                 // add value__ field, see DefineEnum method of ModuleBuilder
1628                 enumToCreate.DefineField("value__", typeof(Int32),
1629                         FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName);
1630
1631                 // add enum entries
1632                 FieldBuilder fb = enumToCreate.DefineField("A", enumToCreate,
1633                         FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
1634                 fb.SetConstant((Int32) 0);
1635
1636                 fb = enumToCreate.DefineField("B", enumToCreate,
1637                         FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
1638                 fb.SetConstant((Int32) 1);
1639
1640                 fb = enumToCreate.DefineField("C", enumToCreate,
1641                         FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
1642                 fb.SetConstant((Int32) 2);
1643
1644                 Type enumType = enumToCreate.CreateType();
1645
1646                 object enumVal = Enum.ToObject(enumType, (Int32) 3);
1647
1648                 AssertEquals ("B, C", enumVal.ToString ());
1649                 AssertEquals (3, (Int32)enumVal);
1650         }
1651
1652         [Test]
1653         public void DefineEnum () {
1654                 TypeBuilder typeBuilder = module.DefineType (genTypeName (),
1655                                                                                                          TypeAttributes.Public);
1656                 EnumBuilder enumBuilder = module.DefineEnum (genTypeName (),
1657                                                                                                          TypeAttributes.Public, typeof(int));
1658                 typeBuilder.DefineField ("myField", enumBuilder, FieldAttributes.Private);
1659                 enumBuilder.CreateType();
1660                 typeBuilder.CreateType();
1661         }
1662
1663         [Test]
1664         [ExpectedException(typeof(TypeLoadException))]
1665         public void DefineEnumThrowIfTypeBuilderCalledBeforeEnumBuilder () {
1666                 TypeBuilder typeBuilder = module.DefineType (genTypeName (),
1667                                                                                                          TypeAttributes.Public);
1668                 EnumBuilder enumBuilder = module.DefineEnum (genTypeName (),
1669                                                                                                          TypeAttributes.Public, typeof(int));
1670                 typeBuilder.DefineField ("myField", enumBuilder, FieldAttributes.Private);
1671                 typeBuilder.CreateType();
1672                 enumBuilder.CreateType();
1673         }
1674         private void DefineStringProperty (TypeBuilder tb, string propertyName, string fieldName, MethodAttributes methodAttribs) {
1675                 // define the field holding the property value
1676                 FieldBuilder fieldBuilder = tb.DefineField (fieldName,
1677                         typeof(string), FieldAttributes.Private);
1678
1679                 PropertyBuilder propertyBuilder = tb.DefineProperty (
1680                         propertyName, PropertyAttributes.HasDefault, typeof(string),
1681                         new Type[] { typeof(string) });
1682
1683                 // First, we'll define the behavior of the "get" property for CustomerName as a method.
1684                 MethodBuilder getMethodBuilder = tb.DefineMethod ("Get" + propertyName,
1685                                                                 methodAttribs,
1686                                                                 typeof(string),
1687                                                                 new Type[] { });
1688
1689                 ILGenerator getIL = getMethodBuilder.GetILGenerator ();
1690
1691                 getIL.Emit (OpCodes.Ldarg_0);
1692                 getIL.Emit (OpCodes.Ldfld, fieldBuilder);
1693                 getIL.Emit (OpCodes.Ret);
1694
1695                 // Now, we'll define the behavior of the "set" property for CustomerName.
1696                 MethodBuilder setMethodBuilder = tb.DefineMethod ("Set" + propertyName,
1697                                                                 methodAttribs,
1698                                                                 null,
1699                                                                 new Type[] { typeof(string) });
1700
1701                 ILGenerator setIL = setMethodBuilder.GetILGenerator ();
1702
1703                 setIL.Emit (OpCodes.Ldarg_0);
1704                 setIL.Emit (OpCodes.Ldarg_1);
1705                 setIL.Emit (OpCodes.Stfld, fieldBuilder);
1706                 setIL.Emit (OpCodes.Ret);
1707
1708                 // Last, we must map the two methods created above to our PropertyBuilder to
1709                 // their corresponding behaviors, "get" and "set" respectively.
1710                 propertyBuilder.SetGetMethod (getMethodBuilder);
1711                 propertyBuilder.SetSetMethod (setMethodBuilder);
1712         }
1713
1714         static int handler_called = 0;
1715
1716         [Test]
1717         public void TestTypeResolve () {
1718                 string typeName = genTypeName ();
1719
1720                 ResolveEventHandler handler = new ResolveEventHandler (TypeResolve);
1721         AppDomain.CurrentDomain.TypeResolve += handler;
1722                 handler_called = 0;
1723                 Type t = Type.GetType (typeName);
1724                 AssertEquals (typeName, t.Name);
1725                 AssertEquals (1, handler_called);
1726         AppDomain.CurrentDomain.TypeResolve -= handler;
1727         }
1728
1729     Assembly TypeResolve (object sender, ResolveEventArgs args) {
1730                 TypeBuilder tb = module.DefineType (args.Name, TypeAttributes.Public);
1731                 tb.CreateType ();
1732                 handler_called ++;
1733                 return tb.Assembly;
1734         }
1735 }
1736 }