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                 [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
 140                 public void DefineType_Name_Null ()
 141                 {
 142                         AssemblyBuilder ab = genAssembly ();
 143                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 144                         try {
 145                                 mb.DefineType ((string) null);
 146                                 Assert.Fail ("#1");
 147                         } catch (ArgumentNullException ex) {
 148                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 149                                 Assert.IsNull (ex.InnerException, "#3");
 150                                 Assert.IsNotNull (ex.Message, "#4");
 151                                 Assert.AreEqual ("fullname", ex.ParamName, "#5");
 152                         }
 153                 }
 154
 155                 [Test]
 156                 [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
 157                 public void DefineType_Name_Empty ()
 158                 {
 159                         AssemblyBuilder ab = genAssembly ();
 160                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 161                         try {
 162                                 mb.DefineType (string.Empty);
 163                                 Assert.Fail ("#1");
 164                         } catch (ArgumentException ex) {
 165                                 // Empty name is not legal
 166                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 167                                 Assert.IsNull (ex.InnerException, "#3");
 168                                 Assert.IsNotNull (ex.Message, "#4");
 169                                 Assert.AreEqual ("fullname", ex.ParamName, "#5");
 170                         }
 171                 }
 172
 173                 [Test]
 174                 [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
 175                 public void DefineType_Name_NullChar ()
 176                 {
 177                         AssemblyBuilder ab = genAssembly ();
 178                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 179                         try {
 180                                 mb.DefineType ("\0test");
 181                                 Assert.Fail ("#1");
 182                         } catch (ArgumentException ex) {
 183                                 // Illegal name
 184                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 185                                 Assert.IsNull (ex.InnerException, "#3");
 186                                 Assert.IsNotNull (ex.Message, "#4");
 187                                 Assert.AreEqual ("fullname", ex.ParamName, "#5");
 188                         }
 189
 190                         mb.DefineType ("te\0st");
 191                 }
 192
 193                 [Test]
 194                 [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
 195                 public void DefineType_InterfaceNotAbstract ()
 196                 {
 197                         AssemblyBuilder ab = genAssembly ();
 198                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 199
 200                         try {
 201                                 mb.DefineType ("ITest1", TypeAttributes.Interface);
 202                                 Assert.Fail ("#A1");
 203                         } catch (InvalidOperationException ex) {
 204                                 // Interface must be declared abstract
 205                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
 206                                 Assert.IsNull (ex.InnerException, "#A3");
 207                                 Assert.IsNotNull (ex.Message, "#A4");
 208                         }
 209
 210                         try {
 211                                 mb.DefineType ("ITest2", TypeAttributes.Interface, (Type) null);
 212                                 Assert.Fail ("#B1");
 213                         } catch (InvalidOperationException ex) {
 214                                 // Interface must be declared abstract
 215                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
 216                                 Assert.IsNull (ex.InnerException, "#B3");
 217                                 Assert.IsNotNull (ex.Message, "#B4");
 218                         }
 219
 220                         // fail on MS .NET 1.1
 221                         TypeBuilder tb = mb.DefineType ("ITest2", TypeAttributes.Interface,
 222                                 typeof (object));
 223                         Assert.AreEqual (typeof (object), tb.BaseType, "#C1");
 224
 225                         tb = mb.DefineType ("ITest3", TypeAttributes.Interface,
 226                                 typeof (IDisposable));
 227                         Assert.AreEqual (typeof (IDisposable), tb.BaseType, "#D1");
 228                 }
 229
 230                 [Test]
 231                 [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
 232                 public void DefineType_Parent_Interface ()
 233                 {
 234                         TypeBuilder tb;
 235
 236                         AssemblyBuilder ab = genAssembly ();
 237                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 238
 239                         tb = mb.DefineType ("Foo", TypeAttributes.Class,
 240                                 typeof (ICollection));
 241                         Assert.AreEqual (typeof (ICollection), tb.BaseType, "#1");
 242
 243                         tb = mb.DefineType ("Bar", TypeAttributes.Interface,
 244                                 typeof (ICollection));
 245                         Assert.AreEqual (typeof (ICollection), tb.BaseType, "#2");
 246                 }
 247
 248                 [Test]
 249                 [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
 250                 public void DefineType_TypeSize ()
 251                 {
 252                         AssemblyBuilder ab = genAssembly ();
 253                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 254
 255                         TypeBuilder tb = mb.DefineType ("Foo", TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.SequentialLayout,
 256                                 typeof (ValueType), 1);
 257                         Assert.AreEqual (1, tb.Size);
 258                 }
 259
 260                 [Test]
 261                 [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
 262                 [ExpectedException (typeof (ArgumentException))]
 263                 public void DuplicateTypeName () {
 264                         AssemblyBuilder ab = genAssembly ();
 265                         ModuleBuilder module = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 266
 267                         var itb = module.DefineType ("TBase", TypeAttributes.Public);
 268
 269                         itb.SetParent (typeof(ValueType));
 270
 271                         var ptb = module.DefineType ("TBase", TypeAttributes.Public);
 272
 273                         ptb.SetParent (typeof(Enum));
 274                 }
 275
 276                 [Test]
 277                 [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
 278                 public void DuplicateSymbolDocument ()
 279                 {
 280                         AssemblyBuilder ab = genAssembly ();
 281                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 282
 283                         // Check that it is possible to redefine a symbol document
 284                         ISymbolDocumentWriter doc1 =
 285                                 mb.DefineDocument ("foo.il", SymDocumentType.Text,
 286                                                                   SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft);
 287                         ISymbolDocumentWriter doc2 =
 288                                 mb.DefineDocument ("foo.il", SymDocumentType.Text,
 289                                                                   SymLanguageType.ILAssembly, SymLanguageVendor.Microsoft);
 290                 }
 291
 292                 [Test] // Test case for #80435.
 293                 public void GetArrayMethodToStringTest ()
 294                 {
 295                         AssemblyBuilder assembly = genAssembly ();
 296                         ModuleBuilder module = assembly.DefineDynamicModule ("m", "test.dll");
 297
 298                         Type [] myArrayClass = new Type [1];
 299                         Type [] parameterTypes = { typeof (Array) };
 300                         MethodInfo myMethodInfo = module.GetArrayMethod (myArrayClass.GetType (), "Sort", CallingConventions.Standard, null, parameterTypes);
 301
 302                         string str = myMethodInfo.ToString ();
 303                         Assert.IsNotNull (str);
 304                         // Don't compare string, since MS returns System.Reflection.Emit.SymbolMethod here
 305                         // (they do not provide an implementation of ToString).
 306                 }
 307
 308                 private static void AssertArrayEqualsSorted (Array o1, Array o2)
 309                 {
 310                         Array s1 = (Array) o1.Clone ();
 311                         Array s2 = (Array) o2.Clone ();
 312
 313                         Array.Sort (s1);
 314                         Array.Sort (s2);
 315
 316                         Assert.AreEqual (s1.Length, s2.Length, "#1");
 317                         for (int i = 0; i < s1.Length; ++i)
 318                                 Assert.AreEqual (s1.GetValue (i), s2.GetValue (i), "#2: " + i);
 319                 }
 320
 321                 [Test]
 322                 public void ResolveFieldTokenFieldBuilder ()
 323                 {
 324                         AssemblyBuilder ab = genAssembly ();
 325                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 326
 327                         TypeBuilder tb = mb.DefineType ("foo");
 328                         FieldBuilder fb = tb.DefineField ("foo", typeof (int), 0);
 329                         tb.CreateType ();
 330
 331                         FieldInfo fi = mb.ResolveField (0x04000001);
 332                         Assert.IsNotNull (fi);
 333                         Assert.AreEqual ("foo", fi.Name);
 334                 }
 335
 336                 [Test]
 337                 public void ResolveGenericFieldBuilderOnGenericTypeBuilder ()
 338                 {
 339                         AssemblyBuilder ab = genAssembly ();
 340                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 341
 342                         TypeBuilder tb = mb.DefineType ("Foo`1");
 343                         var t = tb.DefineGenericParameters ("T") [0];
 344                         FieldBuilder fb = tb.DefineField ("foo", t, 0);
 345                         tb.CreateType ();
 346
 347                         FieldInfo fi = mb.ResolveField (0x04000001);
 348                         Assert.IsNotNull (fi);
 349                         Assert.AreEqual ("foo", fi.Name);
 350                 }
 351
 352                 [Test]
 353                 [ExpectedException (typeof (ArgumentException))]
 354                 public void ResolveFieldTokenInvalidToken ()
 355                 {
 356                         AssemblyBuilder ab = genAssembly ();
 357                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 358
 359                         mb.ResolveField (0x4001234);
 360                 }
 361
 362                 [Test]
 363                 public void ResolveMethodTokenMethodBuilder ()
 364                 {
 365                         AssemblyBuilder ab = genAssembly ();
 366                         ModuleBuilder moduleb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 367
 368                         TypeBuilder tb = moduleb.DefineType ("foo");
 369                         MethodBuilder mb = tb.DefineMethod("Frub", MethodAttributes.Static, null, new Type[] { typeof(IntPtr) });
 370                         int tok = mb.GetToken().Token;
 371                         mb.SetImplementationFlags(MethodImplAttributes.NoInlining);
 372                         ILGenerator ilgen = mb.GetILGenerator();
 373                         ilgen.Emit(OpCodes.Ret);
 374
 375                         tb.CreateType ();
 376
 377                         MethodBase mi = moduleb.ResolveMethod (tok);
 378                         Assert.IsNotNull (mi);
 379                         Assert.AreEqual ("Frub", mi.Name);
 380                 }
 381
 382                 [Test]
 383                 public void GetMethodTokenCrossMethodBuilders ()
 384                 {
 385                         AssemblyBuilder ab = genAssembly ();
 386                         ModuleBuilder moduleb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 387
 388                         TypeBuilder tb = moduleb.DefineType ("foo");
 389                         MethodBuilder mb = tb.DefineMethod("Frub", MethodAttributes.Static, null, new Type[] { typeof(IntPtr) });
 390                         int tok = mb.GetToken().Token;
 391                         mb.SetImplementationFlags(MethodImplAttributes.NoInlining);
 392                         ILGenerator ilgen = mb.GetILGenerator();
 393                         ilgen.Emit(OpCodes.Ret);
 394
 395                         tb.CreateType ();
 396
 397                         var mi = (MethodInfo) moduleb.ResolveMember (tok);
 398                         Assert.IsNotNull (mi);
 399
 400                         ModuleBuilder moduleb2 = ab.DefineDynamicModule ("foo2.dll", "foo2.dll");
 401                         var tok2 = moduleb2.GetMethodToken (mi).Token;
 402
 403                         MethodBase mi2 = moduleb.ResolveMethod (tok2);
 404                         Assert.IsNotNull (mi2);
 405                         Assert.AreEqual ("Frub", mi.Name);
 406                 }
 407
 408                 [Test]
 409                 public void ResolveMemberField ()
 410                 {
 411                         var assembly = genAssembly ();
 412                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 413
 414                         var type = module.DefineType ("Foo");
 415                         var method = type.DefineMethod ("Str", MethodAttributes.Static, typeof (string), Type.EmptyTypes);
 416                         var il = method.GetILGenerator ();
 417
 418                         il.Emit (OpCodes.Ldsfld, typeof (string).GetField ("Empty"));
 419                         il.Emit (OpCodes.Ret);
 420
 421                         type.CreateType ();
 422
 423                         var string_empty = (FieldInfo) module.ResolveMember (0x0a000001);
 424                         Assert.IsNotNull (string_empty);
 425                         Assert.AreEqual ("Empty", string_empty.Name);
 426                         Assert.AreEqual (typeof (string), string_empty.DeclaringType);
 427                 }
 428
 429                 [Test]
 430                 public void ResolveMemberMethod ()
 431                 {
 432                         var assembly = genAssembly ();
 433                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 434
 435                         var type = module.DefineType ("Foo");
 436                         var method = type.DefineMethod ("Str", MethodAttributes.Static, typeof (void), Type.EmptyTypes);
 437                         var il = method.GetILGenerator ();
 438
 439                         il.Emit (OpCodes.Call, typeof (Console).GetMethod ("WriteLine", Type.EmptyTypes));
 440                         il.Emit (OpCodes.Ret);
 441
 442                         type.CreateType ();
 443
 444                         var writeline = (MethodInfo) module.ResolveMember (0x0a000001);
 445                         Assert.IsNotNull (writeline);
 446                         Assert.AreEqual ("WriteLine", writeline.Name);
 447                         Assert.AreEqual (typeof (Console), writeline.DeclaringType);
 448                 }
 449
 450                 [Test]
 451                 public void ResolveMethodDefWithGenericArguments ()
 452                 {
 453                         var assembly = genAssembly ();
 454                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 455
 456                         var type = module.DefineType ("Foo`1");
 457                         var t = type.DefineGenericParameters ("T") [0];
 458
 459                         var method = type.DefineMethod ("Method", MethodAttributes.Static, typeof (void), new Type [] { t });
 460                         method.GetILGenerator ().Emit (OpCodes.Ret);
 461
 462                         type.DefineDefaultConstructor (MethodAttributes.Public);
 463
 464                         type.CreateType ();
 465
 466                         var resolved_method = (MethodInfo) module.ResolveMember (0x06000001, new [] { typeof (string) }, Type.EmptyTypes);
 467                         Assert.IsNotNull (resolved_method);
 468                         Assert.AreEqual ("Method", resolved_method.Name);
 469                         Assert.IsTrue (resolved_method.GetParameters () [0].ParameterType.IsGenericParameter);
 470                 }
 471
 472                 [Test]
 473                 public void ResolveFieldDefWithGenericArguments ()
 474                 {
 475                         var assembly = genAssembly ();
 476                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 477
 478                         var type = module.DefineType ("Foo`1");
 479                         var t = type.DefineGenericParameters ("T") [0];
 480
 481                         var field = type.DefineField ("field", t, FieldAttributes.Public);
 482
 483                         type.CreateType ();
 484
 485                         var resolved_field = (FieldInfo) module.ResolveMember (0x04000001, new [] { typeof (string) }, Type.EmptyTypes);
 486                         Assert.IsNotNull (resolved_field);
 487                         Assert.AreEqual ("field", resolved_field.Name);
 488                         Assert.IsTrue (resolved_field.FieldType.IsGenericParameter);
 489                 }
 490
 491                 [Test]
 492                 public void ResolveTypeDefWithGenericArguments ()
 493                 {
 494                         var assembly = genAssembly ();
 495                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 496
 497                         var type = module.DefineType ("Foo`1");
 498                         var t = type.DefineGenericParameters ("T") [0];
 499
 500                         type.CreateType ();
 501
 502                         var foo = (Type) module.ResolveMember (0x02000002, new [] { typeof (string) }, Type.EmptyTypes);
 503                         Assert.IsNotNull (foo);
 504                         Assert.AreEqual ("Foo`1", foo.Name);
 505                         Assert.IsTrue (foo.IsGenericTypeDefinition);
 506                 }
 507
 508                 [Test]
 509                 // The token is not guaranteed to be 0x0a000001
 510                 [Category ("NotWorking")]
 511                 public void ResolveFieldMemberRefWithGenericArguments ()
 512                 {
 513                         var assembly = genAssembly ();
 514                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 515
 516                         var type = module.DefineType ("Foo`1");
 517                         var t = type.DefineGenericParameters ("T") [0];
 518
 519                         var field = type.DefineField ("field", t, FieldAttributes.Public);
 520
 521                         var method = type.DefineMethod ("Method", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
 522                         var il = method.GetILGenerator ();
 523
 524                         il.Emit (OpCodes.Ldarg_0);
 525                         il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
 526                         il.Emit (OpCodes.Pop);
 527                         il.Emit (OpCodes.Ret);
 528
 529                         type.CreateType ();
 530
 531                         var resolved_field = (FieldInfo) module.ResolveMember (0x0a000001, new [] { typeof (string) }, null);
 532                         Assert.IsNotNull (resolved_field);
 533                         Assert.AreEqual ("field", resolved_field.Name);
 534                         Assert.AreEqual (typeof (string), resolved_field.FieldType);
 535                 }
 536
 537                 [Test]
 538                 // The token is not guaranteed to be 0x0a000002
 539                 [Category ("NotWorking")]
 540                 public void ResolveMethodMemberRefWithGenericArguments ()
 541                 {
 542                         var assembly = genAssembly ();
 543                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 544
 545                         var type = module.DefineType ("Foo`1");
 546                         var t = type.DefineGenericParameters ("T") [0];
 547
 548                         var field = type.DefineField ("field", t, FieldAttributes.Public);
 549
 550                         var method = type.DefineMethod ("Method", MethodAttributes.Public, typeof (void), new Type [] { t });
 551                         method.GetILGenerator ().Emit (OpCodes.Ret);
 552
 553                         var ctor = type.DefineMethod ("Caller", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
 554                         var il = ctor.GetILGenerator ();
 555
 556                         il.Emit (OpCodes.Ldarg_0);
 557                         il.Emit (OpCodes.Ldarg_0);
 558                         il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
 559                         il.Emit (OpCodes.Callvirt, method); // this too
 560                         il.Emit (OpCodes.Ret);
 561
 562                         type.DefineDefaultConstructor (MethodAttributes.Public);
 563
 564                         type.CreateType ();
 565
 566                         var resolved_method = (MethodInfo) module.ResolveMember (0x0a000002, new [] { typeof (string) }, null);
 567                         Assert.IsNotNull (resolved_method);
 568                         Assert.AreEqual ("Method", resolved_method.Name);
 569                         Assert.AreEqual (typeof (string), resolved_method.GetParameters () [0].ParameterType);
 570                 }
 571
 572                 [Test]
 573                 // The token is not guaranteed to be 0x2b000001
 574                 [Category("NotWorking")]
 575                 public void ResolveMethodSpecWithGenericArguments ()
 576                 {
 577                         var assembly = genAssembly ();
 578                         var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
 579
 580                         var type = module.DefineType ("Foo`1");
 581                         var t = type.DefineGenericParameters ("T") [0];
 582
 583                         var field = type.DefineField ("field", t, FieldAttributes.Public);
 584
 585                         var method = type.DefineMethod ("Method", MethodAttributes.Public);
 586                         var s = method.DefineGenericParameters ("S") [0];
 587                         method.SetReturnType (typeof (void));
 588                         method.SetParameters (t, s);
 589                         method.GetILGenerator ().Emit (OpCodes.Ret);
 590
 591                         var ctor = type.DefineMethod ("Caller", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
 592                         var il = ctor.GetILGenerator ();
 593
 594                         il.Emit (OpCodes.Ldarg_0);
 595                         il.Emit (OpCodes.Ldarg_0);
 596                         il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
 597                         il.Emit (OpCodes.Ldarg_0);
 598                         il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
 599                         il.Emit (OpCodes.Callvirt, method); // this triggers the creation of a MethodSpec
 600                         il.Emit (OpCodes.Ret);
 601
 602                         type.DefineDefaultConstructor (MethodAttributes.Public);
 603
 604                         type.CreateType ();
 605
 606                         var resolved_method = (MethodInfo) module.ResolveMember (0x2b000001, new [] { typeof (string) }, new [] { typeof (int) });
 607                         Assert.IsNotNull (resolved_method);
 608                         Assert.AreEqual ("Method", resolved_method.Name);
 609                         Assert.AreEqual (typeof (string), resolved_method.GetParameters () [0].ParameterType);
 610                         Assert.AreEqual (typeof (int), resolved_method.GetParameters () [1].ParameterType);
 611                 }
 612
 613                 [Test]
 614                 public void GetTypes ()
 615                 {
 616                         AssemblyBuilder ab = genAssembly ();
 617                         ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
 618
 619                         TypeBuilder tb1 = mb.DefineType("Foo", TypeAttributes.Public);
 620
 621                         Type[] types = mb.GetTypes ();
 622                         Assert.AreEqual (1, types.Length);
 623                         Assert.AreEqual (tb1, types [0]);
 624
 625                         // After the type is created, MS seems to return the created type
 626                         tb1.CreateType ();
 627
 628                         types = mb.GetTypes ();
 629                         Assert.AreEqual (tb1.CreateType (), types [0]);
 630                 }
 631
 632                 [Test] // GetTypeToken (Type)
 633                 [Category ("NotDotNet")] // http://support.microsoft.com/kb/950986
 634                 public void GetTypeToken2_Type_Array ()
 635                 {
 636                         Type type;
 637                         TypeToken typeToken;
 638                         Type resolved_type;
 639
 640                         AssemblyName aname = genAssemblyName ();
 641                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 642                                 aname, AssemblyBuilderAccess.RunAndSave);
 643                         ModuleBuilder mb = ab.DefineDynamicModule ("MyModule");
 644
 645                         type = typeof (object []);
 646                         typeToken = mb.GetTypeToken (type);
 647                         Assert.IsFalse (typeToken == TypeToken.Empty, "#A1");
 648                         resolved_type = mb.ResolveType (typeToken.Token);
 649                         Assert.AreEqual (type, resolved_type, "#A2");
 650
 651                         type = typeof (object).MakeArrayType ();
 652                         typeToken = mb.GetTypeToken (type);
 653                         Assert.IsFalse (typeToken == TypeToken.Empty, "#B1");
 654                         resolved_type = mb.ResolveType (typeToken.Token);
 655                         Assert.AreEqual (type, resolved_type, "#B2");
 656                 }
 657
 658                 [Test] // GetTypeToken (Type)
 659                 public void GetTypeToken2_Type_String ()
 660                 {
 661                         AssemblyName aname = genAssemblyName ();
 662                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 663                                 aname, AssemblyBuilderAccess.RunAndSave);
 664                         ModuleBuilder mb = ab.DefineDynamicModule ("MyModule");
 665                         Type type = typeof (string);
 666                         TypeToken typeToken = mb.GetTypeToken (type);
 667                         Assert.IsFalse (typeToken == TypeToken.Empty, "#1");
 668                         Type resolved_type = mb.ResolveType (typeToken.Token);
 669                         Assert.AreEqual (type, resolved_type, "#2");
 670                 }
 671
 672                 [Test] // bug #471302
 673                 public void ModuleBuilder_ModuleVersionId ()
 674                 {
 675                         var name = new AssemblyName () { Name = "Foo" };
 676                         var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly (
 677                                 name, AssemblyBuilderAccess.Run);
 678
 679                         var module = assembly.DefineDynamicModule ("Foo");
 680
 681                         Assert.AreNotEqual (new Guid (), module.ModuleVersionId);
 682                 }
 683
 684                 [Test]
 685                 public void GetType_String_Null ()
 686                 {
 687                         AssemblyName an = genAssemblyName ();
 688                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
 689                         ModuleBuilder module = ab.DefineDynamicModule ("GetTypeNullCheck");
 690
 691                         try {
 692                                 module.GetType (null);
 693                                 Assert.Fail ("Expected ArgumentNullException for GetType(string)");
 694                         }
 695                         catch (ArgumentNullException) {
 696                         }
 697                         try {
 698                                 module.GetType (null, true); // ignoreCase
 699                                 Assert.Fail ("Expected ArgumentNullException for GetType(string,bool)");
 700                         }
 701                         catch (ArgumentNullException) {
 702                         }
 703                         try {
 704                                 module.GetType (null, true, true); // throwOnError, ignoreCase
 705                                 Assert.Fail ("Expected ArgumentNullException for GetType(string,bool,bool)");
 706                         }
 707                         catch (ArgumentNullException) {
 708                         }
 709                 }
 710
 711                 [Test]
 712                 public void GetType_String_Empty ()
 713                 {
 714                         AssemblyName an = genAssemblyName ();
 715                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
 716                         ModuleBuilder module = ab.DefineDynamicModule ("GetTypeEmptyCheck");
 717
 718                         try {
 719                                 module.GetType (String.Empty);
 720                                 Assert.Fail ("Expected ArgumentNullException for GetType(string)");
 721                         }
 722                         catch (ArgumentException) {
 723                         }
 724                         try {
 725                                 module.GetType (String.Empty, true); // ignoreCase
 726                                 Assert.Fail ("Expected ArgumentNullException for GetType(string,bool)");
 727                         }
 728                         catch (ArgumentException) {
 729                         }
 730                         try {
 731                                 module.GetType (String.Empty, true, true); // throwOnError, ignoreCase
 732                                 Assert.Fail ("Expected ArgumentNullException for GetType(string,bool,bool)");
 733                         }
 734                         catch (ArgumentException) {
 735                         }
 736                 }
 737
 738                 [Test]
 739                 public void GetType_Escaped_Chars ()
 740                 {
 741                         AssemblyName an = genAssemblyName ();
 742                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
 743                         ModuleBuilder module = ab.DefineDynamicModule ("mod");
 744
 745                         var tb = module.DefineType ("NameSpace,+*&[]\\.Type,+*&[]\\",
 746                                                     TypeAttributes.Class | TypeAttributes.Public);
 747
 748                         var nestedTb = tb.DefineNestedType ("Nested,+*&[]\\",
 749                                                             TypeAttributes.Class | TypeAttributes.NestedPublic);
 750
 751                         var escapedOuterName =
 752                                 "NameSpace\\,\\+\\*\\&\\[\\]\\\\"
 753                                 + "."
 754                                 + "Type\\,\\+\\*\\&\\[\\]\\\\";
 755
 756                         var escapedNestedName =
 757                                 escapedOuterName
 758                                 + "+"
 759                                 + "Nested\\,\\+\\*\\&\\[\\]\\\\";
 760
 761                         Assert.AreEqual (escapedOuterName, tb.FullName);
 762                         Assert.AreEqual (escapedNestedName, nestedTb.FullName);
 763
 764                         Type outerCreatedTy = tb.CreateType ();
 765                         Type nestedCreatedTy = nestedTb.CreateType ();
 766                         Type outerTy = module.GetType (escapedOuterName);
 767                         Type nestedTy = module.GetType (escapedNestedName);
 768
 769                         Assert.IsNotNull (outerTy, "A");
 770                         Assert.IsNotNull (nestedTy, "B");
 771                         Assert.AreEqual (escapedNestedName, nestedTy.FullName);
 772
 773
 774                         Assert.AreEqual (nestedCreatedTy, nestedTy);
 775
 776                 }
 777
 778                 [Test]
 779                 public void GetMethodTokenNullParam ()
 780                 {
 781                         AssemblyName an = genAssemblyName ();
 782                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
 783                         ModuleBuilder module = ab.DefineDynamicModule ("mod");
 784
 785                         var method = typeof (object).GetMethod ("GetType");
 786
 787                         // ArgumentNullException should not occur.
 788                         module.GetMethodToken (method, null);
 789                 }
 790
 791                 [Test]
 792                 public void GetConstructorTokenNullParam ()
 793                 {
 794                         AssemblyName an = genAssemblyName ();
 795                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
 796                         ModuleBuilder module = ab.DefineDynamicModule ("mod");
 797
 798                         var method = typeof (object).GetConstructor (Type.EmptyTypes);
 799
 800                         // ArgumentNullException should not occur.
 801                         module.GetConstructorToken (method, null);
 802                 }
 803
 804                 [Test]
 805                 public void GetType ()
 806                 {
 807                         AssemblyBuilder ab = genAssembly ();
 808                         ModuleBuilder module = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
 809                         TypeBuilder tb = module.DefineType ("t1", TypeAttributes.Public);
 810
 811                         Assert.AreEqual ("t1[]", module.GetType ("t1[]").FullName);
 812                         Assert.AreEqual ("t1*", module.GetType ("t1*").FullName);
 813                         Assert.AreEqual ("t1&", module.GetType ("t1&").FullName);
 814                         Assert.AreEqual ("t1[]&", module.GetType ("t1[]&").FullName);
 815                 }
 816         }
 817 }