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

   1 //
   2 // ModuleBuilderTest - NUnit Test Cases for the ModuleBuilder class
   3 //
   4 // Zoltan Varga (vargaz@freemail.hu)
   5 //
   6 // (C) Ximian, Inc.  http://www.ximian.com
   7 //
   8 //
   9
  10
  11 using System;
  12 using System.Threading;
  13 using System.Reflection;
  14 using System.Reflection.Emit;
  15 using System.IO;
  16 using System.Collections;
  17 using System.Diagnostics.SymbolStore;
  18 using System.Runtime.InteropServices;
  19
  20 using NUnit.Framework;
  21
  22 namespace MonoTests.System.Reflection.Emit
  23 {
  24         [TestFixture]
  25         public class ModuleBuilderTest
  26         {
  27                 static string tempDir = Path.Combine (Path.GetTempPath (), typeof (ModuleBuilderTest).FullName);
  28                 static int nameIndex = 0;
  29
  30                 [SetUp]
  31                 public void SetUp ()
  32                 {
  33                         Random AutoRand = new Random ();
  34                         string basePath = tempDir;
  35                         while (Directory.Exists (tempDir))
  36                                 tempDir = Path.Combine (basePath, AutoRand.Next ().ToString ());
  37                         Directory.CreateDirectory (tempDir);
  38                 }
  39
  40                 [TearDown]
  41                 public void TearDown ()
  42                 {
  43                         try {
  44                                 // This throws an exception under MS.NET, since the directory contains loaded
  45                                 // assemblies.
  46                                 Directory.Delete (tempDir, true);
  47                         } catch (Exception) {
  48                         }
  49                 }
  50
  51                 private AssemblyName genAssemblyName ()
  52                 {
  53                         AssemblyName assemblyName = new AssemblyName();
  54                         assemblyName.Name = typeof (ModuleBuilderTest).FullName + (nameIndex ++);
  55                         return assemblyName;
  56                 }
  57
  58                 private AssemblyBuilder genAssembly ()
  59                 {
  60                         return Thread.GetDomain ().DefineDynamicAssembly (genAssemblyName (),
  61                                                                                                                           AssemblyBuilderAccess.RunAndSave,
  62                                                                                                                           tempDir);
  63                 }
  64
  65                 [Test]
  66                 public void TestIsTransient ()
  67                 {
  68                         AssemblyBuilder ab = genAssembly ();
  69                         ModuleBuilder mb1 = ab.DefineDynamicModule ("foo.dll");
  70                         Assert.IsTrue (mb1.IsTransient (), "#1");
  71                         ModuleBuilder mb2 = ab.DefineDynamicModule ("foo2.dll", "foo2.dll");
  72                         Assert.IsFalse (mb2.IsTransient (), "#2");
  73                 }
  74
  75                 // Some of these tests overlap with the tests for Module
  76
  77                 [Test]
  78                 public void TestGlobalData ()
  79                 {
  80                         AssemblyBuilder ab = genAssembly ();
  81
  82                         string resfile = Path.Combine (tempDir, "res");
  83                         using (StreamWriter sw = new StreamWriter (resfile)) {
  84                                 sw.WriteLine ("FOO");
  85                         }
  86
  87                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
  88
  89                         mb.DefineInitializedData ("DATA", new byte [100], FieldAttributes.Public);
  90                         mb.DefineInitializedData ("DATA2", new byte [100], FieldAttributes.Public);
  91                         mb.DefineInitializedData ("DATA3", new byte [99], FieldAttributes.Public);
  92                         mb.DefineUninitializedData ("DATA4", 101, FieldAttributes.Public);
  93                         mb.DefineInitializedData ("DATA_PRIVATE", new byte [100], 0);
  94                         mb.CreateGlobalFunctions ();
  95
  96                         ab.Save ("foo.dll");
  97
  98                         Assembly assembly = Assembly.LoadFrom (Path.Combine (tempDir, "foo.dll"));
  99
 100                         Module module = assembly.GetLoadedModules () [0];
 101
 102                         string [] expectedFieldNames = new string [] {
 103                                 "DATA", "DATA2", "DATA3", "DATA4" };
 104                         ArrayList fieldNames = new ArrayList ();
 105                         foreach (FieldInfo fi in module.GetFields ()) {
 106                                 fieldNames.Add (fi.Name);
 107                         }
 108                         AssertArrayEqualsSorted (expectedFieldNames, fieldNames.ToArray (typeof (string)));
 109
 110                         Assert.IsNotNull (module.GetField ("DATA"), "#1");
 111                         Assert.IsNotNull (module.GetField ("DATA2"), "#2");
 112                         Assert.IsNotNull (module.GetField ("DATA3"), "#3");
 113                         Assert.IsNotNull (module.GetField ("DATA4"), "#4");
 114                         Assert.IsNull (module.GetField ("DATA_PRIVATE"), "#5");
 115                         Assert.IsNotNull (module.GetField ("DATA_PRIVATE", BindingFlags.NonPublic | BindingFlags.Static), "#6");
 116                 }
 117
 118                 [Test]
 119                 [Category("NotWorking")]
 120                 public void TestGlobalMethods ()
 121                 {
 122                         AssemblyBuilder builder = genAssembly ();
 123                         ModuleBuilder module = builder.DefineDynamicModule ("MessageModule");
 124                         MethodBuilder method = module.DefinePInvokeMethod ("printf", "libc.so",
 125                                                                                                                           MethodAttributes.PinvokeImpl | MethodAttributes.Static | MethodAttributes.Public,
 126                                                                                                                           CallingConventions.Standard, typeof (void), new Type [] { typeof (string) }, CallingConvention.Winapi,
 127                                                                                                                           CharSet.Auto);
 128                         method.SetImplementationFlags (MethodImplAttributes.PreserveSig |
 129                                                                                    method.GetMethodImplementationFlags ());
 130
 131                         Assert.IsNull (module.GetMethod ("printf"), "#1");
 132
 133                         module.CreateGlobalFunctions ();
 134
 135                         Assert.IsNotNull (module.GetMethod ("printf"), "#2");
 136                 }
 137
 138                 [Test]
 139                 public void DefineType_Name_Null ()
 140                 {
 141                         AssemblyBuilder ab = genAssembly ();
 142                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 143                         try {
 144                                 mb.DefineType ((string) null);
 145                                 Assert.Fail ("#1");
 146                         } catch (ArgumentNullException ex) {
 147                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 148                                 Assert.IsNull (ex.InnerException, "#3");
 149                                 Assert.IsNotNull (ex.Message, "#4");
 150                                 Assert.AreEqual ("fullname", ex.ParamName, "#5");
 151                         }
 152                 }
 153
 154                 [Test]
 155                 public void DefineType_Name_Empty ()
 156                 {
 157                         AssemblyBuilder ab = genAssembly ();
 158                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 159                         try {
 160                                 mb.DefineType (string.Empty);
 161                                 Assert.Fail ("#1");
 162                         } catch (ArgumentException ex) {
 163                                 // Empty name is not legal
 164                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 165                                 Assert.IsNull (ex.InnerException, "#3");
 166                                 Assert.IsNotNull (ex.Message, "#4");
 167                                 Assert.AreEqual ("fullname", ex.ParamName, "#5");
 168                         }
 169                 }
 170
 171                 [Test]
 172                 public void DefineType_Name_NullChar ()
 173                 {
 174                         AssemblyBuilder ab = genAssembly ();
 175                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 176                         try {
 177                                 mb.DefineType ("\0test");
 178                                 Assert.Fail ("#1");
 179                         } catch (ArgumentException ex) {
 180                                 // Illegal name
 181                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 182                                 Assert.IsNull (ex.InnerException, "#3");
 183                                 Assert.IsNotNull (ex.Message, "#4");
 184                                 Assert.AreEqual ("fullname", ex.ParamName, "#5");
 185                         }
 186
 187                         mb.DefineType ("te\0st");
 188                 }
 189
 190                 [Test]
 191                 public void DefineType_InterfaceNotAbstract ()
 192                 {
 193                         AssemblyBuilder ab = genAssembly ();
 194                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 195
 196                         try {
 197                                 mb.DefineType ("ITest1", TypeAttributes.Interface);
 198                                 Assert.Fail ("#A1");
 199                         } catch (InvalidOperationException ex) {
 200                                 // Interface must be declared abstract
 201                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 202                                 Assert.IsNull (ex.InnerException, "#A3");
 203                                 Assert.IsNotNull (ex.Message, "#A4");
 204                         }
 205
 206                         try {
 207                                 mb.DefineType ("ITest2", TypeAttributes.Interface, (Type) null);
 208                                 Assert.Fail ("#B1");
 209                         } catch (InvalidOperationException ex) {
 210                                 // Interface must be declared abstract
 211                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 212                                 Assert.IsNull (ex.InnerException, "#B3");
 213                                 Assert.IsNotNull (ex.Message, "#B4");
 214                         }
 215
 216                         // fail on MS .NET 1.1
 217                         TypeBuilder tb = mb.DefineType ("ITest2", TypeAttributes.Interface,
 218                                 typeof (object));
 219                         Assert.AreEqual (typeof (object), tb.BaseType, "#C1");
 220
 221                         tb = mb.DefineType ("ITest3", TypeAttributes.Interface,
 222                                 typeof (IDisposable));
 223                         Assert.AreEqual (typeof (IDisposable), tb.BaseType, "#D1");
 224                 }
 225
 226                 [Test]
 227                 public void DefineType_Parent_Interface ()
 228                 {
 229                         TypeBuilder tb;
 230
 231                         AssemblyBuilder ab = genAssembly ();
 232                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 233
 234                         tb = mb.DefineType ("Foo", TypeAttributes.Class,
 235                                 typeof (ICollection));
 236                         Assert.AreEqual (typeof (ICollection), tb.BaseType, "#1");
 237
 238                         tb = mb.DefineType ("Bar", TypeAttributes.Interface,
 239                                 typeof (ICollection));
 240                         Assert.AreEqual (typeof (ICollection), tb.BaseType, "#2");
 241                 }
 242
 243                 [Test]
 244                 public void DefineType_TypeSize ()
 245                 {
 246                         AssemblyBuilder ab = genAssembly ();
 247                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 248
 249                         TypeBuilder tb = mb.DefineType ("Foo", TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.SequentialLayout,
 250                                 typeof (ValueType), 1);
 251                         Assert.AreEqual (1, tb.Size);
 252                 }
 253
 254                 [Test]
 255                 [ExpectedException (typeof (ArgumentException))]
 256                 public void DuplicateTypeName () {
 257                         AssemblyBuilder ab = genAssembly ();
 258                         ModuleBuilder module = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 259
 260                         var itb = module.DefineType ("TBase", TypeAttributes.Public);
 261
 262                         itb.SetParent (typeof(ValueType));
 263
 264                         var ptb = module.DefineType ("TBase", TypeAttributes.Public);
 265
 266                         ptb.SetParent (typeof(Enum));
 267                 }
 268
 269                 [Test]
 270                 public void DuplicateSymbolDocument ()
 271                 {
 272                         AssemblyBuilder ab = genAssembly ();
 273                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 274
 275                         // Check that it is possible to redefine a symbol document
 276                         ISymbolDocumentWriter doc1 =
 277                                 mb.DefineDocument ("foo.il", SymDocumentType.Text,
 278                                                                   SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft);
 279                         ISymbolDocumentWriter doc2 =
 280                                 mb.DefineDocument ("foo.il", SymDocumentType.Text,
 281                                                                   SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft);
 282                 }
 283
 284                 [Test] // Test case for #80435.
 285                 public void GetArrayMethodToStringTest ()
 286                 {
 287                         AssemblyBuilder assembly = genAssembly ();
 288                         ModuleBuilder module = assembly.DefineDynamicModule ("m", "test.dll");
 289
 290                         Type [] myArrayClass = new Type [1];
 291                         Type [] parameterTypes = { typeof (Array) };
 292                         MethodInfo myMethodInfo = module.GetArrayMethod (myArrayClass.GetType (), "Sort", CallingConventions.Standard, null, parameterTypes);
 293
 294                         string str = myMethodInfo.ToString ();
 295                         Assert.IsNotNull (str);
 296                         // Don't compare string, since MS returns System.Reflection.Emit.SymbolMethod here
 297                         // (they do not provide an implementation of ToString).
 298                 }
 299
 300                 private static void AssertArrayEqualsSorted (Array o1, Array o2)
 301                 {
 302                         Array s1 = (Array) o1.Clone ();
 303                         Array s2 = (Array) o2.Clone ();
 304
 305                         Array.Sort (s1);
 306                         Array.Sort (s2);
 307
 308                         Assert.AreEqual (s1.Length, s2.Length, "#1");
 309                         for (int i = 0; i < s1.Length; ++i)
 310                                 Assert.AreEqual (s1.GetValue (i), s2.GetValue (i), "#2: " + i);
 311                 }
 312
 313                 [Test]
 314                 public void ResolveFieldTokenFieldBuilder ()
 315                 {
 316                         AssemblyBuilder ab = genAssembly ();
 317                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 318
 319                         TypeBuilder tb = mb.DefineType ("foo");
 320                         FieldBuilder fb = tb.DefineField ("foo", typeof (int), 0);
 321                         tb.CreateType ();
 322
 323                         FieldInfo fi = mb.ResolveField (0x04000001);
 324                         Assert.IsNotNull (fi);
 325                         Assert.AreEqual ("foo", fi.Name);
 326                 }
 327
 328                 [Test]
 329                 public void ResolveGenericFieldBuilderOnGenericTypeBuilder ()
 330                 {
 331                         AssemblyBuilder ab = genAssembly ();
 332                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 333
 334                         TypeBuilder tb = mb.DefineType ("Foo`1");
 335                         var t = tb.DefineGenericParameters ("T") [0];
 336                         FieldBuilder fb = tb.DefineField ("foo", t, 0);
 337                         tb.CreateType ();
 338
 339                         FieldInfo fi = mb.ResolveField (0x04000001);
 340                         Assert.IsNotNull (fi);
 341                         Assert.AreEqual ("foo", fi.Name);
 342                 }
 343
 344                 [Test]
 345                 [ExpectedException (typeof (ArgumentException))]
 346                 public void ResolveFieldTokenInvalidToken ()
 347                 {
 348                         AssemblyBuilder ab = genAssembly ();
 349                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 350
 351                         mb.ResolveField (0x4001234);
 352                 }
 353
 354                 [Test]
 355                 public void ResolveMethodTokenMethodBuilder ()
 356                 {
 357                         AssemblyBuilder ab = genAssembly ();
 358                         ModuleBuilder moduleb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 359
 360                         TypeBuilder tb = moduleb.DefineType ("foo");
 361                         MethodBuilder mb = tb.DefineMethod("Frub", MethodAttributes.Static, null, new Type[] { typeof(IntPtr) });
 362                         int tok = mb.GetToken().Token;
 363                         mb.SetImplementationFlags(MethodImplAttributes.NoInlining);
 364                         ILGenerator ilgen = mb.GetILGenerator();
 365                         ilgen.Emit(OpCodes.Ret);
 366
 367                         tb.CreateType ();
 368
 369                         MethodBase mi = moduleb.ResolveMethod (tok);
 370                         Assert.IsNotNull (mi);
 371                         Assert.AreEqual ("Frub", mi.Name);
 372                 }
 373
 374                 [Test]
 375                 public void GetMethodTokenCrossMethodBuilders ()
 376                 {
 377                         AssemblyBuilder ab = genAssembly ();
 378                         ModuleBuilder moduleb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 379
 380                         TypeBuilder tb = moduleb.DefineType ("foo");
 381                         MethodBuilder mb = tb.DefineMethod("Frub", MethodAttributes.Static, null, new Type[] { typeof(IntPtr) });
 382                         int tok = mb.GetToken().Token;
 383                         mb.SetImplementationFlags(MethodImplAttributes.NoInlining);
 384                         ILGenerator ilgen = mb.GetILGenerator();
 385                         ilgen.Emit(OpCodes.Ret);
 386
 387                         tb.CreateType ();
 388
 389                         var mi = (MethodInfo) moduleb.ResolveMember (tok);
 390                         Assert.IsNotNull (mi);
 391
 392                         ModuleBuilder moduleb2 = ab.DefineDynamicModule ("foo2.dll", "foo2.dll");
 393                         var tok2 = moduleb2.GetMethodToken (mi).Token;
 394
 395                         MethodBase mi2 = moduleb.ResolveMethod (tok2);
 396                         Assert.IsNotNull (mi2);
 397                         Assert.AreEqual ("Frub", mi.Name);
 398                 }
 399
 400                 [Test]
 401                 public void ResolveMemberField ()
 402                 {
 403                         var assembly = genAssembly ();
 404                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 405
 406                         var type = module.DefineType ("Foo");
 407                         var method = type.DefineMethod ("Str", MethodAttributes.Static, typeof (string), Type.EmptyTypes);
 408                         var il = method.GetILGenerator ();
 409
 410                         il.Emit (OpCodes.Ldsfld, typeof (string).GetField ("Empty"));
 411                         il.Emit (OpCodes.Ret);
 412
 413                         type.CreateType ();
 414
 415                         var string_empty = (FieldInfo) module.ResolveMember (0x0a000001);
 416                         Assert.IsNotNull (string_empty);
 417                         Assert.AreEqual ("Empty", string_empty.Name);
 418                         Assert.AreEqual (typeof (string), string_empty.DeclaringType);
 419                 }
 420
 421                 [Test]
 422                 public void ResolveMemberMethod ()
 423                 {
 424                         var assembly = genAssembly ();
 425                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 426
 427                         var type = module.DefineType ("Foo");
 428                         var method = type.DefineMethod ("Str", MethodAttributes.Static, typeof (void), Type.EmptyTypes);
 429                         var il = method.GetILGenerator ();
 430
 431                         il.Emit (OpCodes.Call, typeof (Console).GetMethod ("WriteLine", Type.EmptyTypes));
 432                         il.Emit (OpCodes.Ret);
 433
 434                         type.CreateType ();
 435
 436                         var writeline = (MethodInfo) module.ResolveMember (0x0a000001);
 437                         Assert.IsNotNull (writeline);
 438                         Assert.AreEqual ("WriteLine", writeline.Name);
 439                         Assert.AreEqual (typeof (Console), writeline.DeclaringType);
 440                 }
 441
 442                 [Test]
 443                 public void ResolveMethodDefWithGenericArguments ()
 444                 {
 445                         var assembly = genAssembly ();
 446                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 447
 448                         var type = module.DefineType ("Foo`1");
 449                         var t = type.DefineGenericParameters ("T") [0];
 450
 451                         var method = type.DefineMethod ("Method", MethodAttributes.Static, typeof (void), new Type [] { t });
 452                         method.GetILGenerator ().Emit (OpCodes.Ret);
 453
 454                         type.DefineDefaultConstructor (MethodAttributes.Public);
 455
 456                         type.CreateType ();
 457
 458                         var resolved_method = (MethodInfo) module.ResolveMember (0x06000001, new [] { typeof (string) }, Type.EmptyTypes);
 459                         Assert.IsNotNull (resolved_method);
 460                         Assert.AreEqual ("Method", resolved_method.Name);
 461                         Assert.IsTrue (resolved_method.GetParameters () [0].ParameterType.IsGenericParameter);
 462                 }
 463
 464                 [Test]
 465                 public void ResolveFieldDefWithGenericArguments ()
 466                 {
 467                         var assembly = genAssembly ();
 468                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 469
 470                         var type = module.DefineType ("Foo`1");
 471                         var t = type.DefineGenericParameters ("T") [0];
 472
 473                         var field = type.DefineField ("field", t, FieldAttributes.Public);
 474
 475                         type.CreateType ();
 476
 477                         var resolved_field = (FieldInfo) module.ResolveMember (0x04000001, new [] { typeof (string) }, Type.EmptyTypes);
 478                         Assert.IsNotNull (resolved_field);
 479                         Assert.AreEqual ("field", resolved_field.Name);
 480                         Assert.IsTrue (resolved_field.FieldType.IsGenericParameter);
 481                 }
 482
 483                 [Test]
 484                 public void ResolveTypeDefWithGenericArguments ()
 485                 {
 486                         var assembly = genAssembly ();
 487                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 488
 489                         var type = module.DefineType ("Foo`1");
 490                         var t = type.DefineGenericParameters ("T") [0];
 491
 492                         type.CreateType ();
 493
 494                         var foo = (Type) module.ResolveMember (0x02000002, new [] { typeof (string) }, Type.EmptyTypes);
 495                         Assert.IsNotNull (foo);
 496                         Assert.AreEqual ("Foo`1", foo.Name);
 497                         Assert.IsTrue (foo.IsGenericTypeDefinition);
 498                 }
 499
 500                 [Test]
 501                 public void ResolveFieldMemberRefWithGenericArguments ()
 502                 {
 503                         var assembly = genAssembly ();
 504                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 505
 506                         var type = module.DefineType ("Foo`1");
 507                         var t = type.DefineGenericParameters ("T") [0];
 508
 509                         var field = type.DefineField ("field", t, FieldAttributes.Public);
 510
 511                         var method = type.DefineMethod ("Method", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
 512                         var il = method.GetILGenerator ();
 513
 514                         il.Emit (OpCodes.Ldarg_0);
 515                         il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
 516                         il.Emit (OpCodes.Pop);
 517                         il.Emit (OpCodes.Ret);
 518
 519                         type.CreateType ();
 520
 521                         var resolved_field = (FieldInfo) module.ResolveMember (0x0a000001, new [] { typeof (string) }, null);
 522                         Assert.IsNotNull (resolved_field);
 523                         Assert.AreEqual ("field", resolved_field.Name);
 524                         Assert.AreEqual (typeof (string), resolved_field.FieldType);
 525                 }
 526
 527                 [Test]
 528                 public void ResolveMethodMemberRefWithGenericArguments ()
 529                 {
 530                         var assembly = genAssembly ();
 531                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 532
 533                         var type = module.DefineType ("Foo`1");
 534                         var t = type.DefineGenericParameters ("T") [0];
 535
 536                         var field = type.DefineField ("field", t, FieldAttributes.Public);
 537
 538                         var method = type.DefineMethod ("Method", MethodAttributes.Public, typeof (void), new Type [] { t });
 539                         method.GetILGenerator ().Emit (OpCodes.Ret);
 540
 541                         var ctor = type.DefineMethod ("Caller", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
 542                         var il = ctor.GetILGenerator ();
 543
 544                         il.Emit (OpCodes.Ldarg_0);
 545                         il.Emit (OpCodes.Ldarg_0);
 546                         il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
 547                         il.Emit (OpCodes.Callvirt, method); // this too
 548                         il.Emit (OpCodes.Ret);
 549
 550                         type.DefineDefaultConstructor (MethodAttributes.Public);
 551
 552                         type.CreateType ();
 553
 554                         var resolved_method = (MethodInfo) module.ResolveMember (0x0a000002, new [] { typeof (string) }, null);
 555                         Assert.IsNotNull (resolved_method);
 556                         Assert.AreEqual ("Method", resolved_method.Name);
 557                         Assert.AreEqual (typeof (string), resolved_method.GetParameters () [0].ParameterType);
 558                 }
 559
 560                 [Test]
 561                 public void ResolveMethodSpecWithGenericArguments ()
 562                 {
 563                         var assembly = genAssembly ();
 564                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 565
 566                         var type = module.DefineType ("Foo`1");
 567                         var t = type.DefineGenericParameters ("T") [0];
 568
 569                         var field = type.DefineField ("field", t, FieldAttributes.Public);
 570
 571                         var method = type.DefineMethod ("Method", MethodAttributes.Public);
 572                         var s = method.DefineGenericParameters ("S") [0];
 573                         method.SetReturnType (typeof (void));
 574                         method.SetParameters (t, s);
 575                         method.GetILGenerator ().Emit (OpCodes.Ret);
 576
 577                         var ctor = type.DefineMethod ("Caller", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
 578                         var il = ctor.GetILGenerator ();
 579
 580                         il.Emit (OpCodes.Ldarg_0);
 581                         il.Emit (OpCodes.Ldarg_0);
 582                         il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
 583                         il.Emit (OpCodes.Ldarg_0);
 584                         il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
 585                         il.Emit (OpCodes.Callvirt, method); // this triggers the creation of a MethodSpec
 586                         il.Emit (OpCodes.Ret);
 587
 588                         type.DefineDefaultConstructor (MethodAttributes.Public);
 589
 590                         type.CreateType ();
 591
 592                         var resolved_method = (MethodInfo) module.ResolveMember (0x2b000001, new [] { typeof (string) }, new [] { typeof (int) });
 593                         Assert.IsNotNull (resolved_method);
 594                         Assert.AreEqual ("Method", resolved_method.Name);
 595                         Assert.AreEqual (typeof (string), resolved_method.GetParameters () [0].ParameterType);
 596                         Assert.AreEqual (typeof (int), resolved_method.GetParameters () [1].ParameterType);
 597                 }
 598
 599                 [Test]
 600                 public void GetTypes ()
 601                 {
 602                         AssemblyBuilder ab = genAssembly ();
 603                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 604
 605                         TypeBuilder tb1 = mb.DefineType("Foo", TypeAttributes.Public);
 606
 607                         Type[] types = mb.GetTypes ();
 608                         Assert.AreEqual (1, types.Length);
 609                         Assert.AreEqual (tb1, types [0]);
 610
 611                         // After the type is created, MS seems to return the created type
 612                         tb1.CreateType ();
 613
 614                         types = mb.GetTypes ();
 615                         Assert.AreEqual (tb1.CreateType (), types [0]);
 616                 }
 617
 618                 [Test] // GetTypeToken (Type)
 619                 [Category ("NotDotNet")] // http://support.microsoft.com/kb/950986
 620                 public void GetTypeToken2_Type_Array ()
 621                 {
 622                         Type type;
 623                         TypeToken typeToken;
 624                         Type resolved_type;
 625
 626                         AssemblyName aname = genAssemblyName ();
 627                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 628                                 aname, AssemblyBuilderAccess.RunAndSave);
 629                         ModuleBuilder mb = ab.DefineDynamicModule ("MyModule");
 630
 631                         type = typeof (object []);
 632                         typeToken = mb.GetTypeToken (type);
 633                         Assert.IsFalse (typeToken == TypeToken.Empty, "#A1");
 634                         resolved_type = mb.ResolveType (typeToken.Token);
 635                         Assert.AreEqual (type, resolved_type, "#A2");
 636
 637                         type = typeof (object).MakeArrayType ();
 638                         typeToken = mb.GetTypeToken (type);
 639                         Assert.IsFalse (typeToken == TypeToken.Empty, "#B1");
 640                         resolved_type = mb.ResolveType (typeToken.Token);
 641                         Assert.AreEqual (type, resolved_type, "#B2");
 642                 }
 643
 644                 [Test] // GetTypeToken (Type)
 645                 public void GetTypeToken2_Type_String ()
 646                 {
 647                         AssemblyName aname = genAssemblyName ();
 648                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 649                                 aname, AssemblyBuilderAccess.RunAndSave);
 650                         ModuleBuilder mb = ab.DefineDynamicModule ("MyModule");
 651                         Type type = typeof (string);
 652                         TypeToken typeToken = mb.GetTypeToken (type);
 653                         Assert.IsFalse (typeToken == TypeToken.Empty, "#1");
 654                         Type resolved_type = mb.ResolveType (typeToken.Token);
 655                         Assert.AreEqual (type, resolved_type, "#2");
 656                 }
 657
 658                 [Test] // bug #471302
 659                 public void ModuleBuilder_ModuleVersionId ()
 660                 {
 661                         var name = new AssemblyName () { Name = "Foo" };
 662                         var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly (
 663                                 name, AssemblyBuilderAccess.Run);
 664
 665                         var module = assembly.DefineDynamicModule ("Foo");
 666
 667                         Assert.AreNotEqual (new Guid (), module.ModuleVersionId);
 668                 }
 669
 670                 [Test]
 671                 public void GetType_String_Null ()
 672                 {
 673                         AssemblyName an = genAssemblyName ();
 674                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
 675                         ModuleBuilder module = ab.DefineDynamicModule ("GetTypeNullCheck");
 676
 677                         try {
 678                                 module.GetType (null);
 679                                 Assert.Fail ("Expected ArgumentNullException for GetType(string)");
 680                         }
 681                         catch (ArgumentNullException) {
 682                         }
 683                         try {
 684                                 module.GetType (null, true); // ignoreCase
 685                                 Assert.Fail ("Expected ArgumentNullException for GetType(string,bool)");
 686                         }
 687                         catch (ArgumentNullException) {
 688                         }
 689                         try {
 690                                 module.GetType (null, true, true); // throwOnError, ignoreCase
 691                                 Assert.Fail ("Expected ArgumentNullException for GetType(string,bool,bool)");
 692                         }
 693                         catch (ArgumentNullException) {
 694                         }
 695                 }
 696
 697                 [Test]
 698                 public void GetType_String_Empty ()
 699                 {
 700                         AssemblyName an = genAssemblyName ();
 701                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
 702                         ModuleBuilder module = ab.DefineDynamicModule ("GetTypeEmptyCheck");
 703
 704                         try {
 705                                 module.GetType (String.Empty);
 706                                 Assert.Fail ("Expected ArgumentNullException for GetType(string)");
 707                         }
 708                         catch (ArgumentException) {
 709                         }
 710                         try {
 711                                 module.GetType (String.Empty, true); // ignoreCase
 712                                 Assert.Fail ("Expected ArgumentNullException for GetType(string,bool)");
 713                         }
 714                         catch (ArgumentException) {
 715                         }
 716                         try {
 717                                 module.GetType (String.Empty, true, true); // throwOnError, ignoreCase
 718                                 Assert.Fail ("Expected ArgumentNullException for GetType(string,bool,bool)");
 719                         }
 720                         catch (ArgumentException) {
 721                         }
 722                 }
 723         }
 724 }