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

   1 //
   2 // AssemblyBuilderTest.cs - NUnit Test Cases for the AssemblyBuilder class
   3 //
   4 // Zoltan Varga (vargaz@freemail.hu)
   5 // Andres G. Aragoneses (andres@7digital.com)
   6 //
   7 // (C) Ximian, Inc.  http://www.ximian.com
   8 // (C) 7digital Media, Ltd. http://www.7digital.com
   9 //
  10 //
  11
  12
  13 using System;
  14 using System.Globalization;
  15 using System.Threading;
  16 using System.Reflection;
  17 using System.Reflection.Emit;
  18 using System.IO;
  19 using System.Configuration.Assemblies;
  20
  21 using NUnit.Framework;
  22
  23 namespace MonoTests.System.Reflection.Emit
  24 {
  25
  26 [TestFixture]
  27 public class AssemblyBuilderTest
  28 {
  29         [AttributeUsage (AttributeTargets.Assembly)]
  30         public sealed class FooAttribute : Attribute
  31         {
  32                 public FooAttribute (string arg)
  33                 {
  34                 }
  35
  36                 public FooAttribute ()
  37                 {
  38                 }
  39         }
  40
  41         static int nameIndex = 0;
  42         static AppDomain domain;
  43         static AssemblyBuilder ab;
  44         static ModuleBuilder mb;
  45         string tempDir = Path.Combine (Path.GetTempPath (), typeof (AssemblyBuilderTest).FullName);
  46
  47         [SetUp]
  48         protected void SetUp ()
  49         {
  50                 if (Directory.Exists (tempDir))
  51                         Directory.Delete (tempDir, true);
  52
  53                 Directory.CreateDirectory (tempDir);
  54
  55                 for (int i = 1; i < 3; ++i) {
  56                         string resFile = Path.Combine (tempDir, "res" + i + ".txt");
  57                         using (StreamWriter sw = new StreamWriter (resFile)) {
  58                                 sw.WriteLine ("FOO");
  59                         }
  60                 }
  61
  62                 domain = Thread.GetDomain ();
  63                 ab = genAssembly ();
  64                 mb = ab.DefineDynamicModule ("def_module");
  65         }
  66
  67         [TearDown]
  68         protected void TearDown ()
  69         {
  70                 if (Directory.Exists (tempDir))
  71                         Directory.Delete (tempDir, true);
  72         }
  73
  74         private AssemblyName genAssemblyName ()
  75         {
  76                 AssemblyName assemblyName = new AssemblyName();
  77                 assemblyName.Name = typeof (AssemblyBuilderTest).FullName + (nameIndex ++);
  78                 return assemblyName;
  79         }
  80
  81         private AssemblyBuilder genAssembly (AssemblyBuilderAccess access)
  82         {
  83                 return domain.DefineDynamicAssembly (genAssemblyName (),
  84                                                      access,
  85                                                      tempDir);
  86         }
  87         private AssemblyBuilder genAssembly ()
  88         {
  89                 return genAssembly (AssemblyBuilderAccess.RunAndSave);
  90         }
  91
  92         private MethodInfo genEntryFunction (AssemblyBuilder assembly)
  93         {
  94                 ModuleBuilder module = assembly.DefineDynamicModule("module1");
  95                 TypeBuilder tb = module.DefineType ("A");
  96                 MethodBuilder mb = tb.DefineMethod ("A",
  97                         MethodAttributes.Static, typeof (void), new Type [0]);
  98                 mb.GetILGenerator ().Emit (OpCodes.Ret);
  99                 return mb;
 100         }
 101
 102         [Test]
 103         [Category ("NotWorking")]
 104         public void ManifestModule ()
 105         {
 106                 AssemblyName aname = new AssemblyName ("ManifestModule1");
 107                 ab = domain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.RunAndSave,
 108                         tempDir);
 109                 Assert.IsNotNull (ab.ManifestModule, "#A1");
 110                 Assert.AreEqual (1, ab.GetModules ().Length, "#A2");
 111                 Assert.AreEqual (typeof (ModuleBuilder), ab.ManifestModule.GetType (), "#A3");
 112
 113                 ModuleBuilder mb1 = (ModuleBuilder) ab.ManifestModule;
 114                 Assert.AreSame (mb1, ab.GetModules () [0], "#B1");
 115                 Assert.IsFalse (mb1.IsResource (), "#B2");
 116                 Assert.AreSame (mb1, ab.ManifestModule, "#B3");
 117
 118                 ab.Save ("ManifestModule.dll");
 119
 120                 ModuleBuilder mb2 = (ModuleBuilder) ab.ManifestModule;
 121                 Assert.AreSame (mb2, ab.GetModules () [0], "#C1");
 122                 Assert.IsFalse (mb2.IsResource (), "#C2");
 123                 Assert.AreSame (mb2, ab.ManifestModule, "#C3");
 124                 Assert.AreSame (mb1, mb2, "#C4");
 125         }
 126
 127         [Test]
 128         [ExpectedException (typeof (NotSupportedException))]
 129         public void TestCodeBase ()
 130         {
 131                 string codebase = ab.CodeBase;
 132         }
 133
 134         [Test]
 135         [ExpectedException (typeof (NotSupportedException))]
 136         public void TestLocation ()
 137         {
 138                 string location = ab.Location;
 139         }
 140
 141         [Test]
 142         public void TestEntryPoint ()
 143         {
 144                 Assert.AreEqual (null, ab.EntryPoint, "EntryPoint defaults to null");
 145
 146                 MethodInfo mi = genEntryFunction (ab);
 147                 ab.SetEntryPoint (mi);
 148
 149                 Assert.AreEqual (mi, ab.EntryPoint, "EntryPoint works");
 150         }
 151
 152         [Test]
 153         public void TestSetEntryPoint ()
 154         {
 155                 // Check invalid arguments
 156                 try {
 157                         ab.SetEntryPoint (null);
 158                         Assert.Fail ("#A1");
 159                 } catch (ArgumentNullException ex) {
 160                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 161                         Assert.IsNull (ex.InnerException, "#A3");
 162                         Assert.IsNotNull (ex.Message, "#A4");
 163                         Assert.IsNotNull (ex.ParamName, "#A5");
 164                         Assert.AreEqual ("entryMethod", ex.ParamName, "#A6");
 165                 }
 166
 167                 // Check method from other assembly
 168                 try {
 169                         ab.SetEntryPoint (typeof (AssemblyBuilderTest).GetMethod ("TestSetEntryPoint"));
 170                         Assert.Fail ("#B");
 171                 } catch (InvalidOperationException) {
 172                 }
 173         }
 174
 175         [Test]
 176         public void TestIsDefined ()
 177         {
 178                 CustomAttributeBuilder cab = new CustomAttributeBuilder (typeof (FooAttribute).GetConstructor (new Type [1] {typeof (string)}), new object [1] { "A" });
 179                 ab.SetCustomAttribute (cab);
 180
 181                 Assert.IsTrue (ab.IsDefined (typeof (FooAttribute), false),
 182                         "IsDefined(FooAttribute) works");
 183                 Assert.IsFalse (ab.IsDefined (typeof (AssemblyVersionAttribute), false),
 184                         "!IsDefined(AssemblyVersionAttribute) works");
 185         }
 186
 187         [Test]
 188         [ExpectedException (typeof (NotSupportedException))]
 189         public void TestGetManifestResourceNames ()
 190         {
 191                 ab.GetManifestResourceNames ();
 192         }
 193
 194         [Test]
 195         [ExpectedException (typeof (NotSupportedException))]
 196         public void TestGetManifestResourceInfo ()
 197         {
 198                 ab.GetManifestResourceInfo ("foo");
 199         }
 200
 201         [Test]
 202         [ExpectedException (typeof (NotSupportedException))]
 203         public void TestGetManifestResourceStream1 ()
 204         {
 205                 ab.GetManifestResourceStream ("foo");
 206         }
 207
 208         [Test]
 209         [ExpectedException (typeof (NotSupportedException))]
 210         public void TestGetManifestResourceStream2 ()
 211         {
 212                 ab.GetManifestResourceStream (typeof (int), "foo");
 213         }
 214
 215         [Test]
 216         [ExpectedException (typeof (NotSupportedException))]
 217         public void TestGetFiles1 ()
 218         {
 219                 ab.GetFiles ();
 220         }
 221
 222         [Test]
 223         [ExpectedException (typeof (NotSupportedException))]
 224         public void TestGetFiles2 ()
 225         {
 226                 ab.GetFiles (true);
 227         }
 228
 229         [Test]
 230         [ExpectedException (typeof (NotSupportedException))]
 231         public void TestGetFile ()
 232         {
 233                 ab.GetFile ("foo");
 234         }
 235
 236         [Test]
 237         [ExpectedException (typeof (NotSupportedException))]
 238         public void TestGetExportedTypes ()
 239         {
 240                 ab.GetExportedTypes ();
 241         }
 242
 243         [Test]
 244         public void TestGetDynamicModule_Name_Null ()
 245         {
 246                 try {
 247                         ab.GetDynamicModule (null);
 248                         Assert.Fail ("#1");
 249                 } catch (ArgumentNullException ex) {
 250                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 251                         Assert.IsNull (ex.InnerException, "#3");
 252                         Assert.IsNotNull (ex.Message, "#4");
 253                         Assert.IsNotNull (ex.ParamName, "#5");
 254                         Assert.AreEqual ("name", ex.ParamName, "#6");
 255                 }
 256         }
 257
 258         [Test]
 259         public void TestGetDynamicModule_Name_Empty ()
 260         {
 261                 try {
 262                         ab.GetDynamicModule (string.Empty);
 263                         Assert.Fail ("#1");
 264                 } catch (ArgumentException ex) {
 265                         // Empty name is not legal
 266                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 267                         Assert.IsNull (ex.InnerException, "#3");
 268                         Assert.IsNotNull (ex.Message, "#4");
 269                         Assert.IsNotNull (ex.ParamName, "#5");
 270                         Assert.AreEqual ("name", ex.ParamName, "#6");
 271                 }
 272         }
 273
 274         [Test]
 275         public void TestGetDynamicModule3 ()
 276         {
 277                 Assert.IsNull (ab.GetDynamicModule ("FOO2"));
 278                 ModuleBuilder mb = ab.DefineDynamicModule ("FOO");
 279                 Assert.AreEqual (mb, ab.GetDynamicModule ("FOO"));
 280                 Assert.IsNull (ab.GetDynamicModule ("FOO4"));
 281         }
 282
 283         [Test]
 284         public void TestImageRuntimeVersion ()
 285         {
 286                 string version = ab.ImageRuntimeVersion;
 287                 Assert.IsTrue (version.Length > 0);
 288         }
 289
 290         [Test]
 291         public void TestAddResourceFile_Name_Null ()
 292         {
 293                 try {
 294                         ab.AddResourceFile (null, "foo.txt");
 295                         Assert.Fail ("#1");
 296                 } catch (ArgumentNullException ex) {
 297                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 298                         Assert.IsNull (ex.InnerException, "#3");
 299                         Assert.IsNotNull (ex.Message, "#4");
 300                         Assert.IsNotNull (ex.ParamName, "#5");
 301                         Assert.AreEqual ("name", ex.ParamName, "#6");
 302                 }
 303         }
 304
 305         [Test]
 306         public void TestAddResourceFile_Filename_Null ()
 307         {
 308                 try {
 309                         ab.AddResourceFile ("foo", null);
 310                         Assert.Fail ("#1");
 311                 } catch (ArgumentNullException ex) {
 312                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 313                         Assert.IsNull (ex.InnerException, "#3");
 314                         Assert.IsNotNull (ex.Message, "#4");
 315                         Assert.IsNotNull (ex.ParamName, "#5");
 316                         Assert.AreEqual ("fileName", ex.ParamName, "#6");
 317                 }
 318         }
 319
 320         [Test]
 321         public void TestAddResourceFile_Name_Empty ()
 322         {
 323                 try {
 324                         ab.AddResourceFile (string.Empty, "foo.txt");
 325                         Assert.Fail ("#1");
 326                 } catch (ArgumentException ex) {
 327                         // Empty name is not legal
 328                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 329                         Assert.IsNull (ex.InnerException, "#3");
 330                         Assert.IsNotNull (ex.Message, "#4");
 331                 }
 332         }
 333
 334         [Test]
 335         public void TestAddResourceFile_Filename_Empty ()
 336         {
 337                 try {
 338                         ab.AddResourceFile ("foo", string.Empty);
 339                         Assert.Fail ("#1");
 340                 } catch (ArgumentException ex) {
 341                         // Empty file name is not legal
 342                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 343                         Assert.IsNull (ex.InnerException, "#3");
 344                         Assert.IsNotNull (ex.Message, "#4");
 345                 }
 346         }
 347
 348         [Test]
 349         [ExpectedException (typeof (FileNotFoundException))]
 350         public void TestAddResourceFile_FileName_DoesNotExist ()
 351         {
 352                 ab.AddResourceFile ("foo", "not-existent.txt");
 353         }
 354
 355         [Test]
 356         public void TestAddResourceFile_FileName_Duplicate ()
 357         {
 358                 ab.AddResourceFile ("foo", "res1.txt");
 359                 try {
 360                         ab.AddResourceFile ("foo2", "res1.txt");
 361                         Assert.Fail ("#1");
 362                 } catch (ArgumentException ex) {
 363                         // Duplicate file names
 364                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 365                         Assert.IsNull (ex.InnerException, "#3");
 366                         Assert.IsNotNull (ex.Message, "#4");
 367                         Assert.IsNull (ex.ParamName, "#5");
 368                 }
 369         }
 370
 371         [Test]
 372         public void TestAddResourceFile_Name_Duplicate ()
 373         {
 374                 ab.AddResourceFile ("foo", "res1.txt");
 375                 try {
 376                         ab.AddResourceFile ("foo", "res2.txt");
 377                         Assert.Fail ("#1");
 378                 } catch (ArgumentException ex) {
 379                         // Duplicate resource name within an assembly
 380                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 381                         Assert.IsNull (ex.InnerException, "#3");
 382                         Assert.IsNotNull (ex.Message, "#4");
 383                         Assert.IsNull (ex.ParamName, "#5");
 384                 }
 385         }
 386
 387         [Test]
 388         public void TestAddResourceFile_Filename_IncludesPath ()
 389         {
 390                 try {
 391                         ab.AddResourceFile ("foo", "/tmp/res1.txt");
 392                         Assert.Fail ("#1");
 393                 } catch (ArgumentException ex) {
 394                         // The filename must not include a path specification
 395                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 396                         Assert.IsNull (ex.InnerException, "#3");
 397                         Assert.IsNotNull (ex.Message, "#4");
 398                         Assert.IsNotNull (ex.ParamName, "#5");
 399                         Assert.AreEqual ("fileName", ex.ParamName, "#6");
 400                 }
 401         }
 402
 403         [Test]
 404         public void TestAddResourceFile ()
 405         {
 406                 ab.AddResourceFile ("foo", "res2.txt", ResourceAttributes.Public);
 407                 ab.Save ("TestAddResourceFile.dll");
 408
 409                 // TODO: Test reading back
 410         }
 411
 412         [Test]
 413         [Category ("AndroidNotWorking")] // DefineResource doesn't allow path in its fileName parameter and the test attempts to write to / in effect
 414         public void TestDefineResource ()
 415         {
 416                 ab.DefineResource ("foo", "FOO", "foo.txt", ResourceAttributes.Public);
 417                 ab.DefineResource ("foo2", "FOO", "foo2.txt");
 418                 ab.Save ("TestDefineResource.dll");
 419         }
 420
 421         [Test]
 422         public void TestDefineDynamicModule_Name_Null ()
 423         {
 424                 try {
 425                         ab.DefineDynamicModule (null, "foo.txt");
 426                         Assert.Fail ("#1");
 427                 } catch (ArgumentNullException ex) {
 428                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 429                         Assert.IsNull (ex.InnerException, "#3");
 430                         Assert.IsNotNull (ex.Message, "#4");
 431                         Assert.IsNotNull (ex.ParamName, "#5");
 432                         Assert.AreEqual ("name", ex.ParamName, "#6");
 433                 }
 434         }
 435
 436         [Test]
 437         public void TestDefineDynamicModule_FileName_Null ()
 438         {
 439                 try {
 440                         ab.DefineDynamicModule ("foo", null);
 441                         Assert.Fail ("#1");
 442                 } catch (ArgumentNullException ex) {
 443                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 444                         Assert.IsNull (ex.InnerException, "#3");
 445                         Assert.IsNotNull (ex.Message, "#4");
 446                         Assert.IsNotNull (ex.ParamName, "#5");
 447                         Assert.AreEqual ("fileName", ex.ParamName, "#6");
 448                 }
 449         }
 450
 451         [Test]
 452         public void TestDefineDynamicModule_Name_Empty ()
 453         {
 454                 try {
 455                         ab.DefineDynamicModule (string.Empty, "foo.txt");
 456                         Assert.Fail ("#1");
 457                 } catch (ArgumentException ex) {
 458                         // Empty name is not legal
 459                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 460                         Assert.IsNull (ex.InnerException, "#3");
 461                         Assert.IsNotNull (ex.Message, "#4");
 462                         Assert.IsNotNull (ex.ParamName, "#5");
 463                         Assert.AreEqual ("name", ex.ParamName, "#6");
 464                 }
 465         }
 466
 467         [Test]
 468         public void TestDefineDynamicModule_Filename_Empty ()
 469         {
 470                 try {
 471                         ab.DefineDynamicModule ("foo", string.Empty);
 472                         Assert.Fail ("#1");
 473                 } catch (ArgumentException ex) {
 474                         // Empty file name is not legal
 475                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 476                         Assert.IsNull (ex.InnerException, "#3");
 477                         Assert.IsNotNull (ex.Message, "#4");
 478                         Assert.IsNotNull (ex.ParamName, "#5");
 479                         Assert.AreEqual ("fileName", ex.ParamName, "#6");
 480                 }
 481         }
 482
 483         [Test]
 484         public void TestDefineDynamicModule_FileName_Duplicate ()
 485         {
 486                 ab.DefineDynamicModule ("foo", "res1.txt");
 487                 try {
 488                         ab.DefineDynamicModule ("foo2", "res1.txt");
 489                         Assert.Fail ("#1");
 490                 } catch (ArgumentException ex) {
 491                         // Duplicate file names
 492                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 493                         Assert.IsNull (ex.InnerException, "#3");
 494                         Assert.IsNotNull (ex.Message, "#4");
 495                         Assert.IsNull (ex.ParamName, "#5");
 496                 }
 497         }
 498
 499         [Test]
 500         public void TestDefineDynamicModule_Name_Duplicate ()
 501         {
 502                 ab.DefineDynamicModule ("foo", "res1.txt");
 503                 try {
 504                         ab.DefineDynamicModule ("foo", "res2.txt");
 505                         Assert.Fail ("#1");
 506                 } catch (ArgumentException ex) {
 507                         // Duplicate dynamic module name within an assembly
 508                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 509                         Assert.IsNull (ex.InnerException, "#3");
 510                         Assert.IsNotNull (ex.Message, "#4");
 511                         Assert.IsNull (ex.ParamName, "#5");
 512                 }
 513         }
 514
 515         [Test]
 516         public void TestDefineDynamicModule_Filename_IncludesPath ()
 517         {
 518                 try {
 519                         ab.DefineDynamicModule ("foo", "/tmp/res1.txt");
 520                         Assert.Fail ("#1");
 521                 } catch (ArgumentException ex) {
 522                         // The filename must not include a path specification
 523                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 524                         Assert.IsNull (ex.InnerException, "#3");
 525                         Assert.IsNotNull (ex.Message, "#4");
 526                         Assert.IsNotNull (ex.ParamName, "#5");
 527                         Assert.AreEqual ("fileName", ex.ParamName, "#6");
 528                 }
 529         }
 530
 531         [Test]
 532         public void TestDefineDynamicModule5_FileName_NoExtension ()
 533         {
 534                 try {
 535                         ab.DefineDynamicModule ("foo", "bar");
 536                         Assert.Fail ("#1");
 537                 } catch (ArgumentException ex) {
 538                         // Module file name 'bar' must have file extension
 539                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 540                         Assert.IsNull (ex.InnerException, "#3");
 541                         Assert.IsNotNull (ex.Message, "#4");
 542                         Assert.IsTrue (ex.Message.IndexOf ("bar") != -1, "#5");
 543                         Assert.IsNull (ex.ParamName, "#6");
 544                 }
 545         }
 546
 547         [Test]
 548         [Category ("NotWorking")]
 549         public void TestDefineDynamicModule_Name_MaxLength () {
 550                 string name = string.Empty;
 551                 for (int i = 0; i < 259; ++i)
 552                         name = name + "A";
 553                 ab.DefineDynamicModule (name);
 554
 555                 name = name + "A";
 556                 try {
 557                         ab.DefineDynamicModule (name);
 558                         Assert.Fail ("#1");
 559                 } catch (ArgumentException ex) {
 560                         // Value does not fall within expected range
 561                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 562                         Assert.IsNull (ex.InnerException, "#3");
 563                         Assert.IsNotNull (ex.Message, "#4");
 564                         Assert.IsNull (ex.ParamName, "#5");
 565                 }
 566         }
 567
 568         [Test]
 569         [ExpectedException (typeof (InvalidOperationException))]
 570         public void TestDefineDynamicModule_Assembly_Saved ()
 571         {
 572                 // Called when assembly was already saved
 573                 ab.Save ("TestDefineDynamicModule7.dll");
 574                 ab.DefineDynamicModule ("foo", "foo.dll");
 575         }
 576
 577         [Test]
 578         [ExpectedException (typeof (NotSupportedException))]
 579         public void TestDefineDynamicModule_Access_Run ()
 580         {
 581                 // Called on an assembly defined with the Run attribute
 582                 AssemblyBuilder ab =
 583                         domain.DefineDynamicAssembly (genAssemblyName (),
 584                                                                                   AssemblyBuilderAccess.Run,
 585                                                                                   tempDir);
 586                 ab.DefineDynamicModule ("foo", "foo.dll");
 587         }
 588
 589         [Test]
 590         [Category ("AndroidNotWorking")] // Missing Mono.Compilerservices.SymbolWriter assembly
 591         public void TestDefineDynamicModule ()
 592         {
 593                 ab.DefineDynamicModule ("foo", "foo.dll");
 594                 ab.DefineDynamicModule ("foo2", true);
 595                 ab.DefineDynamicModule ("foo3", "foo3.dll");
 596                 ab.DefineDynamicModule ("foo4", "foo4.dll", true);
 597         }
 598
 599         [Test] // DefineUnmanagedResource (byte [])
 600         [Category ("NotWorking")]
 601         public void TestDefineUnmanagedResource1_ResourceAlreadyDefined ()
 602         {
 603                 string version_res = Path.Combine (tempDir, "version.res");
 604                 using (FileStream fs = File.OpenWrite (version_res)) {
 605                         fs.WriteByte (0x0a);
 606                 }
 607
 608                 ab.DefineUnmanagedResource (new byte [0]);
 609
 610                 try {
 611                         ab.DefineUnmanagedResource (new byte [0]);
 612                         Assert.Fail ("#A1");
 613                 } catch (ArgumentException ex) {
 614                         // Native resource has already been defined
 615                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 616                         Assert.IsNull (ex.InnerException, "#A3");
 617                         Assert.IsNotNull (ex.Message, "#A4");
 618                         Assert.IsNull (ex.ParamName, "#A5");
 619                 }
 620
 621                 try {
 622                         ab.DefineUnmanagedResource (version_res);
 623                         Assert.Fail ("#B1");
 624                 } catch (ArgumentException ex) {
 625                         // Native resource has already been defined
 626                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 627                         Assert.IsNull (ex.InnerException, "#B3");
 628                         Assert.IsNotNull (ex.Message, "#B4");
 629                         Assert.IsNull (ex.ParamName, "#B5");
 630                 }
 631
 632                 try {
 633                         ab.DefineVersionInfoResource ();
 634                         Assert.Fail ("#C1");
 635                 } catch (ArgumentException ex) {
 636                         // Native resource has already been defined
 637                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 638                         Assert.IsNull (ex.InnerException, "#C3");
 639                         Assert.IsNotNull (ex.Message, "#C4");
 640                         Assert.IsNull (ex.ParamName, "#C5");
 641                 }
 642
 643                 try {
 644                         ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
 645                         Assert.Fail ("#D1");
 646                 } catch (ArgumentException ex) {
 647                         // Native resource has already been defined
 648                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 649                         Assert.IsNull (ex.InnerException, "#D3");
 650                         Assert.IsNotNull (ex.Message, "#D4");
 651                         Assert.IsNull (ex.ParamName, "#D5");
 652                 }
 653         }
 654
 655         [Test] // DefineUnmanagedResource (byte [])
 656         public void TestDefineUnmanagedResource1_Resource_Null ()
 657         {
 658                 try {
 659                         ab.DefineUnmanagedResource ((byte []) null);
 660                         Assert.Fail ("#1");
 661                 } catch (ArgumentNullException ex) {
 662                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 663                         Assert.IsNull (ex.InnerException, "#3");
 664                         Assert.IsNotNull (ex.Message, "#4");
 665                         Assert.IsNotNull (ex.ParamName, "#5");
 666                         Assert.AreEqual ("resource", ex.ParamName, "#6");
 667                 }
 668         }
 669
 670         [Test] // DefineUnmanagedResource (String)
 671         public void TestDefineUnmanagedResource2_ResourceAlreadyDefined ()
 672         {
 673                 string version_res = Path.Combine (tempDir, "version.res");
 674                 using (FileStream fs = File.OpenWrite (version_res)) {
 675                         fs.WriteByte (0x0a);
 676                 }
 677
 678                 ab.DefineUnmanagedResource (version_res);
 679
 680                 try {
 681                         ab.DefineUnmanagedResource (new byte [0]);
 682                         Assert.Fail ("#A1");
 683                 } catch (ArgumentException ex) {
 684                         // Native resource has already been defined
 685                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 686                         Assert.IsNull (ex.InnerException, "#A3");
 687                         Assert.IsNotNull (ex.Message, "#A4");
 688                         Assert.IsNull (ex.ParamName, "#A5");
 689                 }
 690
 691                 try {
 692                         ab.DefineUnmanagedResource (version_res);
 693                         Assert.Fail ("#B1");
 694                 } catch (ArgumentException ex) {
 695                         // Native resource has already been defined
 696                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 697                         Assert.IsNull (ex.InnerException, "#B3");
 698                         Assert.IsNotNull (ex.Message, "#B4");
 699                         Assert.IsNull (ex.ParamName, "#B5");
 700                 }
 701
 702                 try {
 703                         ab.DefineVersionInfoResource ();
 704                         Assert.Fail ("#C1");
 705                 } catch (ArgumentException ex) {
 706                         // Native resource has already been defined
 707                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 708                         Assert.IsNull (ex.InnerException, "#C3");
 709                         Assert.IsNotNull (ex.Message, "#C4");
 710                         Assert.IsNull (ex.ParamName, "#C5");
 711                 }
 712
 713                 try {
 714                         ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
 715                         Assert.Fail ("#D1");
 716                 } catch (ArgumentException ex) {
 717                         // Native resource has already been defined
 718                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 719                         Assert.IsNull (ex.InnerException, "#D3");
 720                         Assert.IsNotNull (ex.Message, "#D4");
 721                         Assert.IsNull (ex.ParamName, "#D5");
 722                 }
 723         }
 724
 725         [Test] // DefinedUnmanagedResource (String)
 726         [ExpectedException (typeof (FileNotFoundException))]
 727         public void TestDefineUnmanagedResource2_ResourceFile_DoesNotExist ()
 728         {
 729                 ab.DefineUnmanagedResource ("not-exists.txt");
 730         }
 731
 732         [Test] // DefinedUnmanagedResource (String)
 733         public void TestDefineUnmanagedResource2_ResourceFileName_Empty ()
 734         {
 735                 try {
 736                         ab.DefineUnmanagedResource (string.Empty);
 737                         Assert.Fail ("#1");
 738                 } catch (ArgumentException ex) {
 739                         // The path is not of a legal form
 740                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 741                         Assert.IsNull (ex.InnerException, "#3");
 742                         Assert.IsNotNull (ex.Message, "#4");
 743                         Assert.IsNull (ex.ParamName, "#5");
 744                 }
 745         }
 746
 747         [Test] // DefinedUnmanagedResource (String)
 748         public void TestDefineUnmanagedResource2_ResourceFileName_Null ()
 749         {
 750                 try {
 751                         ab.DefineUnmanagedResource ((string) null);
 752                         Assert.Fail ("#1");
 753                 } catch (ArgumentNullException ex) {
 754                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 755                         Assert.IsNull (ex.InnerException, "#3");
 756                         Assert.IsNotNull (ex.Message, "#4");
 757                         Assert.IsNotNull (ex.ParamName, "#5");
 758                         Assert.AreEqual ("resourceFileName", ex.ParamName, "#6");
 759                 }
 760         }
 761
 762         [Test] // DefineVersionInfoResource ()
 763         public void TestDefineVersionInfoResource1_Culture_NotSupported ()
 764         {
 765                 AssemblyName aname = new AssemblyName ();
 766                 aname.CultureInfo = new CultureInfo ("nl-BE");
 767                 aname.Name = "lib";
 768                 aname.Version = new Version (3, 5, 7);
 769
 770                 AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 771                         aname, AssemblyBuilderAccess.RunAndSave,
 772                         tempDir);
 773
 774                 // AssemblyCulture
 775                 Type attrType = typeof (AssemblyCultureAttribute);
 776                 ConstructorInfo ci = attrType.GetConstructor (new Type [] { typeof (String) });
 777                 CustomAttributeBuilder cab = new CustomAttributeBuilder (
 778                         ci, new object [1] { "doesnotexist" });
 779                 ab.SetCustomAttribute (cab);
 780
 781                 ab.DefineVersionInfoResource ();
 782
 783                 try {
 784                         ab.Save ("lib.dll");
 785                         Assert.Fail ("#A1");
 786 #if NET_4_0
 787                 } catch (CultureNotFoundException ex) {
 788                 }
 789 #else
 790                 } catch (ArgumentException ex) {
 791                         // Culture name doesnotexist is not supported
 792                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 793                         Assert.IsNull (ex.InnerException, "#A3");
 794                         Assert.IsNotNull (ex.Message, "#A4");
 795                         Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#A5");
 796                         Assert.AreEqual ("name", ex.ParamName, "#A6");
 797                 }
 798 #endif
 799
 800                 ab = AppDomain.CurrentDomain.DefineDynamicAssembly (aname,
 801                         AssemblyBuilderAccess.RunAndSave, tempDir);
 802
 803                 // AssemblyCulture
 804                 attrType = typeof (AssemblyCultureAttribute);
 805                 ci = attrType.GetConstructor (new Type [] { typeof (String) });
 806                 cab = new CustomAttributeBuilder (ci, new object [1] { "neutral" });
 807                 ab.SetCustomAttribute (cab);
 808
 809                 ab.DefineVersionInfoResource ();
 810
 811                 try {
 812                         ab.Save ("lib.dll");
 813                         Assert.Fail ("#B1");
 814 #if NET_4_0
 815                 } catch (CultureNotFoundException ex) {
 816                 }
 817 #else
 818                 } catch (ArgumentException ex) {
 819                         // Culture name neutral is not supported
 820                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 821                         Assert.IsNull (ex.InnerException, "#B3");
 822                         Assert.IsNotNull (ex.Message, "#B4");
 823                         Assert.IsTrue (ex.Message.IndexOf ("neutral") != -1, "#B5");
 824                         Assert.AreEqual ("name", ex.ParamName, "#B6");
 825                 }
 826 #endif
 827         }
 828
 829         [Test] // DefineVersionInfoResource ()
 830         public void TestDefineVersionInfoResource1_ResourceAlreadyDefined ()
 831         {
 832                 string version_res = Path.Combine (tempDir, "version.res");
 833                 using (FileStream fs = File.OpenWrite (version_res)) {
 834                         fs.WriteByte (0x0a);
 835                 }
 836
 837                 ab.DefineVersionInfoResource ();
 838
 839                 try {
 840                         ab.DefineUnmanagedResource (new byte [0]);
 841                         Assert.Fail ("#A1");
 842                 } catch (ArgumentException ex) {
 843                         // Native resource has already been defined
 844                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 845                         Assert.IsNull (ex.InnerException, "#A3");
 846                         Assert.IsNotNull (ex.Message, "#A4");
 847                         Assert.IsNull (ex.ParamName, "#A5");
 848                 }
 849
 850                 try {
 851                         ab.DefineUnmanagedResource (version_res);
 852                         Assert.Fail ("#B1");
 853                 } catch (ArgumentException ex) {
 854                         // Native resource has already been defined
 855                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 856                         Assert.IsNull (ex.InnerException, "#B3");
 857                         Assert.IsNotNull (ex.Message, "#B4");
 858                         Assert.IsNull (ex.ParamName, "#B5");
 859                 }
 860
 861                 try {
 862                         ab.DefineVersionInfoResource ();
 863                         Assert.Fail ("#C1");
 864                 } catch (ArgumentException ex) {
 865                         // Native resource has already been defined
 866                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 867                         Assert.IsNull (ex.InnerException, "#C3");
 868                         Assert.IsNotNull (ex.Message, "#C4");
 869                         Assert.IsNull (ex.ParamName, "#C5");
 870                 }
 871
 872                 try {
 873                         ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
 874                         Assert.Fail ("#D1");
 875                 } catch (ArgumentException ex) {
 876                         // Native resource has already been defined
 877                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 878                         Assert.IsNull (ex.InnerException, "#D3");
 879                         Assert.IsNotNull (ex.Message, "#D4");
 880                         Assert.IsNull (ex.ParamName, "#D5");
 881                 }
 882         }
 883
 884         [Test] // DefineVersionInfoResource (String, String, String, String, String)
 885         public void TestDefineVersionInfoResource2_Culture_NotSupported ()
 886         {
 887                 AssemblyName aname = new AssemblyName ();
 888                 aname.CultureInfo = new CultureInfo ("nl-BE");
 889                 aname.Name = "lib";
 890                 aname.Version = new Version (3, 5, 7);
 891
 892                 AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 893                         aname, AssemblyBuilderAccess.RunAndSave,
 894                         tempDir);
 895
 896                 // AssemblyCulture
 897                 Type attrType = typeof (AssemblyCultureAttribute);
 898                 ConstructorInfo ci = attrType.GetConstructor (new Type [] { typeof (String) });
 899                 CustomAttributeBuilder cab = new CustomAttributeBuilder (
 900                         ci, new object [1] { "doesnotexist" });
 901                 ab.SetCustomAttribute (cab);
 902
 903                 ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
 904
 905                 try {
 906                         ab.Save ("lib.dll");
 907                         Assert.Fail ("#A1");
 908 #if NET_4_0
 909                 } catch (CultureNotFoundException ex) {
 910                 }
 911 #else
 912                 } catch (ArgumentException ex) {
 913                         // Culture name doesnotexist is not supported
 914                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 915                         Assert.IsNull (ex.InnerException, "#A3");
 916                         Assert.IsNotNull (ex.Message, "#A4");
 917                         Assert.IsTrue (ex.Message.IndexOf ("doesnotexist") != -1, "#A5");
 918                         Assert.AreEqual ("name", ex.ParamName, "#A6");
 919                 }
 920 #endif
 921
 922                 ab = AppDomain.CurrentDomain.DefineDynamicAssembly (aname,
 923                         AssemblyBuilderAccess.RunAndSave, tempDir);
 924
 925                 // AssemblyCulture
 926                 attrType = typeof (AssemblyCultureAttribute);
 927                 ci = attrType.GetConstructor (new Type [] { typeof (String) });
 928                 cab = new CustomAttributeBuilder (ci, new object [1] { "neutral" });
 929                 ab.SetCustomAttribute (cab);
 930
 931                 ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
 932
 933                 try {
 934                         ab.Save ("lib.dll");
 935                         Assert.Fail ("#B1");
 936 #if NET_4_0
 937                 } catch (CultureNotFoundException ex) {
 938                 }
 939 #else
 940                 } catch (ArgumentException ex) {
 941                         // Culture name neutral is not supported
 942                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 943                         Assert.IsNull (ex.InnerException, "#B3");
 944                         Assert.IsNotNull (ex.Message, "#B4");
 945                         Assert.IsTrue (ex.Message.IndexOf ("neutral") != -1, "#B5");
 946                         Assert.AreEqual ("name", ex.ParamName, "#B6");
 947                 }
 948 #endif
 949         }
 950
 951         [Test] // DefineVersionInfoResource (String, String, String, String, String)
 952         public void TestDefineVersionInfoResource2_ResourceAlreadyDefined ()
 953         {
 954                 string version_res = Path.Combine (tempDir, "version.res");
 955                 using (FileStream fs = File.OpenWrite (version_res)) {
 956                         fs.WriteByte (0x0a);
 957                 }
 958
 959                 ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
 960
 961                 try {
 962                         ab.DefineUnmanagedResource (new byte [0]);
 963                         Assert.Fail ("#A1");
 964                 } catch (ArgumentException ex) {
 965                         // Native resource has already been defined
 966                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 967                         Assert.IsNull (ex.InnerException, "#A3");
 968                         Assert.IsNotNull (ex.Message, "#A4");
 969                         Assert.IsNull (ex.ParamName, "#A5");
 970                 }
 971
 972                 try {
 973                         ab.DefineUnmanagedResource (version_res);
 974                         Assert.Fail ("#B1");
 975                 } catch (ArgumentException ex) {
 976                         // Native resource has already been defined
 977                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 978                         Assert.IsNull (ex.InnerException, "#B3");
 979                         Assert.IsNotNull (ex.Message, "#B4");
 980                         Assert.IsNull (ex.ParamName, "#B5");
 981                 }
 982
 983                 try {
 984                         ab.DefineVersionInfoResource ();
 985                         Assert.Fail ("#C1");
 986                 } catch (ArgumentException ex) {
 987                         // Native resource has already been defined
 988                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 989                         Assert.IsNull (ex.InnerException, "#C3");
 990                         Assert.IsNotNull (ex.Message, "#C4");
 991                         Assert.IsNull (ex.ParamName, "#C5");
 992                 }
 993
 994                 try {
 995                         ab.DefineVersionInfoResource ("A", "1.0", "C", "D", "E");
 996                         Assert.Fail ("#D1");
 997                 } catch (ArgumentException ex) {
 998                         // Native resource has already been defined
 999                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
1000                         Assert.IsNull (ex.InnerException, "#D3");
1001                         Assert.IsNotNull (ex.Message, "#D4");
1002                         Assert.IsNull (ex.ParamName, "#D5");
1003                 }
1004         }
1005
1006         [Test]
1007         public void TestSetCustomAttribute1_CustomBuilder_Null ()
1008         {
1009                 try {
1010                         ab.SetCustomAttribute (null);
1011                         Assert.Fail ("#1");
1012                 } catch (ArgumentNullException ex) {
1013                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1014                         Assert.IsNull (ex.InnerException, "#3");
1015                         Assert.IsNotNull (ex.Message, "#4");
1016                         Assert.IsNotNull (ex.ParamName, "#5");
1017                         Assert.AreEqual ("customBuilder", ex.ParamName, "#6");
1018                 }
1019         }
1020
1021         [Test]
1022         public void TestSetCustomAttribute2_ConstructorInfo_Null ()
1023         {
1024                 try {
1025                         ab.SetCustomAttribute (null, new byte [0]);
1026                         Assert.Fail ("#1");
1027                 } catch (ArgumentNullException ex) {
1028                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1029                         Assert.IsNull (ex.InnerException, "#3");
1030                         Assert.IsNotNull (ex.Message, "#4");
1031                         Assert.IsNotNull (ex.ParamName, "#5");
1032                         Assert.AreEqual ("con", ex.ParamName, "#6");
1033                 }
1034         }
1035
1036         [Test]
1037         public void TestSetCustomAttribute2_BinaryAttribute_Null ()
1038         {
1039                 try {
1040                         ab.SetCustomAttribute (typeof (AssemblyCompanyAttribute).GetConstructor (
1041                                 new Type [] { typeof (String) }), null);
1042                         Assert.Fail ("#1");
1043                 } catch (ArgumentNullException ex) {
1044                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1045                         Assert.IsNull (ex.InnerException, "#3");
1046                         Assert.IsNotNull (ex.Message, "#4");
1047                         Assert.IsNotNull (ex.ParamName, "#5");
1048                         Assert.AreEqual ("binaryAttribute", ex.ParamName, "#6");
1049                 }
1050         }
1051
1052         [Test] // SetCustomAttribute (CustomAttributeBuilder)
1053         public void TestSetCustomAttribute1 ()
1054         {
1055                 Assembly a;
1056                 AssemblyName an;
1057                 AssemblyName check;
1058                 Attribute attr;
1059                 string filename;
1060
1061                 an = new AssemblyName ();
1062                 an.Name = "TestSetCustomAttributeA";
1063
1064                 ab = domain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Save, tempDir);
1065                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyVersionAttribute).
1066                         GetConstructor (new Type [] { typeof (string) }), new object [] { "1.2.3.4"}));
1067                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyCultureAttribute).
1068                         GetConstructor (new Type [] { typeof (string) }), new object [] { "bar"}));
1069                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyAlgorithmIdAttribute).
1070                         GetConstructor (new Type [] { typeof (AssemblyHashAlgorithm) }),
1071                         new object [] { AssemblyHashAlgorithm.MD5 }));
1072                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyFlagsAttribute).
1073                         GetConstructor (new Type [] { typeof (uint) }), new object [] { (uint)0xff }));
1074                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyDelaySignAttribute).
1075                         GetConstructor (new Type [] { typeof (bool) }), new object [] { true }));
1076                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (FooAttribute).
1077                         GetConstructor (Type.EmptyTypes), new object [0]));
1078                 ab.Save ("TestSetCustomAttributeA.dll");
1079
1080                 filename = Path.Combine (tempDir, "TestSetCustomAttributeA.dll");
1081                 check = AssemblyName.GetAssemblyName (filename);
1082                 Assert.AreEqual (CultureInfo.InvariantCulture, check.CultureInfo, "#A1");
1083                 Assert.AreEqual (AssemblyNameFlags.None, check.Flags, "#A2");
1084                 Assert.AreEqual ("TestSetCustomAttributeA, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", check.FullName, "#A3");
1085                 Assert.IsNull (check.GetPublicKey (), "#A4");
1086                 Assert.AreEqual (new byte [0], check.GetPublicKeyToken (), "#A5");
1087                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1, check.HashAlgorithm, "#A6");
1088                 Assert.IsNull (check.KeyPair, "#A7");
1089                 Assert.AreEqual ("TestSetCustomAttributeA", check.Name, "#A8");
1090                 //Assert.AreEqual (ProcessorArchitecture.MSIL, check.ProcessorArchitecture, "#A9");
1091                 Assert.AreEqual (new Version (0, 0, 0, 0), check.Version, "#A10");
1092                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, check.VersionCompatibility, "#A11");
1093
1094                 using (FileStream fs = File.OpenRead (filename)) {
1095                         byte [] buffer = new byte [fs.Length];
1096                         fs.Read (buffer, 0, buffer.Length);
1097                         a = Assembly.Load (buffer);
1098                 }
1099
1100                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyVersionAttribute));
1101                 Assert.IsNotNull (attr, "#A12a");
1102                 Assert.AreEqual ("1.2.3.4", ((AssemblyVersionAttribute) attr).Version, "#A12b");
1103                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyCultureAttribute));
1104                 Assert.IsNotNull (attr, "#A13a");
1105                 Assert.AreEqual ("bar", ((AssemblyCultureAttribute) attr).Culture, "#A13b");
1106                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyAlgorithmIdAttribute));
1107                 Assert.IsNotNull (attr, "#A14a");
1108                 Assert.AreEqual ((uint) AssemblyHashAlgorithm.MD5, ((AssemblyAlgorithmIdAttribute) attr).AlgorithmId, "#A14b");
1109                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyFlagsAttribute));
1110                 Assert.IsNotNull (attr, "#A15a");
1111                 Assert.AreEqual ((uint) 0xff, ((AssemblyFlagsAttribute) attr).Flags, "#A15b");
1112                 attr = Attribute.GetCustomAttribute (a, typeof (FooAttribute));
1113                 Assert.IsNotNull (attr, "#A16");
1114
1115                 an = new AssemblyName ();
1116                 an.CultureInfo = new CultureInfo ("nl-BE");
1117                 an.Flags = AssemblyNameFlags.Retargetable;
1118                 an.Name = "TestSetCustomAttributeB";
1119                 an.ProcessorArchitecture = ProcessorArchitecture.IA64;
1120                 an.Version = new Version (1, 3, 5, 7);
1121                 an.VersionCompatibility = AssemblyVersionCompatibility.SameDomain;
1122
1123                 ab = domain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Save, tempDir);
1124                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyVersionAttribute).
1125                         GetConstructor (new Type [] { typeof (string) }), new object [] { "1.2.3.4" }));
1126                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyCultureAttribute).
1127                         GetConstructor (new Type [] { typeof (string) }), new object [] { "en-US" }));
1128                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyAlgorithmIdAttribute).
1129                         GetConstructor (new Type [] { typeof (AssemblyHashAlgorithm) }),
1130                         new object [] { AssemblyHashAlgorithm.MD5 }));
1131                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyFlagsAttribute).
1132                         GetConstructor (new Type [] { typeof (uint) }), new object [] { (uint) 0x0100 }));
1133                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyDelaySignAttribute).
1134                         GetConstructor (new Type [] { typeof (bool) }), new object [] { true }));
1135                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (FooAttribute).
1136                         GetConstructor (Type.EmptyTypes), new object [0]));
1137                 ab.Save ("TestSetCustomAttributeB.dll");
1138
1139                 filename = Path.Combine (tempDir, "TestSetCustomAttributeB.dll");
1140                 check = AssemblyName.GetAssemblyName (filename);
1141                 Assert.AreEqual ("nl-BE", check.CultureInfo.Name, "#B1");
1142                 Assert.AreEqual (AssemblyNameFlags.Retargetable, check.Flags, "#B2");
1143                 Assert.AreEqual ("TestSetCustomAttributeB, Version=1.3.5.7, Culture=nl-BE, PublicKeyToken=null, Retargetable=Yes", check.FullName, "#B3");
1144                 Assert.IsNull (check.GetPublicKey (), "#B4");
1145                 Assert.AreEqual (new byte [0], check.GetPublicKeyToken (), "#B5");
1146                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1, check.HashAlgorithm, "#B6");
1147                 Assert.IsNull (check.KeyPair, "#B7");
1148                 Assert.AreEqual ("TestSetCustomAttributeB", check.Name, "#B8");
1149                 //Assert.AreEqual (ProcessorArchitecture.MSIL, check.ProcessorArchitecture, "#B9");
1150                 Assert.AreEqual (new Version (1, 3, 5, 7), check.Version, "#B10");
1151                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, check.VersionCompatibility, "#B11");
1152
1153                 using (FileStream fs = File.OpenRead (filename)) {
1154                         byte [] buffer = new byte [fs.Length];
1155                         fs.Read (buffer, 0, buffer.Length);
1156                         a = Assembly.Load (buffer);
1157                 }
1158
1159                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyVersionAttribute));
1160                 Assert.IsNotNull (attr, "#B12a");
1161                 Assert.AreEqual ("1.2.3.4", ((AssemblyVersionAttribute) attr).Version, "#B12b");
1162                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyCultureAttribute));
1163                 Assert.IsNotNull (attr, "#B13a");
1164                 Assert.AreEqual ("en-US", ((AssemblyCultureAttribute) attr).Culture, "#B13b");
1165                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyAlgorithmIdAttribute));
1166                 Assert.IsNotNull (attr, "#B14a");
1167                 Assert.AreEqual ((uint) AssemblyHashAlgorithm.MD5, ((AssemblyAlgorithmIdAttribute) attr).AlgorithmId, "#B14b");
1168                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyFlagsAttribute));
1169                 Assert.IsNotNull (attr, "#B15a");
1170                 Assert.AreEqual ((uint) 0x0100, ((AssemblyFlagsAttribute) attr).Flags, "#B15b");
1171                 attr = Attribute.GetCustomAttribute (a, typeof (FooAttribute));
1172                 Assert.IsNotNull (attr, "#B16");
1173         }
1174
1175         // strongname generated using "sn -k unit.snk"
1176         static byte[] strongName = {
1177                 0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x32,
1178                 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x7F, 0x7C, 0xEA, 0x4A,
1179                 0x28, 0x33, 0xD8, 0x3C, 0x86, 0x90, 0x86, 0x91, 0x11, 0xBB, 0x30, 0x0D,
1180                 0x3D, 0x69, 0x04, 0x4C, 0x48, 0xF5, 0x4F, 0xE7, 0x64, 0xA5, 0x82, 0x72,
1181                 0x5A, 0x92, 0xC4, 0x3D, 0xC5, 0x90, 0x93, 0x41, 0xC9, 0x1D, 0x34, 0x16,
1182                 0x72, 0x2B, 0x85, 0xC1, 0xF3, 0x99, 0x62, 0x07, 0x32, 0x98, 0xB7, 0xE4,
1183                 0xFA, 0x75, 0x81, 0x8D, 0x08, 0xB9, 0xFD, 0xDB, 0x00, 0x25, 0x30, 0xC4,
1184                 0x89, 0x13, 0xB6, 0x43, 0xE8, 0xCC, 0xBE, 0x03, 0x2E, 0x1A, 0x6A, 0x4D,
1185                 0x36, 0xB1, 0xEB, 0x49, 0x26, 0x6C, 0xAB, 0xC4, 0x29, 0xD7, 0x8F, 0x25,
1186                 0x11, 0xA4, 0x7C, 0x81, 0x61, 0x97, 0xCB, 0x44, 0x2D, 0x80, 0x49, 0x93,
1187                 0x48, 0xA7, 0xC9, 0xAB, 0xDB, 0xCF, 0xA3, 0x34, 0xCB, 0x6B, 0x86, 0xE0,
1188                 0x4D, 0x27, 0xFC, 0xA7, 0x4F, 0x36, 0xCA, 0x13, 0x42, 0xD3, 0x83, 0xC4,
1189                 0x06, 0x6E, 0x12, 0xE0, 0xA1, 0x3D, 0x9F, 0xA9, 0xEC, 0xD1, 0xC6, 0x08,
1190                 0x1B, 0x3D, 0xF5, 0xDB, 0x4C, 0xD4, 0xF0, 0x2C, 0xAA, 0xFC, 0xBA, 0x18,
1191                 0x6F, 0x48, 0x7E, 0xB9, 0x47, 0x68, 0x2E, 0xF6, 0x1E, 0x67, 0x1C, 0x7E,
1192                 0x0A, 0xCE, 0x10, 0x07, 0xC0, 0x0C, 0xAD, 0x5E, 0xC1, 0x53, 0x70, 0xD5,
1193                 0xE7, 0x25, 0xCA, 0x37, 0x5E, 0x49, 0x59, 0xD0, 0x67, 0x2A, 0xBE, 0x92,
1194                 0x36, 0x86, 0x8A, 0xBF, 0x3E, 0x17, 0x04, 0xFB, 0x1F, 0x46, 0xC8, 0x10,
1195                 0x5C, 0x93, 0x02, 0x43, 0x14, 0x96, 0x6A, 0xD9, 0x87, 0x17, 0x62, 0x7D,
1196                 0x3A, 0x45, 0xBE, 0x35, 0xDE, 0x75, 0x0B, 0x2A, 0xCE, 0x7D, 0xF3, 0x19,
1197                 0x85, 0x4B, 0x0D, 0x6F, 0x8D, 0x15, 0xA3, 0x60, 0x61, 0x28, 0x55, 0x46,
1198                 0xCE, 0x78, 0x31, 0x04, 0x18, 0x3C, 0x56, 0x4A, 0x3F, 0xA4, 0xC9, 0xB1,
1199                 0x41, 0xED, 0x22, 0x80, 0xA1, 0xB3, 0xE2, 0xC7, 0x1B, 0x62, 0x85, 0xE4,
1200                 0x81, 0x39, 0xCB, 0x1F, 0x95, 0xCC, 0x61, 0x61, 0xDF, 0xDE, 0xF3, 0x05,
1201                 0x68, 0xB9, 0x7D, 0x4F, 0xFF, 0xF3, 0xC0, 0x0A, 0x25, 0x62, 0xD9, 0x8A,
1202                 0x8A, 0x9E, 0x99, 0x0B, 0xFB, 0x85, 0x27, 0x8D, 0xF6, 0xD4, 0xE1, 0xB9,
1203                 0xDE, 0xB4, 0x16, 0xBD, 0xDF, 0x6A, 0x25, 0x9C, 0xAC, 0xCD, 0x91, 0xF7,
1204                 0xCB, 0xC1, 0x81, 0x22, 0x0D, 0xF4, 0x7E, 0xEC, 0x0C, 0x84, 0x13, 0x5A,
1205                 0x74, 0x59, 0x3F, 0x3E, 0x61, 0x00, 0xD6, 0xB5, 0x4A, 0xA1, 0x04, 0xB5,
1206                 0xA7, 0x1C, 0x29, 0xD0, 0xE1, 0x11, 0x19, 0xD7, 0x80, 0x5C, 0xEE, 0x08,
1207                 0x15, 0xEB, 0xC9, 0xA8, 0x98, 0xF5, 0xA0, 0xF0, 0x92, 0x2A, 0xB0, 0xD3,
1208                 0xC7, 0x8C, 0x8D, 0xBB, 0x88, 0x96, 0x4F, 0x18, 0xF0, 0x8A, 0xF9, 0x31,
1209                 0x9E, 0x44, 0x94, 0x75, 0x6F, 0x78, 0x04, 0x10, 0xEC, 0xF3, 0xB0, 0xCE,
1210                 0xA0, 0xBE, 0x7B, 0x25, 0xE1, 0xF7, 0x8A, 0xA8, 0xD4, 0x63, 0xC2, 0x65,
1211                 0x47, 0xCC, 0x5C, 0xED, 0x7D, 0x8B, 0x07, 0x4D, 0x76, 0x29, 0x53, 0xAC,
1212                 0x27, 0x8F, 0x5D, 0x78, 0x56, 0xFA, 0x99, 0x45, 0xA2, 0xCC, 0x65, 0xC4,
1213                 0x54, 0x13, 0x9F, 0x38, 0x41, 0x7A, 0x61, 0x0E, 0x0D, 0x34, 0xBC, 0x11,
1214                 0xAF, 0xE2, 0xF1, 0x8B, 0xFA, 0x2B, 0x54, 0x6C, 0xA3, 0x6C, 0x09, 0x1F,
1215                 0x0B, 0x43, 0x9B, 0x07, 0x95, 0x83, 0x3F, 0x97, 0x99, 0x89, 0xF5, 0x51,
1216                 0x41, 0xF6, 0x8E, 0x5D, 0xEF, 0x6D, 0x24, 0x71, 0x41, 0x7A, 0xAF, 0xBE,
1217                 0x81, 0x71, 0xAB, 0x76, 0x2F, 0x1A, 0x5A, 0xBA, 0xF3, 0xA6, 0x65, 0x7A,
1218                 0x80, 0x50, 0xCE, 0x23, 0xC3, 0xC7, 0x53, 0xB0, 0x7C, 0x97, 0x77, 0x27,
1219                 0x70, 0x98, 0xAE, 0xB5, 0x24, 0x66, 0xE1, 0x60, 0x39, 0x41, 0xDA, 0x54,
1220                 0x01, 0x64, 0xFB, 0x10, 0x33, 0xCE, 0x8B, 0xBE, 0x27, 0xD4, 0x21, 0x57,
1221                 0xCC, 0x0F, 0x1A, 0xC1, 0x3D, 0xF3, 0xCC, 0x39, 0xF0, 0x2F, 0xAE, 0xF1,
1222                 0xC0, 0xCD, 0x3B, 0x23, 0x87, 0x49, 0x7E, 0x40, 0x32, 0x6A, 0xD3, 0x96,
1223                 0x4A, 0xE5, 0x5E, 0x6E, 0x26, 0xFD, 0x8A, 0xCF, 0x7E, 0xFC, 0x37, 0xDE,
1224                 0x39, 0x0C, 0x53, 0x81, 0x75, 0x08, 0xAF, 0x6B, 0x39, 0x6C, 0xFB, 0xC9,
1225                 0x79, 0xC0, 0x9B, 0x5F, 0x34, 0x86, 0xB2, 0xDE, 0xC4, 0x19, 0x84, 0x5F,
1226                 0x0E, 0xED, 0x9B, 0xB8, 0xD3, 0x17, 0xDA, 0x78 };
1227
1228         static byte [] token = { 0x0e, 0xea, 0x7c, 0xe6, 0x5f, 0x35, 0xf2, 0xd8 };
1229
1230         [Test]
1231         public void StrongName_MissingKeyFile_NoDelay ()
1232         {
1233                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyKeyFileAttribute).GetConstructor (new Type [] { typeof (string) }), new object [] { "missing.snk" }));
1234                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyDelaySignAttribute).GetConstructor (new Type [] { typeof (bool) }), new object [] { false }));
1235                 ab.Save ("StrongName_MissingKeyFile_NoDelay.dll");
1236
1237                 string filename = Path.Combine (tempDir, "StrongName_MissingKeyFile_NoDelay.dll");
1238                 AssemblyName check = AssemblyName.GetAssemblyName (filename);
1239                 // no exception is thrown (file not found)
1240                 // because it's not AssemblyBuilder.Save job to do the signing :-/
1241                 Assert.AreEqual (AssemblyNameFlags.None, check.Flags, "#1");
1242                 Assert.IsNull (check.GetPublicKey (), "#2");
1243                 Assert.IsNotNull (check.GetPublicKeyToken (), "#3a");
1244                 Assert.AreEqual (0, check.GetPublicKeyToken ().Length, "#3b");
1245                 Assert.IsTrue (check.FullName.IndexOf ("Version=0.0.0.0") != -1, "#4");
1246                 Assert.IsTrue (check.FullName.IndexOf ("Culture=neutral") != -1, "#5");
1247                 Assert.IsTrue (check.FullName.IndexOf ("PublicKeyToken=null") != -1, "#6");
1248         }
1249
1250         [Test]
1251         public void StrongName_KeyFile_Delay ()
1252         {
1253                 string strongfile = Path.Combine (tempDir, "strongname.snk");
1254                 using (FileStream fs = File.OpenWrite (strongfile)) {
1255                         fs.Write (strongName, 0, strongName.Length);
1256                         fs.Close ();
1257                 }
1258                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyKeyFileAttribute).GetConstructor (new Type [] { typeof (string) }), new object [] { strongfile }));
1259                 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (AssemblyDelaySignAttribute).GetConstructor (new Type [] { typeof (bool) }), new object [] { true }));
1260                 ab.Save ("StrongName_KeyFile_Delay.dll");
1261
1262                 string filename = Path.Combine (tempDir, "StrongName_KeyFile_Delay.dll");
1263                 AssemblyName check = AssemblyName.GetAssemblyName (filename);
1264                 // no public key is inserted into the assembly
1265                 // because it's not AssemblyBuilder.Save job to do the signing :-/
1266                 Assert.AreEqual (AssemblyNameFlags.None, check.Flags, "#1");
1267                 Assert.IsNull (check.GetPublicKey (), "#2");
1268                 Assert.IsNotNull (check.GetPublicKeyToken (), "#3a");
1269                 Assert.AreEqual (0, check.GetPublicKeyToken ().Length, "#3b");
1270                 Assert.IsTrue (check.FullName.IndexOf ("Version=0.0.0.0") != -1, "#4");
1271                 Assert.IsTrue (check.FullName.IndexOf ("Culture=neutral") != -1, "#5");
1272                 Assert.IsTrue (check.FullName.IndexOf ("PublicKeyToken=null") != -1, "#6");
1273         }
1274
1275         [Test]
1276         public void StrongName_WithoutAttributes ()
1277         {
1278                 // this demonstrate that AssemblyKeyFileAttribute (or AssemblyKeyNameAttribute)
1279                 // aren't required to sign an assembly.
1280                 AssemblyName an = genAssemblyName ();
1281                 an.KeyPair = new StrongNameKeyPair (strongName);
1282                 AssemblyBuilder ab = domain.DefineDynamicAssembly (an, AssemblyBuilderAccess.RunAndSave, tempDir);
1283                 ab.Save ("StrongName_WithoutAttributes.dll");
1284
1285                 string filename = Path.Combine (tempDir, "StrongName_WithoutAttributes.dll");
1286                 AssemblyName check = AssemblyName.GetAssemblyName (filename);
1287                 Assert.IsNotNull (check.GetPublicKey (), "#1a");
1288                 Assert.IsTrue (check.GetPublicKey ().Length > 0, "#1b");
1289                 Assert.AreEqual ("0E-EA-7C-E6-5F-35-F2-D8", BitConverter.ToString (check.GetPublicKeyToken ()), "#2");
1290
1291                 Assert.IsTrue (check.FullName.IndexOf ("Version=0.0.0.0") != -1, "#3");
1292                 Assert.IsTrue (check.FullName.IndexOf ("Culture=neutral") != -1, "#4");
1293                 Assert.IsTrue (check.FullName.IndexOf ("PublicKeyToken=0eea7ce65f35f2d8") != -1, "#5");
1294                 Assert.AreEqual (AssemblyNameFlags.PublicKey, check.Flags, "#6");
1295         }
1296
1297         [Test]
1298         public void SaveUnfinishedTypes ()
1299         {
1300                 mb.DefineType ("TestType", TypeAttributes.Class |
1301                         TypeAttributes.Public | TypeAttributes.Sealed |
1302                         TypeAttributes.AnsiClass | TypeAttributes.AutoClass,
1303                         typeof(object));
1304                 try {
1305                         ab.Save ("def_module");
1306                         Assert.Fail ("#1");
1307                 } catch (NotSupportedException ex) {
1308                         // Type 'TestType' was not completed
1309                         Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
1310                         Assert.IsNull (ex.InnerException, "#3");
1311                         Assert.IsNotNull (ex.Message, "#4");
1312                         Assert.IsTrue (ex.Message.IndexOf ("TestType") != -1, "#5");
1313                 }
1314         }
1315
1316         [Test]
1317         public void GetModules ()
1318         {
1319                 Module[] arr;
1320
1321                 arr = ab.GetModules ();
1322                 Assert.IsNotNull (arr, "#A1");
1323                 // FIXME: This doesn't work on mono
1324                 //Assert.IsTrue (arr.Length >= 2, "#A2");
1325                 foreach (Module m in arr)
1326                         Assert.AreEqual (typeof (ModuleBuilder), m.GetType (), "#A3");
1327
1328                 // Test with no modules
1329                 AssemblyBuilder ab2 = genAssembly ();
1330                 arr = ab2.GetModules ();
1331                 Assert.IsNotNull (arr, "#B1");
1332                 Assert.AreEqual (0, arr.Length, "#B2");
1333         }
1334
1335         [Test]
1336         [Category ("NotWorking")] // bug #351932
1337         public void GetReferencedAssemblies ()
1338         {
1339                 AssemblyBuilder ab1;
1340                 AssemblyBuilder ab2;
1341                 AssemblyBuilder ab3;
1342                 AssemblyName [] refs;
1343                 TypeBuilder tb1;
1344                 TypeBuilder tb2;
1345                 TypeBuilder tb3;
1346                 TypeBuilder tb4;
1347                 ModuleBuilder mb1;
1348                 ModuleBuilder mb2;
1349                 ModuleBuilder mb3;
1350                 AssemblyName an1 = genAssemblyName ();
1351                 an1.Version = new Version (3, 0);
1352                 AssemblyName an2 = genAssemblyName ();
1353                 an2.Version = new Version ("1.2.3.4");
1354                 an2.KeyPair = new StrongNameKeyPair (strongName);
1355                 AssemblyName an3 = genAssemblyName ();
1356
1357                 ab1 = domain.DefineDynamicAssembly (an1,
1358                         AssemblyBuilderAccess.RunAndSave,
1359                         tempDir);
1360                 ab2 = domain.DefineDynamicAssembly (an2,
1361                         AssemblyBuilderAccess.RunAndSave,
1362                         tempDir);
1363                 ab3 = domain.DefineDynamicAssembly (an3,
1364                         AssemblyBuilderAccess.RunAndSave,
1365                         tempDir);
1366
1367                 refs = ab1.GetReferencedAssemblies ();
1368                 Assert.AreEqual (0, refs.Length, "#A1");
1369                 refs = ab2.GetReferencedAssemblies ();
1370                 Assert.AreEqual (0, refs.Length, "#A2");
1371                 refs = ab3.GetReferencedAssemblies ();
1372                 Assert.AreEqual (0, refs.Length, "#A3");
1373
1374                 mb1 = ab1.DefineDynamicModule (an1.Name + ".dll");
1375                 tb1 = mb1.DefineType ("TestType1", TypeAttributes.Class |
1376                         TypeAttributes.Public, typeof (Attribute));
1377                 tb1.CreateType ();
1378
1379                 mb2 = ab2.DefineDynamicModule (an2.Name + ".dll");
1380                 tb2 = mb2.DefineType ("TestType2", TypeAttributes.Class |
1381                         TypeAttributes.Public, tb1);
1382                 tb2.CreateType ();
1383
1384                 mb3 = ab3.DefineDynamicModule (an3.Name + ".dll");
1385                 tb3 = mb3.DefineType ("TestType3", TypeAttributes.Class |
1386                         TypeAttributes.Public, tb1);
1387                 tb3.CreateType ();
1388                 tb4 = mb3.DefineType ("TestType4", TypeAttributes.Class |
1389                         TypeAttributes.Public, tb2);
1390                 tb4.CreateType ();
1391
1392                 refs = ab1.GetReferencedAssemblies ();
1393                 Assert.AreEqual (0, refs.Length, "#B1");
1394                 refs = ab2.GetReferencedAssemblies ();
1395                 Assert.AreEqual (0, refs.Length, "#B2");
1396                 refs = ab3.GetReferencedAssemblies ();
1397                 Assert.AreEqual (0, refs.Length, "#B3");
1398
1399                 ab1.Save (an1.Name + ".dll");
1400                 ab2.Save (an2.Name + ".dll");
1401                 ab3.Save (an3.Name + ".dll");
1402
1403                 refs = ab1.GetReferencedAssemblies ();
1404                 Assert.AreEqual (0, refs.Length, "#C1");
1405                 refs = ab2.GetReferencedAssemblies ();
1406                 Assert.AreEqual (0, refs.Length, "#C2");
1407                 refs = ab3.GetReferencedAssemblies ();
1408                 Assert.AreEqual (0, refs.Length, "#C3");
1409
1410                 string assemblyFile = Path.Combine (tempDir, an1.Name + ".dll");
1411
1412                 using (FileStream fs = File.OpenRead (assemblyFile)) {
1413                         byte [] buffer = new byte [fs.Length];
1414                         fs.Read (buffer, 0, buffer.Length);
1415                         Assembly a = Assembly.Load (buffer);
1416                         refs = a.GetReferencedAssemblies ();
1417                         Assert.AreEqual (1, refs.Length, "#D1");
1418
1419                         Assert.IsNull (refs [0].CodeBase, "#D2:CodeBase");
1420                         Assert.IsNotNull (refs [0].CultureInfo, "#D2:CultureInfo");
1421                         Assert.IsNull (refs [0].EscapedCodeBase, "#D2:EscapedCodeBase");
1422                         Assert.AreEqual (AssemblyNameFlags.None, refs [0].Flags, "#D2:Flags");
1423                         Assert.AreEqual (typeof (object).FullName, refs [0].FullName, "#D2:FullName");
1424                         Assert.AreEqual (AssemblyHashAlgorithm.SHA1, refs [0].HashAlgorithm, "#D2:HashAlgorithm");
1425                         Assert.IsNull (refs [0].KeyPair, "#D2:KeyPair");
1426                         Assert.AreEqual ("mscorlib", refs [0].Name, "#D2:Name");
1427                         Assert.AreEqual (ProcessorArchitecture.None, refs [0].ProcessorArchitecture, "#D2:PA");
1428
1429                         string FxVersion;
1430 #if MOBILE
1431                         FxVersion = "2.0.5.0;";
1432 #elif NET_4_0
1433                         FxVersion = "4.0.0.0;";
1434 #else
1435                         FxVersion = "2.0.0.0;";
1436 #endif
1437                         Assert.AreEqual (new Version (FxVersion), refs [0].Version, "#D2:Version");
1438                         Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1439                                 refs [0].VersionCompatibility, "#D2:VersionCompatibility");
1440                         Assert.IsNull (refs [0].GetPublicKey (), "#D2:GetPublicKey");
1441                         Assert.IsNotNull (refs [0].GetPublicKeyToken (), "#D2:GetPublicKeyToken(a)");
1442                         Assert.AreEqual (8, refs [0].GetPublicKeyToken ().Length, "#D2:GetPublicKeyToken(b)");
1443                         Assert.AreEqual (refs [0].FullName, refs [0].ToString (), "#D2:ToString");
1444                 }
1445
1446                 assemblyFile = Path.Combine (tempDir, an2.Name + ".dll");
1447
1448                 using (FileStream fs = File.OpenRead (assemblyFile)) {
1449                         byte [] buffer = new byte [fs.Length];
1450                         fs.Read (buffer, 0, buffer.Length);
1451                         Assembly a = Assembly.Load (buffer);
1452                         refs = a.GetReferencedAssemblies ();
1453                         Assert.AreEqual (1, refs.Length, "#E1");
1454
1455                         Assert.IsNull (refs [0].CodeBase, "#E2:CodeBase");
1456                         Assert.IsNotNull (refs [0].CultureInfo, "#E2:CultureInfo(a)");
1457                         Assert.AreEqual (CultureInfo.InvariantCulture, refs [0].CultureInfo, "#E2:CultureInfo(b)");
1458                         Assert.IsNull (refs [0].EscapedCodeBase, "#E2:EscapedCodeBase");
1459                         Assert.AreEqual (AssemblyNameFlags.None, refs [0].Flags, "#E2:Flags");
1460                         Assert.AreEqual (an1.Name + ", Version=3.0.0.0, Culture=neutral, PublicKeyToken=null", refs [0].FullName, "#E2:FullName");
1461                         Assert.AreEqual (AssemblyHashAlgorithm.SHA1, refs [0].HashAlgorithm, "#E2:HashAlgorithm");
1462                         Assert.IsNull (refs [0].KeyPair, "#E2:KeyPair");
1463                         Assert.AreEqual (an1.Name, refs [0].Name, "#E2:Name");
1464                         Assert.AreEqual (ProcessorArchitecture.None, refs [0].ProcessorArchitecture, "#E2:PA");
1465                         Assert.AreEqual (new Version (3, 0, 0, 0), refs [0].Version, "#E2:Version");
1466                         Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1467                                 refs [0].VersionCompatibility, "#E2:VersionCompatibility");
1468                         Assert.IsNull (refs [0].GetPublicKey (), "#E2:GetPublicKey");
1469                         Assert.IsNotNull (refs [0].GetPublicKeyToken (), "#E2:GetPublicKeyToken(a)");
1470                         Assert.AreEqual (0, refs [0].GetPublicKeyToken ().Length, "#E2:GetPublicKeyToken(b)");
1471                         Assert.AreEqual (refs [0].FullName, refs [0].ToString (), "#E2:ToString");
1472                 }
1473
1474                 assemblyFile = Path.Combine (tempDir, an3.Name + ".dll");
1475
1476                 using (FileStream fs = File.OpenRead (assemblyFile)) {
1477                         byte [] buffer = new byte [fs.Length];
1478                         fs.Read (buffer, 0, buffer.Length);
1479                         Assembly a = Assembly.Load (buffer);
1480                         refs = a.GetReferencedAssemblies ();
1481                         Assert.AreEqual (2, refs.Length, "#F1");
1482
1483                         Assert.IsNull (refs [0].CodeBase, "#F2:CodeBase");
1484                         Assert.IsNotNull (refs [0].CultureInfo, "#F2:CultureInfo(a)");
1485                         Assert.AreEqual (CultureInfo.InvariantCulture, refs [0].CultureInfo, "#F2:CultureInfo(b)");
1486                         Assert.IsNull (refs [0].EscapedCodeBase, "#F2:EscapedCodeBase");
1487                         Assert.AreEqual (AssemblyNameFlags.None, refs [0].Flags, "#F2:Flags");
1488                         Assert.AreEqual (an1.Name + ", Version=3.0.0.0, Culture=neutral, PublicKeyToken=null", refs [0].FullName, "#F2:FullName");
1489                         Assert.AreEqual (AssemblyHashAlgorithm.SHA1, refs [0].HashAlgorithm, "#F2:HashAlgorithm");
1490                         Assert.IsNull (refs [0].KeyPair, "#F2:KeyPair");
1491                         Assert.AreEqual (an1.Name, refs [0].Name, "#F2:Name");
1492                         Assert.AreEqual (ProcessorArchitecture.None, refs [0].ProcessorArchitecture, "#F2:PA");
1493                         Assert.AreEqual (new Version (3, 0, 0, 0), refs [0].Version, "#F2:Version");
1494                         Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1495                                 refs [0].VersionCompatibility, "#F2:VersionCompatibility");
1496                         Assert.IsNull (refs [0].GetPublicKey (), "#F2:GetPublicKey");
1497                         Assert.IsNotNull (refs [0].GetPublicKeyToken (), "#F2:GetPublicKeyToken(a)");
1498                         Assert.AreEqual (0, refs [0].GetPublicKeyToken ().Length, "#F2:GetPublicKeyToken(b)");
1499                         Assert.AreEqual (refs [0].FullName, refs [0].ToString (), "#F2:ToString");
1500
1501                         Assert.IsNull (refs [1].CodeBase, "#F3:CodeBase");
1502                         Assert.IsNotNull (refs [1].CultureInfo, "#F3:CultureInfo(a)");
1503                         Assert.AreEqual (CultureInfo.InvariantCulture, refs [1].CultureInfo, "#F3:CultureInfo(b)");
1504                         Assert.IsNull (refs [1].EscapedCodeBase, "#F3:EscapedCodeBase");
1505                         Assert.AreEqual (AssemblyNameFlags.None, refs [1].Flags, "#F3:Flags");
1506                         Assert.AreEqual (an2.Name + ", Version=1.2.3.4, Culture=neutral, PublicKeyToken=0eea7ce65f35f2d8", refs [1].FullName, "#F3:FullName");
1507                         Assert.AreEqual (AssemblyHashAlgorithm.SHA1, refs [1].HashAlgorithm, "#F3:HashAlgorithm");
1508                         Assert.IsNull (refs [1].KeyPair, "#F3:KeyPair");
1509                         Assert.AreEqual (an2.Name, refs [1].Name, "#F3:Name");
1510                         Assert.AreEqual (ProcessorArchitecture.None, refs [1].ProcessorArchitecture, "#F3:PA");
1511                         Assert.AreEqual (new Version (1, 2, 3, 4), refs [1].Version, "#F3:Version");
1512                         Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1513                                 refs [1].VersionCompatibility, "#F3:VersionCompatibility");
1514                         Assert.IsNull (refs [1].GetPublicKey (), "#F3:GetPublicKey");
1515                         Assert.AreEqual (token, refs [1].GetPublicKeyToken (), "#F3:GetPublicKeyToken");
1516                         Assert.AreEqual (refs [1].FullName, refs [1].ToString (), "#F3:ToString");
1517                 }
1518         }
1519
1520         [Test] // bug #78724
1521         public void GetTypes ()
1522         {
1523                 TypeBuilder tb = mb.DefineType ("sometype");
1524                 tb.CreateType ();
1525
1526                 Type[] types = ab.GetTypes ();
1527                 Assert.AreEqual (1, types.Length, "#1");
1528                 Assert.AreEqual ("sometype", types[0].Name, "#2");
1529         }
1530
1531         [Test]
1532         public void AssemblyName_Culture ()
1533         {
1534                 AssemblyName assemblyName = new AssemblyName ();
1535                 assemblyName.Name = "AssemblyNameTest";
1536                 assemblyName.Version = new Version ("1.0.0.0");
1537                 assemblyName.CultureInfo = new CultureInfo ("en-US");
1538
1539                 const string fullName = "AssemblyNameTest, Version=1.0.0.0, Culture=en-US, PublicKeyToken=null";
1540                 const string abName = "AssemblyNameTest, Version=1.0.0.0, Culture=en-US";
1541
1542                 AssertAssemblyName (tempDir, assemblyName, abName, fullName);
1543         }
1544
1545         [Test]
1546         public void AssemblyName_PublicKey ()
1547         {
1548                 AssemblyName assemblyName = new AssemblyName ();
1549                 assemblyName.Name = "AssemblyNameTest_PublicKey";
1550                 assemblyName.Version = new Version ("1.2.3.4");
1551                 assemblyName.KeyPair = new StrongNameKeyPair (strongName);
1552
1553                 Assert.AreEqual ("AssemblyNameTest_PublicKey, Version=1.2.3.4", assemblyName.FullName, "#A1");
1554
1555                 const string fullName = "AssemblyNameTest_PublicKey, Version=1.2.3.4, Culture=neutral, PublicKeyToken=0eea7ce65f35f2d8";
1556
1557                 AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1558                         assemblyName, AssemblyBuilderAccess.Save, tempDir);
1559
1560                 AssemblyName abName = ab.GetName ();
1561                 Assert.AreEqual (CultureInfo.InvariantCulture, abName.CultureInfo, "#B1");
1562                 Assert.AreEqual (AssemblyNameFlags.PublicKey, abName.Flags, "#B2");
1563                 Assert.IsNotNull (abName.GetPublicKey () != null, "#B3a");
1564                 Assert.IsTrue (abName.GetPublicKey ().Length > 0, "#B3b");
1565                 Assert.IsNotNull (abName.GetPublicKeyToken (), "#B4a");
1566                 Assert.IsTrue (abName.GetPublicKeyToken ().Length > 0, "#B4b");
1567                 Assert.AreEqual (fullName, abName.FullName, "#B5");
1568
1569                 ab.Save ("AssemblyNameTest_PublicKey.dll");
1570                 AssemblyName bakedName = AssemblyName.GetAssemblyName (Path.Combine(
1571                         tempDir, "AssemblyNameTest_PublicKey.dll"));
1572
1573                 Assert.AreEqual (CultureInfo.InvariantCulture, bakedName.CultureInfo, "#C1");
1574                 Assert.AreEqual (AssemblyNameFlags.PublicKey, bakedName.Flags, "#C2");
1575                 Assert.IsNotNull (bakedName.GetPublicKeyToken (), "#C3");
1576                 Assert.IsNotNull (bakedName.GetPublicKey (), "#C4");
1577                 Assert.AreEqual (fullName, bakedName.FullName, "#C5");
1578         }
1579
1580         [Test]
1581         public void AssemblyName_MoreCultureInfo ()
1582         {
1583                 AssemblyName assemblyName = new AssemblyName ();
1584                 assemblyName.Name = "AssemblyNameTest_MoreCultureInfo";
1585                 assemblyName.Version = new Version ("1.2.3.4");
1586                 assemblyName.KeyPair = new StrongNameKeyPair (strongName);
1587
1588                 Assert.IsNull (assemblyName.CultureInfo, "#A1");
1589                 Assert.AreEqual ("AssemblyNameTest_MoreCultureInfo, Version=1.2.3.4", assemblyName.FullName, "#A2");
1590
1591                 const string fullName = "AssemblyNameTest_MoreCultureInfo, Version=1.2.3.4, Culture=neutral, PublicKeyToken=0eea7ce65f35f2d8";
1592
1593                 AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1594                         assemblyName, AssemblyBuilderAccess.Save, tempDir);
1595
1596                 AssemblyName abName = ab.GetName ();
1597                 Assert.IsNotNull (abName.CultureInfo != null, "#B1");
1598                 Assert.IsTrue (abName.CultureInfo != CultureInfo.InvariantCulture, "#B2a");
1599                 Assert.AreEqual (CultureInfo.InvariantCulture.LCID, abName.CultureInfo.LCID, "#B2a");
1600                 Assert.AreEqual (AssemblyNameFlags.PublicKey, abName.Flags, "#B3");
1601                 Assert.AreEqual (fullName, abName.FullName, "#B4");
1602
1603                 ab.Save ("AssemblyNameTest_MoreCultureInfo.dll");
1604
1605                 AssemblyName bakedName = AssemblyName.GetAssemblyName (Path.Combine(
1606                         tempDir, "AssemblyNameTest_MoreCultureInfo.dll"));
1607
1608                 Assert.IsNotNull (bakedName.CultureInfo, "#C1");
1609
1610                 Assert.IsTrue (abName.CultureInfo != CultureInfo.InvariantCulture, "#C2a");
1611                 Assert.AreEqual (CultureInfo.InvariantCulture.LCID, abName.CultureInfo.LCID, "#C2b");
1612                 Assert.AreEqual (fullName, bakedName.FullName, "#C3");
1613         }
1614
1615         [Test]
1616         public void AssemblyName_NoVersion ()
1617         {
1618                 AssemblyName assemblyName = new AssemblyName ();
1619                 assemblyName.Name = "AssemblyNameTest";
1620
1621                 const string fullName = "AssemblyNameTest, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null";
1622                 const string abName = "AssemblyNameTest, Version=0.0.0.0";
1623
1624                 AssertAssemblyName (tempDir, assemblyName, abName, fullName);
1625         }
1626
1627         [Test]
1628         public void AssemblyName_Version ()
1629         {
1630                 AssemblyName assemblyName = new AssemblyName ();
1631                 assemblyName.Name = "AssemblyNameTest";
1632                 assemblyName.Version = new Version (1, 2, 3, 4);
1633
1634                 string fullName = "AssemblyNameTest, Version=1.2.3.4, Culture=neutral, PublicKeyToken=null";
1635                 string abName = "AssemblyNameTest, Version=1.2.3.4";
1636
1637                 AssertAssemblyName (tempDir, assemblyName, abName, fullName);
1638
1639                 assemblyName = new AssemblyName ();
1640                 assemblyName.Name = "AssemblyNameTest";
1641                 assemblyName.Version = new Version (1, 2);
1642
1643                 fullName = "AssemblyNameTest, Version=1.2.0.0, Culture=neutral, PublicKeyToken=null";
1644                 abName = "AssemblyNameTest, Version=1.2.0.0";
1645
1646                 AssertAssemblyName (tempDir, assemblyName, abName, fullName);
1647         }
1648
1649         [Test]
1650         public void GetType_IgnoreCase ()
1651         {
1652                 TypeBuilder tb = mb.DefineType ("Foo.Test2", TypeAttributes.Public, typeof (object));
1653                 tb.CreateType ();
1654
1655                 Type t;
1656
1657                 t = ab.GetType ("foo.Test2", true, true);
1658                 Assert.AreEqual ("Test2", t.Name, "#1");
1659
1660                 t = ab.GetType ("foo.test2", true, true);
1661                 Assert.AreEqual ("Test2", t.Name, "#2");
1662
1663                 t = ab.GetType ("Foo.test2", true, true);
1664                 Assert.AreEqual ("Test2", t.Name, "#3");
1665         }
1666
1667
1668         [Test]
1669         public void TestGetType ()
1670         {
1671                 TypeBuilder tb = mb.DefineType ("Test", TypeAttributes.Public);
1672
1673                 Assert.IsNull (ab.GetType ("Test", false, true), "#1");
1674                 try {
1675                         ab.GetType ("Test", true, true);
1676                         Assert.Fail ("#2");
1677                 } catch (TypeLoadException) { }
1678
1679                 var res = tb.CreateType ();
1680
1681                 Assert.AreSame (res, ab.GetType ("Test", false, true), "#3");
1682         }
1683
1684         [Test]
1685         public void GetModule ()
1686         {
1687                 var ab = genAssembly ();
1688                 Assert.IsNull (ab.GetModule ("Foo"), "#1");
1689
1690                 var modA = ab.DefineDynamicModule ("Foo");
1691                 var modB = ab.DefineDynamicModule ("Bar");
1692
1693                 Assert.AreSame (modA, ab.GetModule ("Foo"), "#2");
1694                 Assert.AreSame (modB, ab.GetModule ("Bar"), "#3");
1695                 Assert.IsNull (ab.GetModule ("FooBar"), "#4");
1696         }
1697
1698         [Test]
1699         public void GetModules2 ()
1700         {
1701                 //XXX this is not the v4 behavior since it returns
1702                 //the manifest module in the place of the first one
1703                 var ab = genAssembly ();
1704                 var modA = ab.DefineDynamicModule ("Foo");
1705                 var modB = ab.DefineDynamicModule ("Bar");
1706                 Assert.AreEqual (2, ab.GetModules ().Length, "#1");
1707                 Assert.AreSame (modA, ab.GetModules () [0], "#2");
1708                 Assert.AreSame (modB, ab.GetModules () [1], "#3");
1709         }
1710
1711         [Test]
1712         [Category ("NotDotNet")] // MS returns the real deal
1713         public void GetReferencedAssemblies_Trivial ()
1714         {
1715                 Assert.IsNotNull (ab.GetReferencedAssemblies (), "#1");
1716         }
1717
1718         [Test]
1719         public void GetLoadedModules ()
1720         {
1721                 var res = ab.GetLoadedModules (true);
1722                 Assert.IsNotNull (res, "#1");
1723                 Assert.AreEqual (1, res.Length, "#2");
1724                 Assert.AreEqual (mb, res [0], "#3");
1725         }
1726
1727         [ExpectedException (typeof (TypeLoadException))]
1728         public void GetCustomAttributes_NotCreated ()
1729         {
1730                 AssemblyBuilder ab = genAssembly ();
1731                 ModuleBuilder mb = ab.DefineDynamicModule("tester", "tester.dll", false);
1732                 TypeBuilder tb = mb.DefineType ("T");
1733                 tb.SetParent (typeof (Attribute));
1734                 ConstructorBuilder ctor = tb.DefineDefaultConstructor (MethodAttributes.Public);
1735                 object [] o = new object [0];
1736                 CustomAttributeBuilder cab = new CustomAttributeBuilder (ctor, o);
1737                 ab.SetCustomAttribute (cab);
1738
1739                 ab.GetCustomAttributes (true);
1740         }
1741
1742
1743         [Test]
1744         public void GetTypesWithUnfinishedTypeBuilder ()
1745         {
1746                 AssemblyBuilder ab = genAssembly ();
1747                 ModuleBuilder mb = ab.DefineDynamicModule("tester", "tester.dll", false);
1748                 mb.DefineType ("K").CreateType ();
1749                 var tb = mb.DefineType ("T");
1750
1751                 try {
1752                         ab.GetTypes ();
1753                         Assert.Fail ("#1");
1754                 } catch (ReflectionTypeLoadException ex) {
1755                         Assert.AreEqual (1, ex.Types.Length, "#2");
1756                         Assert.AreEqual (1, ex.LoaderExceptions.Length, "#3");
1757                         Assert.IsNull (ex.Types [0], "#4");
1758                         Assert.IsTrue (ex.LoaderExceptions [0] is TypeLoadException, "#5");
1759                 }
1760
1761                 tb.CreateType ();
1762                 var types = ab.GetTypes ();
1763                 Assert.AreEqual (2, types.Length, "#5");
1764                 foreach (var t in types)
1765                         Assert.IsFalse (t is TypeBuilder, "#6_" + t.Name);
1766         }
1767
1768         [Test]
1769         public void DynamicAssemblyGenerationInCurrentDomainShouldNotChangeTheOrderOfCurrentDomainGetAssemblies ()
1770         {
1771                 var initialPosition = GetAssemblyPositionForType (GetType ());
1772                 DefineDynamicAssembly (AppDomain.CurrentDomain);
1773
1774                 var currentPosition = GetAssemblyPositionForType (GetType ());
1775                 Assert.AreEqual (initialPosition, currentPosition);
1776         }
1777
1778         static void DefineDynamicAssembly (AppDomain domain)
1779         {
1780                 AssemblyName assemblyName = new AssemblyName ();
1781                 assemblyName.Name = "MyDynamicAssembly";
1782
1783                 AssemblyBuilder assemblyBuilder = domain.DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.Run);
1784                 ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule ("MyDynamicModule");
1785                 TypeBuilder typeBuilder = moduleBuilder.DefineType ("MyDynamicType", TypeAttributes.Public);
1786                 ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, null);
1787                 ILGenerator ilGenerator = constructorBuilder.GetILGenerator ();
1788                 ilGenerator.EmitWriteLine ("MyDynamicType instantiated!");
1789                 ilGenerator.Emit (OpCodes.Ret);
1790                 typeBuilder.CreateType ();
1791         }
1792
1793         static int GetAssemblyPositionForType (Type type)
1794         {
1795                 var assemblies = AppDomain.CurrentDomain.GetAssemblies ();
1796                 for (int i = 0; i < assemblies.Length; i++)
1797                         if (type.Assembly == assemblies [i])
1798                                 return i;
1799                 return -1;
1800         }
1801
1802
1803         private static void AssertAssemblyName (string tempDir, AssemblyName assemblyName, string abName, string fullName)
1804         {
1805                 AppDomain currentDomain = AppDomain.CurrentDomain;
1806                 AppDomain newDomain = null;
1807
1808                 try {
1809                         AssemblyBuilder ab = currentDomain.DefineDynamicAssembly (
1810                                 assemblyName, AssemblyBuilderAccess.Save, tempDir);
1811                         ab.Save (assemblyName.Name + ".dll");
1812
1813                         // on .NET 2.0, the full name of the AssemblyBuilder matches the
1814                         // fully qualified assembly name
1815                         Assert.AreEqual (fullName, ab.FullName, "#1");
1816
1817                         AssemblyName an = ab.GetName ();
1818
1819                         Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#2");
1820                         Assert.IsNotNull (an.GetPublicKey (), "#3a");
1821                         Assert.AreEqual (0, an.GetPublicKey ().Length, "#3b");
1822                         Assert.IsNotNull (an.GetPublicKeyToken (), "#4a");
1823                         Assert.AreEqual (0, an.GetPublicKeyToken ().Length, "#4b");
1824
1825                         // load assembly in separate domain, so we can clean-up after the
1826                         // test
1827                         newDomain = AppDomain.CreateDomain ("test2", currentDomain.Evidence,
1828                                 currentDomain.SetupInformation);
1829
1830                         Helper helper = new Helper (Path.Combine (tempDir, assemblyName.Name + ".dll"),
1831                                 fullName);
1832                         newDomain.DoCallBack (new CrossAppDomainDelegate (helper.Test));
1833                 } finally {
1834                         if (newDomain != null) {
1835                                 AppDomain.Unload (newDomain);
1836                         }
1837                 }
1838         }
1839
1840         [Serializable ()]
1841         private class Helper
1842         {
1843                 private readonly string _assemblyPath;
1844                 private readonly string _assemblyName;
1845
1846                 public Helper (string assemblyPath, string assemblyName)
1847                 {
1848                         _assemblyPath = assemblyPath;
1849                         _assemblyName = assemblyName;
1850                 }
1851
1852                 public void Test ()
1853                 {
1854                         AssemblyName assemblyName = AssemblyName.GetAssemblyName (_assemblyPath);
1855                         Assert.AreEqual (_assemblyName, assemblyName.ToString ());
1856                 }
1857         }
1858
1859
1860         [Test]//Bug #7126
1861         public void CannotCreateInstanceOfSaveOnlyAssembly ()
1862         {
1863                 var asm_builder = genAssembly (AssemblyBuilderAccess.Save);
1864         var mod_builder = asm_builder.DefineDynamicModule("Foo", "Foo.dll");
1865
1866         var type_builder = mod_builder.DefineType("Foo",
1867                 TypeAttributes.Public | TypeAttributes.Sealed |
1868                 TypeAttributes.Class | TypeAttributes.BeforeFieldInit);
1869
1870         var type = type_builder.CreateType();
1871
1872                 try {
1873                         Activator.CreateInstance(type);
1874                         Assert.Fail ("Cannot create instance of save only type");
1875                 } catch (NotSupportedException e) {
1876                 }
1877      }
1878 }
1879 }