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