mcs/class/corlib/Test/System/AppDomainTest.cs

   1 //
   2 // AppDomainTest.cs - NUnit Test Cases for AppDomain
   3 //
   4 // Author:
   5 //      Sebastien Pouliot (sebastien@ximian.com)
   6 //
   7 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   8 // Copyright 2011 Xamarin Inc (http://www.xamarin.com).
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 #if !MOBILE
  31
  32 using NUnit.Framework;
  33 using System;
  34 using System.Collections;
  35 using System.Collections.Generic;
  36 using System.Configuration.Assemblies;
  37 using System.Globalization;
  38 using System.IO;
  39 using System.Reflection;
  40 using System.Reflection.Emit;
  41 using System.Runtime.InteropServices;
  42 using System.Security;
  43 using System.Security.Permissions;
  44 using System.Security.Policy;
  45 using System.Security.Principal;
  46
  47 namespace MonoTests.System
  48 {
  49         [TestFixture]
  50         public class AppDomainTest
  51         {
  52                 private AppDomain ad;
  53                 private ArrayList files = new ArrayList ();
  54                 private string tempDir;
  55
  56                 [SetUp]
  57                 public void SetUp ()
  58                 {
  59                         tempDir = Path.Combine (Path.GetTempPath (), Environment.UserName);
  60                         tempDir = Path.Combine (tempDir, "MonoTests.System.AppDomainTest");
  61                         if (!Directory.Exists (tempDir)) {
  62                                 Directory.CreateDirectory (tempDir);
  63                         }
  64                 }
  65
  66                 [TearDown]
  67                 public void TearDown ()
  68                 {
  69                         if (ad != null) {
  70                                 try {
  71                                         AppDomain.Unload (ad);
  72                                         ad = null;
  73                                 } catch { } // do not affect unit test results in TearDown
  74                         }
  75                         foreach (string fname in files) {
  76                                 File.Delete (fname);
  77                         }
  78                         files.Clear ();
  79                 }
  80
  81                 [Test] // bug #80934
  82                 public void ConfigurationFile_Relative ()
  83                 {
  84                         // Note:
  85                         // We use Environment.GetCommandLineArgs () to get the location of
  86                         // the entry assembly in the default domain (since the default domain
  87                         // is not exposed by any API)
  88                         //
  89                         // MS returns a lower-case path in Environment.GetCommandLineArgs ()
  90                         // and hence we need to perform a case-insensitive comparison
  91                         // if the Assert involves that path
  92
  93                         string configFile = "test.config";
  94                         string appBase = null;
  95                         string expectedConfigFile = null;
  96                         string expectedAppBase = null;
  97
  98                         // do not set ApplicationBase
  99                         appBase = Path.GetDirectoryName (Environment.GetCommandLineArgs () [0]);
 100                         expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
 101                                 appBase : appBase + Path.DirectorySeparatorChar;
 102                         expectedConfigFile = Path.Combine (appBase, configFile);
 103                         AppDomainSetup setup = new AppDomainSetup();
 104                         setup.ConfigurationFile = configFile;
 105                         ad = CreateTestDomain (setup, true);
 106                         CrossDomainTester cdt = CreateCrossDomainTester (ad);
 107                         if (RunningOnUnix) {
 108                                 Assert.AreEqual (expectedConfigFile, cdt.GetConfigurationFile (), "#A1");
 109                                 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#A2");
 110                         } else {
 111                                 Assert.IsTrue (string.Compare (expectedConfigFile, cdt.GetConfigurationFile (), true) == 0, "#A1");
 112                                 Assert.IsTrue (string.Compare (expectedAppBase, cdt.GetApplicationBase (), true) == 0, "#A2");
 113                         }
 114                         AppDomain.Unload (ad);
 115
 116                         // set ApplicationBase
 117                         appBase = Path.GetTempPath ();
 118                         expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
 119                                 appBase : appBase + Path.DirectorySeparatorChar;
 120                         expectedConfigFile = Path.Combine (appBase, configFile);
 121                         setup = new AppDomainSetup ();
 122                         setup.ApplicationBase = appBase;
 123                         setup.ConfigurationFile = configFile;
 124                         ad = CreateTestDomain (setup, true);
 125                         cdt = CreateCrossDomainTester (ad);
 126                         Assert.AreEqual (expectedConfigFile, cdt.GetConfigurationFile (), "#B1");
 127                         Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#B2");
 128                         AppDomain.Unload (ad);
 129                 }
 130
 131                 [Test] // bug #80934
 132                 public void ConfigurationFile_Absolute ()
 133                 {
 134                         // Note:
 135                         // We use Environment.GetCommandLineArgs () to get the location of
 136                         // the entry assembly in the default domain (since the default domain
 137                         // is not exposed by any API)
 138                         //
 139                         // MS returns a lower-case path in Environment.GetCommandLineArgs ()
 140                         // and hence on Windows we need to perform a case-insensitive
 141                         // comparison if the Assert involves that path
 142
 143                         string configFile = Path.Combine (tempDir, "test.config");
 144                         string appBase = null;
 145                         string expectedAppBase = null;
 146
 147                         // do not set ApplicationBase
 148                         appBase = Path.GetDirectoryName (Environment.GetCommandLineArgs () [0]);
 149                         expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
 150                                 appBase : appBase + Path.DirectorySeparatorChar;
 151                         AppDomainSetup setup = new AppDomainSetup ();
 152                         setup.ConfigurationFile = configFile;
 153                         ad = CreateTestDomain (setup, true);
 154                         CrossDomainTester cdt = CreateCrossDomainTester (ad);
 155                         Assert.AreEqual (configFile, cdt.GetConfigurationFile (), "#A1");
 156                         if (RunningOnUnix) {
 157                                 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#A2");
 158                         } else {
 159                                 Assert.IsTrue (string.Compare (expectedAppBase, cdt.GetApplicationBase (), true) == 0, "#A2");
 160                         }
 161                         AppDomain.Unload (ad);
 162
 163                         // set ApplicationBase
 164                         appBase = Path.GetTempPath ();
 165                         expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
 166                                 appBase : appBase + Path.DirectorySeparatorChar;
 167                         setup = new AppDomainSetup ();
 168                         setup.ApplicationBase = appBase;
 169                         setup.ConfigurationFile = configFile;
 170                         ad = CreateTestDomain (setup, true);
 171                         cdt = CreateCrossDomainTester (ad);
 172                         Assert.AreEqual (configFile, cdt.GetConfigurationFile (), "#B1");
 173                         Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#B2");
 174                         AppDomain.Unload (ad);
 175                 }
 176
 177                 [Test] // bug #80934
 178                 public void ConfigurationFile_Null ()
 179                 {
 180                         // Note:
 181                         // We use Environment.GetCommandLineArgs () to get the location of
 182                         // the entry assembly in the default domain (since the default domain
 183                         // is not exposed by any API)
 184                         //
 185                         // MS returns a lower-case path in Environment.GetCommandLineArgs ()
 186                         // and hence we need to perform a case-insensitive comparison
 187                         // if the Assert involves that path
 188
 189                         string appBase = null;
 190                         string expectedAppBase = null;
 191                         string expectedConfigFile = null;
 192
 193                         // do not set ApplicationBase
 194                         appBase = Path.GetDirectoryName (Environment.GetCommandLineArgs () [0]);
 195                         expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
 196                                 appBase : appBase + Path.DirectorySeparatorChar;
 197                         expectedConfigFile = Environment.GetCommandLineArgs () [0] + ".config";
 198                         AppDomainSetup setup = new AppDomainSetup ();
 199                         setup.ConfigurationFile = null;
 200                         ad = CreateTestDomain (setup, true);
 201                         CrossDomainTester cdt = CreateCrossDomainTester (ad);
 202                         if (RunningOnUnix) {
 203                                 Assert.AreEqual (expectedConfigFile, cdt.GetConfigurationFile (), "#A1");
 204                                 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#A2");
 205                         } else {
 206                                 Assert.IsTrue (string.Compare (expectedConfigFile, cdt.GetConfigurationFile (), true) == 0, "#A1");
 207                                 Assert.IsTrue (string.Compare (expectedAppBase, cdt.GetApplicationBase (), true) == 0, "#A2");
 208                         }
 209                         AppDomain.Unload (ad);
 210
 211                         // set ApplicationBase
 212                         appBase = Path.GetTempPath ();
 213                         expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
 214                                 appBase : appBase + Path.DirectorySeparatorChar;
 215                         expectedConfigFile = Path.Combine (appBase, Path.GetFileName (Environment.GetCommandLineArgs () [0]) + ".config");
 216                         setup = new AppDomainSetup ();
 217                         setup.ApplicationBase = appBase;
 218                         setup.ConfigurationFile = null;
 219                         ad = CreateTestDomain (setup, true);
 220                         cdt = CreateCrossDomainTester (ad);
 221                         if (RunningOnUnix) {
 222                                 Assert.AreEqual (expectedConfigFile, cdt.GetConfigurationFile (), "#B1");
 223                         } else {
 224                                 Assert.IsTrue (string.Compare (expectedConfigFile, cdt.GetConfigurationFile (), true) == 0, "#B1");
 225                         }
 226                         Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#B2");
 227                         AppDomain.Unload (ad);
 228                 }
 229
 230                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess)
 231                 public void DefineDynamicAssembly1_Access_Invalid ()
 232                 {
 233                         AssemblyName name = new AssemblyName ();
 234                         name.Name = "DefineDynamicAssembly1";
 235
 236                         try {
 237                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 238                                         name, AssemblyBuilderAccess.Run |
 239                                         (AssemblyBuilderAccess) 666);
 240                                 Assert.Fail ("#1");
 241                         } catch (ArgumentException ex) {
 242                                 // Illegal enum value: 667
 243                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 244                                 Assert.IsNull (ex.InnerException, "#3");
 245                                 Assert.IsNotNull (ex.Message, "#4");
 246                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
 247                                 Assert.IsNotNull (ex.ParamName, "#6");
 248                                 Assert.AreEqual ("access", ex.ParamName, "#7");
 249                         }
 250                 }
 251
 252                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess)
 253                 public void DefineDynamicAssembly1_Name_InvalidChars ()
 254                 {
 255                         string [] invalid_char_names = new string [] {
 256                                 "\tAB",
 257                                 " AB",
 258                                 "\rAB",
 259                                 "A/B",
 260                                 ":AB",
 261                                 "B:A",
 262                                 "B\\A",
 263                                 "BA\\"};
 264
 265                         AssemblyName name = new AssemblyName ();
 266
 267                         foreach (string invalid_name in invalid_char_names) {
 268                                 name.Name = invalid_name;
 269                                 try {
 270                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
 271                                                 name,
 272                                                 AssemblyBuilderAccess.Run);
 273                                         Assert.Fail ("#1:" + invalid_name);
 274                                 } catch (ArgumentException ex) {
 275                                         // Assembly names may not begin with whitespace
 276                                         // or contain the characters '/', '\' or ':'
 277                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
 278                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
 279                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
 280                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
 281                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
 282                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
 283                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
 284                                 }
 285                         }
 286                 }
 287
 288                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess)
 289                 public void DefineDynamicAssembly1_Name_Null ()
 290                 {
 291                         try {
 292                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 293                                         (AssemblyName) null,
 294                                         AssemblyBuilderAccess.Run);
 295                                 Assert.Fail ("#A1");
 296                         } catch (ArgumentNullException ex) {
 297                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 298                                 Assert.IsNull (ex.InnerException, "#A3");
 299                                 Assert.IsNotNull (ex.Message, "#A4");
 300                                 Assert.IsNotNull (ex.ParamName, "#A5");
 301                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 302                         }
 303
 304                         AssemblyName name = new AssemblyName ();
 305
 306                         try {
 307                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 308                                         name,
 309                                         AssemblyBuilderAccess.Run);
 310                                 Assert.Fail ("#B1");
 311                         } catch (ArgumentException ex) {
 312                                 // AssemblyName.Name cannot be null or an empty string
 313                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 314                                 Assert.IsNull (ex.InnerException, "#B3");
 315                                 Assert.IsNotNull (ex.Message, "#B4");
 316                                 Assert.IsNull (ex.ParamName, "#B5");
 317                         }
 318
 319                         name.Name = string.Empty;
 320
 321                         try {
 322                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 323                                         name,
 324                                         AssemblyBuilderAccess.Run);
 325                                 Assert.Fail ("#C1");
 326                         } catch (ArgumentException ex) {
 327                                 // AssemblyName.Name cannot be null or an empty string
 328                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 329                                 Assert.IsNull (ex.InnerException, "#C3");
 330                                 Assert.IsNotNull (ex.Message, "#C4");
 331                                 Assert.IsNull (ex.ParamName, "#C5");
 332                         }
 333                 }
 334
 335                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence)
 336                 public void DefineDynamicAssembly2_Access_Invalid ()
 337                 {
 338                         AssemblyName name = new AssemblyName ();
 339                         name.Name = "DefineDynamicAssembly2";
 340
 341 #if NET_2_0
 342                         try {
 343                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 344                                         name, AssemblyBuilderAccess.Run |
 345                                         (AssemblyBuilderAccess) 666,
 346                                         AppDomain.CurrentDomain.Evidence);
 347                                 Assert.Fail ("#1");
 348                         } catch (ArgumentException ex) {
 349                                 // Illegal enum value: 667
 350                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 351                                 Assert.IsNull (ex.InnerException, "#3");
 352                                 Assert.IsNotNull (ex.Message, "#4");
 353                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
 354                                 Assert.IsNotNull (ex.ParamName, "#6");
 355                                 Assert.AreEqual ("access", ex.ParamName, "#7");
 356                         }
 357 #else
 358                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 359                                 name, AssemblyBuilderAccess.Run |
 360                                 (AssemblyBuilderAccess) 666,
 361                                 AppDomain.CurrentDomain.Evidence);
 362                         Assert.IsNotNull (ab, "#1");
 363 #endif
 364                 }
 365
 366                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence)
 367                 public void DefineDynamicAssembly2_Name_InvalidChars ()
 368                 {
 369                         string [] invalid_char_names = new string [] {
 370                                 "\tAB",
 371                                 " AB",
 372                                 "\rAB",
 373                                 "A/B",
 374                                 ":AB",
 375                                 "B:A",
 376                                 "B\\A",
 377                                 "BA\\"};
 378
 379                         AssemblyName name = new AssemblyName ();
 380
 381                         foreach (string invalid_name in invalid_char_names) {
 382                                 name.Name = invalid_name;
 383                                 try {
 384                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
 385                                                 name,
 386                                                 AssemblyBuilderAccess.Run,
 387                                                 AppDomain.CurrentDomain.Evidence);
 388                                         Assert.Fail ("#1:" + invalid_name);
 389                                 } catch (ArgumentException ex) {
 390                                         // Assembly names may not begin with whitespace
 391                                         // or contain the characters '/', '\' or ':'
 392                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
 393                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
 394                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
 395                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
 396                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
 397                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
 398                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
 399                                 }
 400                         }
 401                 }
 402
 403                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence)
 404                 public void DefineDynamicAssembly2_Name_Null ()
 405                 {
 406                         try {
 407                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 408                                         (AssemblyName) null,
 409                                         AssemblyBuilderAccess.Run,
 410                                         AppDomain.CurrentDomain.Evidence);
 411                                 Assert.Fail ("#A1");
 412                         } catch (ArgumentNullException ex) {
 413                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 414                                 Assert.IsNull (ex.InnerException, "#A3");
 415                                 Assert.IsNotNull (ex.Message, "#A4");
 416                                 Assert.IsNotNull (ex.ParamName, "#A5");
 417                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 418                         }
 419
 420                         AssemblyName name = new AssemblyName ();
 421
 422                         try {
 423                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 424                                         name,
 425                                         AssemblyBuilderAccess.Run,
 426                                         AppDomain.CurrentDomain.Evidence);
 427                                 Assert.Fail ("#B1");
 428                         } catch (ArgumentException ex) {
 429                                 // AssemblyName.Name cannot be null or an empty string
 430                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 431                                 Assert.IsNull (ex.InnerException, "#B3");
 432                                 Assert.IsNotNull (ex.Message, "#B4");
 433                                 Assert.IsNull (ex.ParamName, "#B5");
 434                         }
 435
 436                         name.Name = string.Empty;
 437
 438                         try {
 439                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 440                                         name,
 441                                         AssemblyBuilderAccess.Run,
 442                                         AppDomain.CurrentDomain.Evidence);
 443                                 Assert.Fail ("#C1");
 444                         } catch (ArgumentException ex) {
 445                                 // AssemblyName.Name cannot be null or an empty string
 446                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 447                                 Assert.IsNull (ex.InnerException, "#C3");
 448                                 Assert.IsNotNull (ex.Message, "#C4");
 449                                 Assert.IsNull (ex.ParamName, "#C5");
 450                         }
 451                 }
 452
 453                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String)
 454                 public void DefineDynamicAssembly3_Access_Invalid ()
 455                 {
 456                         AssemblyName name = new AssemblyName ();
 457                         name.Name = "DefineDynamicAssembly3";
 458
 459 #if NET_2_0
 460                         try {
 461                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 462                                         name, AssemblyBuilderAccess.Run |
 463                                         (AssemblyBuilderAccess) 666,
 464                                         Path.GetTempPath ());
 465                                 Assert.Fail ("#1");
 466                         } catch (ArgumentException ex) {
 467                                 // Illegal enum value: 667
 468                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 469                                 Assert.IsNull (ex.InnerException, "#3");
 470                                 Assert.IsNotNull (ex.Message, "#4");
 471                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
 472                                 Assert.IsNotNull (ex.ParamName, "#6");
 473                                 Assert.AreEqual ("access", ex.ParamName, "#7");
 474                         }
 475 #else
 476                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 477                                 name, AssemblyBuilderAccess.Run |
 478                                 (AssemblyBuilderAccess) 666,
 479                                 Path.GetTempPath ());
 480                         Assert.IsNotNull (ab, "#1");
 481 #endif
 482                 }
 483
 484                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String)
 485                 public void DefineDynamicAssembly3_Name_InvalidChars ()
 486                 {
 487                         string [] invalid_char_names = new string [] {
 488                                 "\tAB",
 489                                 " AB",
 490                                 "\rAB",
 491                                 "A/B",
 492                                 ":AB",
 493                                 "B:A",
 494                                 "B\\A",
 495                                 "BA\\"};
 496
 497                         AssemblyName name = new AssemblyName ();
 498
 499                         foreach (string invalid_name in invalid_char_names) {
 500                                 name.Name = invalid_name;
 501                                 try {
 502                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
 503                                                 name,
 504                                                 AssemblyBuilderAccess.Run,
 505                                                 Path.GetTempPath ());
 506                                         Assert.Fail ("#1:" + invalid_name);
 507                                 } catch (ArgumentException ex) {
 508                                         // Assembly names may not begin with whitespace
 509                                         // or contain the characters '/', '\' or ':'
 510                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
 511                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
 512                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
 513                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
 514                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
 515                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
 516                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
 517                                 }
 518                         }
 519                 }
 520
 521                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String)
 522                 public void DefineDynamicAssembly3_Name_Null ()
 523                 {
 524                         try {
 525                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 526                                         (AssemblyName) null,
 527                                         AssemblyBuilderAccess.Run,
 528                                         Path.GetTempPath ());
 529                                 Assert.Fail ("#A1");
 530                         } catch (ArgumentNullException ex) {
 531                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 532                                 Assert.IsNull (ex.InnerException, "#A3");
 533                                 Assert.IsNotNull (ex.Message, "#A4");
 534                                 Assert.IsNotNull (ex.ParamName, "#A5");
 535                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 536                         }
 537
 538                         AssemblyName name = new AssemblyName ();
 539
 540                         try {
 541                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 542                                         name,
 543                                         AssemblyBuilderAccess.Run,
 544                                         Path.GetTempPath ());
 545                                 Assert.Fail ("#B1");
 546                         } catch (ArgumentException ex) {
 547                                 // AssemblyName.Name cannot be null or an empty string
 548                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 549                                 Assert.IsNull (ex.InnerException, "#B3");
 550                                 Assert.IsNotNull (ex.Message, "#B4");
 551                                 Assert.IsNull (ex.ParamName, "#B5");
 552                         }
 553
 554                         name.Name = string.Empty;
 555
 556                         try {
 557                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 558                                         name,
 559                                         AssemblyBuilderAccess.Run,
 560                                         Path.GetTempPath ());
 561                                 Assert.Fail ("#C1");
 562                         } catch (ArgumentException ex) {
 563                                 // AssemblyName.Name cannot be null or an empty string
 564                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 565                                 Assert.IsNull (ex.InnerException, "#C3");
 566                                 Assert.IsNotNull (ex.Message, "#C4");
 567                                 Assert.IsNull (ex.ParamName, "#C5");
 568                         }
 569                 }
 570
 571                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence)
 572                 public void DefineDynamicAssembly4_Access_Invalid ()
 573                 {
 574                         AssemblyName name = new AssemblyName ();
 575                         name.Name = "DefineDynamicAssembly4";
 576
 577 #if NET_2_0
 578                         try {
 579                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 580                                         name, AssemblyBuilderAccess.Run |
 581                                         (AssemblyBuilderAccess) 666,
 582                                         Path.GetTempPath (),
 583                                         AppDomain.CurrentDomain.Evidence);
 584                                 Assert.Fail ("#1");
 585                         } catch (ArgumentException ex) {
 586                                 // Illegal enum value: 667
 587                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 588                                 Assert.IsNull (ex.InnerException, "#3");
 589                                 Assert.IsNotNull (ex.Message, "#4");
 590                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
 591                                 Assert.IsNotNull (ex.ParamName, "#6");
 592                                 Assert.AreEqual ("access", ex.ParamName, "#7");
 593                         }
 594 #else
 595                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 596                                 name, AssemblyBuilderAccess.Run |
 597                                 (AssemblyBuilderAccess) 666,
 598                                 Path.GetTempPath (),
 599                                 AppDomain.CurrentDomain.Evidence);
 600                         Assert.IsNotNull (ab, "#1");
 601 #endif
 602                 }
 603
 604                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence)
 605                 public void DefineDynamicAssembly4_Name_InvalidChars ()
 606                 {
 607                         string [] invalid_char_names = new string [] {
 608                                 "\tAB",
 609                                 " AB",
 610                                 "\rAB",
 611                                 "A/B",
 612                                 ":AB",
 613                                 "B:A",
 614                                 "B\\A",
 615                                 "BA\\"};
 616
 617                         AssemblyName name = new AssemblyName ();
 618
 619                         foreach (string invalid_name in invalid_char_names) {
 620                                 name.Name = invalid_name;
 621                                 try {
 622                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
 623                                                 name,
 624                                                 AssemblyBuilderAccess.Run,
 625                                                 Path.GetTempPath (),
 626                                                 AppDomain.CurrentDomain.Evidence);
 627                                         Assert.Fail ("#1:" + invalid_name);
 628                                 } catch (ArgumentException ex) {
 629                                         // Assembly names may not begin with whitespace
 630                                         // or contain the characters '/', '\' or ':'
 631                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
 632                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
 633                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
 634                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
 635                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
 636                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
 637                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
 638                                 }
 639                         }
 640                 }
 641
 642                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence)
 643                 public void DefineDynamicAssembly4_Name_Null ()
 644                 {
 645                         try {
 646                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 647                                         (AssemblyName) null,
 648                                         AssemblyBuilderAccess.Run,
 649                                         Path.GetTempPath (),
 650                                         AppDomain.CurrentDomain.Evidence);
 651                                 Assert.Fail ("#A1");
 652                         } catch (ArgumentNullException ex) {
 653                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 654                                 Assert.IsNull (ex.InnerException, "#A3");
 655                                 Assert.IsNotNull (ex.Message, "#A4");
 656                                 Assert.IsNotNull (ex.ParamName, "#A5");
 657                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 658                         }
 659
 660                         AssemblyName name = new AssemblyName ();
 661
 662                         try {
 663                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 664                                         name,
 665                                         AssemblyBuilderAccess.Run,
 666                                         Path.GetTempPath (),
 667                                         AppDomain.CurrentDomain.Evidence);
 668                                 Assert.Fail ("#B1");
 669                         } catch (ArgumentException ex) {
 670                                 // AssemblyName.Name cannot be null or an empty string
 671                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 672                                 Assert.IsNull (ex.InnerException, "#B3");
 673                                 Assert.IsNotNull (ex.Message, "#B4");
 674                                 Assert.IsNull (ex.ParamName, "#B5");
 675                         }
 676
 677                         name.Name = string.Empty;
 678
 679                         try {
 680                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 681                                         name,
 682                                         AssemblyBuilderAccess.Run,
 683                                         Path.GetTempPath (),
 684                                         AppDomain.CurrentDomain.Evidence);
 685                                 Assert.Fail ("#C1");
 686                         } catch (ArgumentException ex) {
 687                                 // AssemblyName.Name cannot be null or an empty string
 688                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 689                                 Assert.IsNull (ex.InnerException, "#C3");
 690                                 Assert.IsNotNull (ex.Message, "#C4");
 691                                 Assert.IsNull (ex.ParamName, "#C5");
 692                         }
 693                 }
 694
 695                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)
 696                 public void DefineDynamicAssembly5_Access_Invalid ()
 697                 {
 698                         AssemblyName name = new AssemblyName ();
 699                         name.Name = "DefineDynamicAssembly5";
 700
 701 #if NET_2_0
 702                         try {
 703                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 704                                         name, AssemblyBuilderAccess.Run |
 705                                         (AssemblyBuilderAccess) 666,
 706                                         (PermissionSet) null,
 707                                         (PermissionSet) null,
 708                                         (PermissionSet) null);
 709                                 Assert.Fail ("#1");
 710                         } catch (ArgumentException ex) {
 711                                 // Illegal enum value: 667
 712                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 713                                 Assert.IsNull (ex.InnerException, "#3");
 714                                 Assert.IsNotNull (ex.Message, "#4");
 715                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
 716                                 Assert.IsNotNull (ex.ParamName, "#6");
 717                                 Assert.AreEqual ("access", ex.ParamName, "#7");
 718                         }
 719 #else
 720                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 721                                 name, AssemblyBuilderAccess.Run |
 722                                 (AssemblyBuilderAccess) 666,
 723                                 (PermissionSet) null,
 724                                 (PermissionSet) null,
 725                                 (PermissionSet) null);
 726                         Assert.IsNotNull (ab, "#1");
 727 #endif
 728                 }
 729
 730                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)
 731                 public void DefineDynamicAssembly5_Name_InvalidChars ()
 732                 {
 733                         string [] invalid_char_names = new string [] {
 734                                 "\tAB",
 735                                 " AB",
 736                                 "\rAB",
 737                                 "A/B",
 738                                 ":AB",
 739                                 "B:A",
 740                                 "B\\A",
 741                                 "BA\\"};
 742
 743                         AssemblyName name = new AssemblyName ();
 744
 745                         foreach (string invalid_name in invalid_char_names) {
 746                                 name.Name = invalid_name;
 747                                 try {
 748                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
 749                                                 name,
 750                                                 AssemblyBuilderAccess.Run,
 751                                                 (PermissionSet) null,
 752                                                 (PermissionSet) null,
 753                                                 (PermissionSet) null);
 754                                         Assert.Fail ("#1:" + invalid_name);
 755                                 } catch (ArgumentException ex) {
 756                                         // Assembly names may not begin with whitespace
 757                                         // or contain the characters '/', '\' or ':'
 758                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
 759                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
 760                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
 761                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
 762                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
 763                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
 764                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
 765                                 }
 766                         }
 767                 }
 768
 769                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)
 770                 public void DefineDynamicAssembly5_Name_Null ()
 771                 {
 772                         try {
 773                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 774                                         (AssemblyName) null,
 775                                         AssemblyBuilderAccess.Run,
 776                                         (PermissionSet) null,
 777                                         (PermissionSet) null,
 778                                         (PermissionSet) null);
 779                                 Assert.Fail ("#A1");
 780                         } catch (ArgumentNullException ex) {
 781                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 782                                 Assert.IsNull (ex.InnerException, "#A3");
 783                                 Assert.IsNotNull (ex.Message, "#A4");
 784                                 Assert.IsNotNull (ex.ParamName, "#A5");
 785                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 786                         }
 787
 788                         AssemblyName name = new AssemblyName ();
 789
 790                         try {
 791                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 792                                         name,
 793                                         AssemblyBuilderAccess.Run,
 794                                         (PermissionSet) null,
 795                                         (PermissionSet) null,
 796                                         (PermissionSet) null);
 797                                 Assert.Fail ("#B1");
 798                         } catch (ArgumentException ex) {
 799                                 // AssemblyName.Name cannot be null or an empty string
 800                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 801                                 Assert.IsNull (ex.InnerException, "#B3");
 802                                 Assert.IsNotNull (ex.Message, "#B4");
 803                                 Assert.IsNull (ex.ParamName, "#B5");
 804                         }
 805
 806                         name.Name = string.Empty;
 807
 808                         try {
 809                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 810                                         name,
 811                                         AssemblyBuilderAccess.Run,
 812                                         (PermissionSet) null,
 813                                         (PermissionSet) null,
 814                                         (PermissionSet) null);
 815                                 Assert.Fail ("#C1");
 816                         } catch (ArgumentException ex) {
 817                                 // AssemblyName.Name cannot be null or an empty string
 818                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 819                                 Assert.IsNull (ex.InnerException, "#C3");
 820                                 Assert.IsNotNull (ex.Message, "#C4");
 821                                 Assert.IsNull (ex.ParamName, "#C5");
 822                         }
 823                 }
 824
 825                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)
 826                 public void DefineDynamicAssembly6_Access_Invalid ()
 827                 {
 828                         AssemblyName name = new AssemblyName ();
 829                         name.Name = "DefineDynamicAssembly6";
 830
 831 #if NET_2_0
 832                         try {
 833                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 834                                         name, AssemblyBuilderAccess.Run |
 835                                         (AssemblyBuilderAccess) 666,
 836                                         AppDomain.CurrentDomain.Evidence,
 837                                         (PermissionSet) null,
 838                                         (PermissionSet) null,
 839                                         (PermissionSet) null);
 840                                 Assert.Fail ("#1");
 841                         } catch (ArgumentException ex) {
 842                                 // Illegal enum value: 667
 843                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 844                                 Assert.IsNull (ex.InnerException, "#3");
 845                                 Assert.IsNotNull (ex.Message, "#4");
 846                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
 847                                 Assert.IsNotNull (ex.ParamName, "#6");
 848                                 Assert.AreEqual ("access", ex.ParamName, "#7");
 849                         }
 850 #else
 851                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 852                                 name, AssemblyBuilderAccess.Run |
 853                                 (AssemblyBuilderAccess) 666,
 854                                 AppDomain.CurrentDomain.Evidence,
 855                                 (PermissionSet) null,
 856                                 (PermissionSet) null,
 857                                 (PermissionSet) null);
 858                         Assert.IsNotNull (ab, "#1");
 859 #endif
 860                 }
 861
 862                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)
 863                 public void DefineDynamicAssembly6_Name_InvalidChars ()
 864                 {
 865                         string [] invalid_char_names = new string [] {
 866                                 "\tAB",
 867                                 " AB",
 868                                 "\rAB",
 869                                 "A/B",
 870                                 ":AB",
 871                                 "B:A",
 872                                 "B\\A",
 873                                 "BA\\"};
 874
 875                         AssemblyName name = new AssemblyName ();
 876
 877                         foreach (string invalid_name in invalid_char_names) {
 878                                 name.Name = invalid_name;
 879                                 try {
 880                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
 881                                                 name,
 882                                                 AssemblyBuilderAccess.Run,
 883                                                 AppDomain.CurrentDomain.Evidence,
 884                                                 (PermissionSet) null,
 885                                                 (PermissionSet) null,
 886                                                 (PermissionSet) null);
 887                                         Assert.Fail ("#1:" + invalid_name);
 888                                 } catch (ArgumentException ex) {
 889                                         // Assembly names may not begin with whitespace
 890                                         // or contain the characters '/', '\' or ':'
 891                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
 892                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
 893                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
 894                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
 895                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
 896                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
 897                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
 898                                 }
 899                         }
 900                 }
 901
 902                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)
 903                 public void DefineDynamicAssembly6_Name_Null ()
 904                 {
 905                         try {
 906                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 907                                         (AssemblyName) null,
 908                                         AssemblyBuilderAccess.Run,
 909                                         AppDomain.CurrentDomain.Evidence,
 910                                         (PermissionSet) null,
 911                                         (PermissionSet) null,
 912                                         (PermissionSet) null);
 913                                 Assert.Fail ("#A1");
 914                         } catch (ArgumentNullException ex) {
 915                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 916                                 Assert.IsNull (ex.InnerException, "#A3");
 917                                 Assert.IsNotNull (ex.Message, "#A4");
 918                                 Assert.IsNotNull (ex.ParamName, "#A5");
 919                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 920                         }
 921
 922                         AssemblyName name = new AssemblyName ();
 923
 924                         try {
 925                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 926                                         name,
 927                                         AssemblyBuilderAccess.Run,
 928                                         AppDomain.CurrentDomain.Evidence,
 929                                         (PermissionSet) null,
 930                                         (PermissionSet) null,
 931                                         (PermissionSet) null);
 932                                 Assert.Fail ("#B1");
 933                         } catch (ArgumentException ex) {
 934                                 // AssemblyName.Name cannot be null or an empty string
 935                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 936                                 Assert.IsNull (ex.InnerException, "#B3");
 937                                 Assert.IsNotNull (ex.Message, "#B4");
 938                                 Assert.IsNull (ex.ParamName, "#B5");
 939                         }
 940
 941                         name.Name = string.Empty;
 942
 943                         try {
 944                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 945                                         name,
 946                                         AssemblyBuilderAccess.Run,
 947                                         AppDomain.CurrentDomain.Evidence,
 948                                         (PermissionSet) null,
 949                                         (PermissionSet) null,
 950                                         (PermissionSet) null);
 951                                 Assert.Fail ("#C1");
 952                         } catch (ArgumentException ex) {
 953                                 // AssemblyName.Name cannot be null or an empty string
 954                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 955                                 Assert.IsNull (ex.InnerException, "#C3");
 956                                 Assert.IsNotNull (ex.Message, "#C4");
 957                                 Assert.IsNull (ex.ParamName, "#C5");
 958                         }
 959                 }
 960
 961                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)
 962                 public void DefineDynamicAssembly7_Access_Invalid ()
 963                 {
 964                         AssemblyName name = new AssemblyName ();
 965                         name.Name = "DefineDynamicAssembly7";
 966
 967 #if NET_2_0
 968                         try {
 969                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
 970                                         name, AssemblyBuilderAccess.Run |
 971                                         (AssemblyBuilderAccess) 666,
 972                                         Path.GetTempPath (),
 973                                         (PermissionSet) null,
 974                                         (PermissionSet) null,
 975                                         (PermissionSet) null);
 976                                 Assert.Fail ("#1");
 977                         } catch (ArgumentException ex) {
 978                                 // Illegal enum value: 667
 979                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 980                                 Assert.IsNull (ex.InnerException, "#3");
 981                                 Assert.IsNotNull (ex.Message, "#4");
 982                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
 983                                 Assert.IsNotNull (ex.ParamName, "#6");
 984                                 Assert.AreEqual ("access", ex.ParamName, "#7");
 985                         }
 986 #else
 987                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
 988                                 name, AssemblyBuilderAccess.Run |
 989                                 (AssemblyBuilderAccess) 666,
 990                                 Path.GetTempPath (),
 991                                 (PermissionSet) null,
 992                                 (PermissionSet) null,
 993                                 (PermissionSet) null);
 994                         Assert.IsNotNull (ab, "#1");
 995 #endif
 996                 }
 997
 998                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)
 999                 public void DefineDynamicAssembly7_Name_InvalidChars ()
1000                 {
1001                         string [] invalid_char_names = new string [] {
1002                                 "\tAB",
1003                                 " AB",
1004                                 "\rAB",
1005                                 "A/B",
1006                                 ":AB",
1007                                 "B:A",
1008                                 "B\\A",
1009                                 "BA\\"};
1010
1011                         AssemblyName name = new AssemblyName ();
1012
1013                         foreach (string invalid_name in invalid_char_names) {
1014                                 name.Name = invalid_name;
1015                                 try {
1016                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
1017                                                 name,
1018                                                 AssemblyBuilderAccess.Run,
1019                                                 Path.GetTempPath (),
1020                                                 (PermissionSet) null,
1021                                                 (PermissionSet) null,
1022                                                 (PermissionSet) null);
1023                                         Assert.Fail ("#1:" + invalid_name);
1024                                 } catch (ArgumentException ex) {
1025                                         // Assembly names may not begin with whitespace
1026                                         // or contain the characters '/', '\' or ':'
1027                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1028                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1029                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1030                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1031                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1032                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1033                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1034                                 }
1035                         }
1036                 }
1037
1038                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)
1039                 public void DefineDynamicAssembly7_Name_Null ()
1040                 {
1041                         try {
1042                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1043                                         (AssemblyName) null,
1044                                         AssemblyBuilderAccess.Run,
1045                                         Path.GetTempPath (),
1046                                         (PermissionSet) null,
1047                                         (PermissionSet) null,
1048                                         (PermissionSet) null);
1049                                 Assert.Fail ("#A1");
1050                         } catch (ArgumentNullException ex) {
1051                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1052                                 Assert.IsNull (ex.InnerException, "#A3");
1053                                 Assert.IsNotNull (ex.Message, "#A4");
1054                                 Assert.IsNotNull (ex.ParamName, "#A5");
1055                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
1056                         }
1057
1058                         AssemblyName name = new AssemblyName ();
1059
1060                         try {
1061                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1062                                         name,
1063                                         AssemblyBuilderAccess.Run,
1064                                         Path.GetTempPath (),
1065                                         (PermissionSet) null,
1066                                         (PermissionSet) null,
1067                                         (PermissionSet) null);
1068                                 Assert.Fail ("#B1");
1069                         } catch (ArgumentException ex) {
1070                                 // AssemblyName.Name cannot be null or an empty string
1071                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1072                                 Assert.IsNull (ex.InnerException, "#B3");
1073                                 Assert.IsNotNull (ex.Message, "#B4");
1074                                 Assert.IsNull (ex.ParamName, "#B5");
1075                         }
1076
1077                         name.Name = string.Empty;
1078
1079                         try {
1080                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1081                                         name,
1082                                         AssemblyBuilderAccess.Run,
1083                                         Path.GetTempPath (),
1084                                         (PermissionSet) null,
1085                                         (PermissionSet) null,
1086                                         (PermissionSet) null);
1087                                 Assert.Fail ("#C1");
1088                         } catch (ArgumentException ex) {
1089                                 // AssemblyName.Name cannot be null or an empty string
1090                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1091                                 Assert.IsNull (ex.InnerException, "#C3");
1092                                 Assert.IsNotNull (ex.Message, "#C4");
1093                                 Assert.IsNull (ex.ParamName, "#C5");
1094                         }
1095                 }
1096
1097                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)
1098                 public void DefineDynamicAssembly8_Access_Invalid ()
1099                 {
1100                         AssemblyName name = new AssemblyName ();
1101                         name.Name = "DefineDynamicAssembly8";
1102
1103 #if NET_2_0
1104                         try {
1105                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1106                                         name, AssemblyBuilderAccess.Run |
1107                                         (AssemblyBuilderAccess) 666,
1108                                         Path.GetTempPath (),
1109                                         AppDomain.CurrentDomain.Evidence,
1110                                         (PermissionSet) null,
1111                                         (PermissionSet) null,
1112                                         (PermissionSet) null);
1113                                 Assert.Fail ("#1");
1114                         } catch (ArgumentException ex) {
1115                                 // Illegal enum value: 667
1116                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1117                                 Assert.IsNull (ex.InnerException, "#3");
1118                                 Assert.IsNotNull (ex.Message, "#4");
1119                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
1120                                 Assert.IsNotNull (ex.ParamName, "#6");
1121                                 Assert.AreEqual ("access", ex.ParamName, "#7");
1122                         }
1123 #else
1124                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1125                                 name, AssemblyBuilderAccess.Run |
1126                                 (AssemblyBuilderAccess) 666,
1127                                 Path.GetTempPath (),
1128                                 AppDomain.CurrentDomain.Evidence,
1129                                 (PermissionSet) null,
1130                                 (PermissionSet) null,
1131                                 (PermissionSet) null);
1132                         Assert.IsNotNull (ab, "#1");
1133 #endif
1134                 }
1135
1136                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)
1137                 public void DefineDynamicAssembly8_Name_InvalidChars ()
1138                 {
1139                         string [] invalid_char_names = new string [] {
1140                                 "\tAB",
1141                                 " AB",
1142                                 "\rAB",
1143                                 "A/B",
1144                                 ":AB",
1145                                 "B:A",
1146                                 "B\\A",
1147                                 "BA\\"};
1148
1149                         AssemblyName name = new AssemblyName ();
1150
1151                         foreach (string invalid_name in invalid_char_names) {
1152                                 name.Name = invalid_name;
1153                                 try {
1154                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
1155                                                 name,
1156                                                 AssemblyBuilderAccess.Run,
1157                                                 Path.GetTempPath (),
1158                                                 AppDomain.CurrentDomain.Evidence,
1159                                                 (PermissionSet) null,
1160                                                 (PermissionSet) null,
1161                                                 (PermissionSet) null);
1162                                         Assert.Fail ("#1:" + invalid_name);
1163                                 } catch (ArgumentException ex) {
1164                                         // Assembly names may not begin with whitespace
1165                                         // or contain the characters '/', '\' or ':'
1166                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1167                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1168                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1169                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1170                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1171                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1172                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1173                                 }
1174                         }
1175                 }
1176
1177                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)
1178                 public void DefineDynamicAssembly8_Name_Null ()
1179                 {
1180                         try {
1181                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1182                                         (AssemblyName) null,
1183                                         AssemblyBuilderAccess.Run,
1184                                         Path.GetTempPath (),
1185                                         AppDomain.CurrentDomain.Evidence,
1186                                         (PermissionSet) null,
1187                                         (PermissionSet) null,
1188                                         (PermissionSet) null);
1189                                 Assert.Fail ("#A1");
1190                         } catch (ArgumentNullException ex) {
1191                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1192                                 Assert.IsNull (ex.InnerException, "#A3");
1193                                 Assert.IsNotNull (ex.Message, "#A4");
1194                                 Assert.IsNotNull (ex.ParamName, "#A5");
1195                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
1196                         }
1197
1198                         AssemblyName name = new AssemblyName ();
1199
1200                         try {
1201                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1202                                         name,
1203                                         AssemblyBuilderAccess.Run,
1204                                         Path.GetTempPath (),
1205                                         AppDomain.CurrentDomain.Evidence,
1206                                         (PermissionSet) null,
1207                                         (PermissionSet) null,
1208                                         (PermissionSet) null);
1209                                 Assert.Fail ("#B1");
1210                         } catch (ArgumentException ex) {
1211                                 // AssemblyName.Name cannot be null or an empty string
1212                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1213                                 Assert.IsNull (ex.InnerException, "#B3");
1214                                 Assert.IsNotNull (ex.Message, "#B4");
1215                                 Assert.IsNull (ex.ParamName, "#B5");
1216                         }
1217
1218                         name.Name = string.Empty;
1219
1220                         try {
1221                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1222                                         name,
1223                                         AssemblyBuilderAccess.Run,
1224                                         Path.GetTempPath (),
1225                                         AppDomain.CurrentDomain.Evidence,
1226                                         (PermissionSet) null,
1227                                         (PermissionSet) null,
1228                                         (PermissionSet) null);
1229                                 Assert.Fail ("#C1");
1230                         } catch (ArgumentException ex) {
1231                                 // AssemblyName.Name cannot be null or an empty string
1232                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1233                                 Assert.IsNull (ex.InnerException, "#C3");
1234                                 Assert.IsNotNull (ex.Message, "#C4");
1235                                 Assert.IsNull (ex.ParamName, "#C5");
1236                         }
1237                 }
1238
1239                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)
1240                 public void DefineDynamicAssembly9_Access_Invalid ()
1241                 {
1242                         AssemblyName name = new AssemblyName ();
1243                         name.Name = "DefineDynamicAssembly9";
1244
1245 #if NET_2_0
1246                         try {
1247                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1248                                         name, AssemblyBuilderAccess.Run |
1249                                         (AssemblyBuilderAccess) 666,
1250                                         Path.GetTempPath (),
1251                                         AppDomain.CurrentDomain.Evidence,
1252                                         (PermissionSet) null,
1253                                         (PermissionSet) null,
1254                                         (PermissionSet) null,
1255                                         true);
1256                                 Assert.Fail ("#1");
1257                         } catch (ArgumentException ex) {
1258                                 // Illegal enum value: 667
1259                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1260                                 Assert.IsNull (ex.InnerException, "#3");
1261                                 Assert.IsNotNull (ex.Message, "#4");
1262                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
1263                                 Assert.IsNotNull (ex.ParamName, "#6");
1264                                 Assert.AreEqual ("access", ex.ParamName, "#7");
1265                         }
1266 #else
1267                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1268                                 name, AssemblyBuilderAccess.Run |
1269                                 (AssemblyBuilderAccess) 666,
1270                                 Path.GetTempPath (),
1271                                 AppDomain.CurrentDomain.Evidence,
1272                                 (PermissionSet) null,
1273                                 (PermissionSet) null,
1274                                 (PermissionSet) null,
1275                                 true);
1276                         Assert.IsNotNull (ab, "#1");
1277 #endif
1278                 }
1279
1280                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)
1281                 public void DefineDynamicAssembly9_Name_InvalidChars ()
1282                 {
1283                         string [] invalid_char_names = new string [] {
1284                                 "\tAB",
1285                                 " AB",
1286                                 "\rAB",
1287                                 "A/B",
1288                                 ":AB",
1289                                 "B:A",
1290                                 "B\\A",
1291                                 "BA\\"};
1292
1293                         AssemblyName name = new AssemblyName ();
1294
1295                         foreach (string invalid_name in invalid_char_names) {
1296                                 name.Name = invalid_name;
1297                                 try {
1298                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
1299                                                 name,
1300                                                 AssemblyBuilderAccess.Run,
1301                                                 Path.GetTempPath (),
1302                                                 AppDomain.CurrentDomain.Evidence,
1303                                                 (PermissionSet) null,
1304                                                 (PermissionSet) null,
1305                                                 (PermissionSet) null,
1306                                                 true);
1307                                         Assert.Fail ("#1:" + invalid_name);
1308                                 } catch (ArgumentException ex) {
1309                                         // Assembly names may not begin with whitespace
1310                                         // or contain the characters '/', '\' or ':'
1311                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1312                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1313                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1314                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1315                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1316                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1317                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1318                                 }
1319                         }
1320                 }
1321
1322                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)
1323                 public void DefineDynamicAssembly9_Name_Null ()
1324                 {
1325                         try {
1326                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1327                                         (AssemblyName) null,
1328                                         AssemblyBuilderAccess.Run,
1329                                         Path.GetTempPath (),
1330                                         AppDomain.CurrentDomain.Evidence,
1331                                         (PermissionSet) null,
1332                                         (PermissionSet) null,
1333                                         (PermissionSet) null,
1334                                         true);
1335                                 Assert.Fail ("#A1");
1336                         } catch (ArgumentNullException ex) {
1337                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1338                                 Assert.IsNull (ex.InnerException, "#A3");
1339                                 Assert.IsNotNull (ex.Message, "#A4");
1340                                 Assert.IsNotNull (ex.ParamName, "#A5");
1341                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
1342                         }
1343
1344                         AssemblyName name = new AssemblyName ();
1345
1346                         try {
1347                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1348                                         name,
1349                                         AssemblyBuilderAccess.Run,
1350                                         Path.GetTempPath (),
1351                                         AppDomain.CurrentDomain.Evidence,
1352                                         (PermissionSet) null,
1353                                         (PermissionSet) null,
1354                                         (PermissionSet) null,
1355                                         true);
1356                                 Assert.Fail ("#B1");
1357                         } catch (ArgumentException ex) {
1358                                 // AssemblyName.Name cannot be null or an empty string
1359                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1360                                 Assert.IsNull (ex.InnerException, "#B3");
1361                                 Assert.IsNotNull (ex.Message, "#B4");
1362                                 Assert.IsNull (ex.ParamName, "#B5");
1363                         }
1364
1365                         name.Name = string.Empty;
1366
1367                         try {
1368                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1369                                         name,
1370                                         AssemblyBuilderAccess.Run,
1371                                         Path.GetTempPath (),
1372                                         AppDomain.CurrentDomain.Evidence,
1373                                         (PermissionSet) null,
1374                                         (PermissionSet) null,
1375                                         (PermissionSet) null,
1376                                         true);
1377                                 Assert.Fail ("#C1");
1378                         } catch (ArgumentException ex) {
1379                                 // AssemblyName.Name cannot be null or an empty string
1380                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1381                                 Assert.IsNull (ex.InnerException, "#C3");
1382                                 Assert.IsNotNull (ex.Message, "#C4");
1383                                 Assert.IsNull (ex.ParamName, "#C5");
1384                         }
1385                 }
1386
1387 #if NET_2_0
1388                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
1389                 public void DefineDynamicAssembly10_Access_Invalid ()
1390                 {
1391                         AssemblyName name = new AssemblyName ();
1392                         name.Name = "DefineDynamicAssembly10";
1393
1394 #if NET_2_0
1395                         try {
1396                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1397                                         name, AssemblyBuilderAccess.Run |
1398                                         (AssemblyBuilderAccess) 666,
1399                                         Path.GetTempPath (),
1400                                         AppDomain.CurrentDomain.Evidence,
1401                                         (PermissionSet) null,
1402                                         (PermissionSet) null,
1403                                         (PermissionSet) null,
1404                                         true,
1405                                         new List<CustomAttributeBuilder> ());
1406                                 Assert.Fail ("#1");
1407                         } catch (ArgumentException ex) {
1408                                 // Illegal enum value: 667
1409                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1410                                 Assert.IsNull (ex.InnerException, "#3");
1411                                 Assert.IsNotNull (ex.Message, "#4");
1412                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
1413                                 Assert.IsNotNull (ex.ParamName, "#6");
1414                                 Assert.AreEqual ("access", ex.ParamName, "#7");
1415                         }
1416 #else
1417                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1418                                 name, AssemblyBuilderAccess.Run |
1419                                 (AssemblyBuilderAccess) 666,
1420                                 Path.GetTempPath (),
1421                                 AppDomain.CurrentDomain.Evidence,
1422                                 (PermissionSet) null,
1423                                 (PermissionSet) null,
1424                                 (PermissionSet) null,
1425                                 true,
1426                                 new List<CustomAttributeBuilder> ());
1427                         Assert.IsNotNull (ab, "#1");
1428 #endif
1429                 }
1430
1431                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
1432                 public void DefineDynamicAssembly10_Name_InvalidChars ()
1433                 {
1434                         string [] invalid_char_names = new string [] {
1435                                 "\tAB",
1436                                 " AB",
1437                                 "\rAB",
1438                                 "A/B",
1439                                 ":AB",
1440                                 "B:A",
1441                                 "B\\A",
1442                                 "BA\\"};
1443
1444                         AssemblyName name = new AssemblyName ();
1445
1446                         foreach (string invalid_name in invalid_char_names) {
1447                                 name.Name = invalid_name;
1448                                 try {
1449                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
1450                                                 name,
1451                                                 AssemblyBuilderAccess.Run,
1452                                                 Path.GetTempPath (),
1453                                                 AppDomain.CurrentDomain.Evidence,
1454                                                 (PermissionSet) null,
1455                                                 (PermissionSet) null,
1456                                                 (PermissionSet) null,
1457                                                 true,
1458                                                 new List<CustomAttributeBuilder> ());
1459                                         Assert.Fail ("#1:" + invalid_name);
1460                                 } catch (ArgumentException ex) {
1461                                         // Assembly names may not begin with whitespace
1462                                         // or contain the characters '/', '\' or ':'
1463                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1464                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1465                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1466                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1467                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1468                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1469                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1470                                 }
1471                         }
1472                 }
1473
1474                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
1475                 public void DefineDynamicAssembly10_Name_Null ()
1476                 {
1477                         try {
1478                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1479                                         (AssemblyName) null,
1480                                         AssemblyBuilderAccess.Run,
1481                                         Path.GetTempPath (),
1482                                         AppDomain.CurrentDomain.Evidence,
1483                                         (PermissionSet) null,
1484                                         (PermissionSet) null,
1485                                         (PermissionSet) null,
1486                                         true,
1487                                         new List<CustomAttributeBuilder> ());
1488                                 Assert.Fail ("#A1");
1489                         } catch (ArgumentNullException ex) {
1490                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1491                                 Assert.IsNull (ex.InnerException, "#A3");
1492                                 Assert.IsNotNull (ex.Message, "#A4");
1493                                 Assert.IsNotNull (ex.ParamName, "#A5");
1494                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
1495                         }
1496
1497                         AssemblyName name = new AssemblyName ();
1498
1499                         try {
1500                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1501                                         name,
1502                                         AssemblyBuilderAccess.Run,
1503                                         Path.GetTempPath (),
1504                                         AppDomain.CurrentDomain.Evidence,
1505                                         (PermissionSet) null,
1506                                         (PermissionSet) null,
1507                                         (PermissionSet) null,
1508                                         true,
1509                                         new List<CustomAttributeBuilder> ());
1510                                 Assert.Fail ("#B1");
1511                         } catch (ArgumentException ex) {
1512                                 // AssemblyName.Name cannot be null or an empty string
1513                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1514                                 Assert.IsNull (ex.InnerException, "#B3");
1515                                 Assert.IsNotNull (ex.Message, "#B4");
1516                                 Assert.IsNull (ex.ParamName, "#B5");
1517                         }
1518
1519                         name.Name = string.Empty;
1520
1521                         try {
1522                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1523                                         name,
1524                                         AssemblyBuilderAccess.Run,
1525                                         Path.GetTempPath (),
1526                                         AppDomain.CurrentDomain.Evidence,
1527                                         (PermissionSet) null,
1528                                         (PermissionSet) null,
1529                                         (PermissionSet) null,
1530                                         true,
1531                                         new List<CustomAttributeBuilder> ());
1532                                 Assert.Fail ("#C1");
1533                         } catch (ArgumentException ex) {
1534                                 // AssemblyName.Name cannot be null or an empty string
1535                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1536                                 Assert.IsNull (ex.InnerException, "#C3");
1537                                 Assert.IsNotNull (ex.Message, "#C4");
1538                                 Assert.IsNull (ex.ParamName, "#C5");
1539                         }
1540                 }
1541
1542                 [Test] // DefineDynamicAssembly (AssemblyName name, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)
1543                 public void DefineDynamicAssembly11 ()
1544                 {
1545                         List<CustomAttributeBuilder> cattrs;
1546                         AssemblyBuilder ab;
1547                         Attribute attr;
1548                         AssemblyName name;
1549                         string assemblyFile;
1550                         string current_dir = Directory.GetCurrentDirectory ();
1551
1552                         name = new AssemblyName ();
1553                         name.Name = "DefineDynamicAssembly11A";
1554
1555                         cattrs = new List<CustomAttributeBuilder> ();
1556                         cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyVersionAttribute).
1557                                 GetConstructor (new Type [] { typeof (string) }),
1558                                 new object [] { "1.2.3.4"}));
1559                         cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyCultureAttribute).
1560                                 GetConstructor (new Type [] { typeof (string) }),
1561                                 new object [] { "nl-BE"}));
1562                         cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyAlgorithmIdAttribute).
1563                                 GetConstructor (new Type [] { typeof (AssemblyHashAlgorithm) }),
1564                                 new object [] { AssemblyHashAlgorithm.MD5 }));
1565                         cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyFlagsAttribute).
1566                                 GetConstructor (new Type [] { typeof (uint) }),
1567                                 new object [] { (uint)0x0100 }));
1568                         cattrs.Add (new CustomAttributeBuilder (typeof (CLSCompliantAttribute).
1569                                 GetConstructor (new Type [] { typeof (bool) }),
1570                                 new object [] { true }));
1571
1572                         ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1573                                 name, AssemblyBuilderAccess.Save, cattrs);
1574
1575                         ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (ComVisibleAttribute).
1576                                 GetConstructor (new Type [] { typeof (bool) }),
1577                                 new object [] { true }));
1578
1579                         ab.Save ("DefineDynamicAssembly11A.dll");
1580
1581                         assemblyFile = Path.Combine (current_dir, "DefineDynamicAssembly11A.dll");
1582
1583                         try {
1584                                 AssemblyName an = AssemblyName.GetAssemblyName (assemblyFile);
1585                                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#A1");
1586                                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A2");
1587                                 Assert.AreEqual ("DefineDynamicAssembly11A, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", an.FullName, "#A3");
1588                                 Assert.IsNull (an.GetPublicKey (), "#A4");
1589                                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A5");
1590                                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1, an.HashAlgorithm, "#A6");
1591                                 Assert.IsNull (an.KeyPair, "#A7");
1592                                 Assert.AreEqual ("DefineDynamicAssembly11A", an.Name, "#A8");
1593                                 //Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "#A9");
1594                                 Assert.AreEqual (an.FullName, an.ToString (), "#A10");
1595                                 Assert.AreEqual (new Version (0, 0, 0, 0), an.Version, "#A11");
1596                                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, an.VersionCompatibility, "#A12");
1597
1598                                 Assembly a;
1599
1600                                 using (FileStream fs = File.OpenRead (assemblyFile)) {
1601                                         byte [] buffer = new byte [fs.Length];
1602                                         fs.Read (buffer, 0, buffer.Length);
1603                                         a = Assembly.Load (buffer);
1604                                 }
1605
1606                                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyVersionAttribute));
1607                                 Assert.IsNotNull (attr, "#A13a");
1608                                 Assert.AreEqual ("1.2.3.4", ((AssemblyVersionAttribute) attr).Version, "#A13b");
1609                                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyCultureAttribute));
1610                                 Assert.IsNotNull (attr, "#A14a");
1611                                 Assert.AreEqual ("nl-BE", ((AssemblyCultureAttribute) attr).Culture, "#A14b");
1612                                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyAlgorithmIdAttribute));
1613                                 Assert.IsNotNull (attr, "#A15a");
1614                                 Assert.AreEqual ((uint) AssemblyHashAlgorithm.MD5, ((AssemblyAlgorithmIdAttribute) attr).AlgorithmId, "#A15b");
1615                                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyFlagsAttribute));
1616                                 Assert.IsNotNull (attr, "#A16a");
1617                                 Assert.AreEqual ((uint) 0x0100, ((AssemblyFlagsAttribute) attr).Flags, "#A16b");
1618                                 attr = Attribute.GetCustomAttribute (a, typeof (CLSCompliantAttribute));
1619                                 Assert.IsNotNull (attr, "#A17a");
1620                                 Assert.IsTrue (((CLSCompliantAttribute) attr).IsCompliant, "#A17b");
1621                                 attr = Attribute.GetCustomAttribute (a, typeof (ComVisibleAttribute));
1622                                 Assert.IsNotNull (attr, "#A18a");
1623                                 Assert.IsTrue (((ComVisibleAttribute) attr).Value, "#A18b");
1624                         } finally {
1625                                 File.Delete (assemblyFile);
1626                         }
1627
1628                         name = new AssemblyName ();
1629                         name.CultureInfo = new CultureInfo ("fr-BE");
1630                         name.KeyPair = new StrongNameKeyPair (keyPair);
1631                         name.Name = "DefineDynamicAssembly11B";
1632                         name.Version = new Version (3, 2, 4, 1);
1633
1634                         cattrs = new List<CustomAttributeBuilder> ();
1635                         cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyVersionAttribute).
1636                                 GetConstructor (new Type [] { typeof (string) }),
1637                                 new object [] { "1.2.3.4"}));
1638                         cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyCultureAttribute).
1639                                 GetConstructor (new Type [] { typeof (string) }),
1640                                 new object [] { "nl-BE"}));
1641                         cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyAlgorithmIdAttribute).
1642                                 GetConstructor (new Type [] { typeof (AssemblyHashAlgorithm) }),
1643                                 new object [] { AssemblyHashAlgorithm.MD5 }));
1644                         cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyFlagsAttribute).
1645                                 GetConstructor (new Type [] { typeof (uint) }),
1646                                 new object [] { (uint)0x0100 }));
1647                         cattrs.Add (new CustomAttributeBuilder (typeof (CLSCompliantAttribute).
1648                                 GetConstructor (new Type [] { typeof (bool) }),
1649                                 new object [] { true }));
1650
1651                         ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1652                                 name, AssemblyBuilderAccess.Save, cattrs);
1653
1654                         ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (ComVisibleAttribute).
1655                                 GetConstructor (new Type [] { typeof (bool) }),
1656                                 new object [] { true }));
1657
1658                         ab.Save ("DefineDynamicAssembly11B.dll");
1659
1660                         assemblyFile = Path.Combine (current_dir, "DefineDynamicAssembly11B.dll");
1661
1662                         try {
1663                                 AssemblyName an = AssemblyName.GetAssemblyName (assemblyFile);
1664                                 Assert.AreEqual ("fr-BE", an.CultureInfo.Name, "#B1");
1665                                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#B2");
1666                                 Assert.AreEqual ("DefineDynamicAssembly11B, Version=3.2.4.1, Culture=fr-BE, PublicKeyToken=ce5276d8687ec6dc", an.FullName, "#B3");
1667                                 Assert.AreEqual (publicKey, an.GetPublicKey (), "#B4");
1668                                 Assert.AreEqual (pk_token, an.GetPublicKeyToken (), "#B5");
1669                                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1, an.HashAlgorithm, "#B6");
1670                                 Assert.IsNull (an.KeyPair, "#B7");
1671                                 Assert.AreEqual ("DefineDynamicAssembly11B", an.Name, "#B8");
1672                                 //Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "#B9");
1673                                 Assert.AreEqual (an.FullName, an.ToString (), "#B10");
1674                                 Assert.AreEqual (new Version (3, 2, 4, 1), an.Version, "#B11");
1675                                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, an.VersionCompatibility, "#B12");
1676
1677                                 Assembly a;
1678
1679                                 using (FileStream fs = File.OpenRead (assemblyFile)) {
1680                                         byte [] buffer = new byte [fs.Length];
1681                                         fs.Read (buffer, 0, buffer.Length);
1682                                         a = Assembly.Load (buffer);
1683                                 }
1684
1685                                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyVersionAttribute));
1686                                 Assert.IsNotNull (attr, "#B13a");
1687                                 Assert.AreEqual ("1.2.3.4", ((AssemblyVersionAttribute) attr).Version, "#B13b");
1688                                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyCultureAttribute));
1689                                 Assert.IsNotNull (attr, "#B14a");
1690                                 Assert.AreEqual ("nl-BE", ((AssemblyCultureAttribute) attr).Culture, "#B14b");
1691                                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyAlgorithmIdAttribute));
1692                                 Assert.IsNotNull (attr, "#B15a");
1693                                 Assert.AreEqual ((uint) AssemblyHashAlgorithm.MD5, ((AssemblyAlgorithmIdAttribute) attr).AlgorithmId, "#B15b");
1694                                 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyFlagsAttribute));
1695                                 Assert.IsNotNull (attr, "#B16a");
1696                                 Assert.AreEqual ((uint) 0x0100, ((AssemblyFlagsAttribute) attr).Flags, "#B16b");
1697                                 attr = Attribute.GetCustomAttribute (a, typeof (CLSCompliantAttribute));
1698                                 Assert.IsNotNull (attr, "#B17a");
1699                                 Assert.IsTrue (((CLSCompliantAttribute) attr).IsCompliant, "#B17b");
1700                                 attr = Attribute.GetCustomAttribute (a, typeof (ComVisibleAttribute));
1701                                 Assert.IsNotNull (attr, "#B18a");
1702                                 Assert.IsTrue (((ComVisibleAttribute) attr).Value, "#B18b");
1703                         } finally {
1704                                 File.Delete (assemblyFile);
1705                         }
1706                 }
1707
1708                 [Test] // DefineDynamicAssembly (AssemblyName name, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)
1709                 public void DefineDynamicAssembly11_Access_Invalid ()
1710                 {
1711                         AssemblyName name = new AssemblyName ();
1712                         name.Name = "DefineDynamicAssembly11";
1713
1714 #if NET_2_0
1715                         try {
1716                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1717                                         name, AssemblyBuilderAccess.Run |
1718                                         (AssemblyBuilderAccess) 666,
1719                                         new List<CustomAttributeBuilder> ());
1720                                 Assert.Fail ("#1");
1721                         } catch (ArgumentException ex) {
1722                                 // Illegal enum value: 667
1723                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1724                                 Assert.IsNull (ex.InnerException, "#3");
1725                                 Assert.IsNotNull (ex.Message, "#4");
1726                                 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
1727                                 Assert.IsNotNull (ex.ParamName, "#6");
1728                                 Assert.AreEqual ("access", ex.ParamName, "#7");
1729                         }
1730 #else
1731                         AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1732                                 name, AssemblyBuilderAccess.Run |
1733                                 (AssemblyBuilderAccess) 666,
1734                                 new List<CustomAttributeBuilder> ());
1735                         Assert.IsNotNull (ab, "#1");
1736 #endif
1737                 }
1738
1739                 [Test] // DefineDynamicAssembly (AssemblyName name, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)
1740                 public void DefineDynamicAssembly11_Name_InvalidChars ()
1741                 {
1742                         string [] invalid_char_names = new string [] {
1743                                 "\tAB",
1744                                 " AB",
1745                                 "\rAB",
1746                                 "A/B",
1747                                 ":AB",
1748                                 "B:A",
1749                                 "B\\A",
1750                                 "BA\\"};
1751
1752                         AssemblyName name = new AssemblyName ();
1753
1754                         foreach (string invalid_name in invalid_char_names) {
1755                                 name.Name = invalid_name;
1756                                 try {
1757                                         AppDomain.CurrentDomain.DefineDynamicAssembly (
1758                                                 name,
1759                                                 AssemblyBuilderAccess.Run,
1760                                                 new List<CustomAttributeBuilder> ());
1761                                         Assert.Fail ("#1:" + invalid_name);
1762                                 } catch (ArgumentException ex) {
1763                                         // Assembly names may not begin with whitespace
1764                                         // or contain the characters '/', '\' or ':'
1765                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1766                                         Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1767                                         Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1768                                         Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1769                                         Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1770                                         Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1771                                         Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1772                                 }
1773                         }
1774                 }
1775
1776                 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
1777                 public void DefineDynamicAssembly11_Name_Null ()
1778                 {
1779                         try {
1780                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1781                                         (AssemblyName) null,
1782                                         AssemblyBuilderAccess.Run,
1783                                         new List<CustomAttributeBuilder> ());
1784                                 Assert.Fail ("#A1");
1785                         } catch (ArgumentNullException ex) {
1786                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1787                                 Assert.IsNull (ex.InnerException, "#A3");
1788                                 Assert.IsNotNull (ex.Message, "#A4");
1789                                 Assert.IsNotNull (ex.ParamName, "#A5");
1790                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
1791                         }
1792
1793                         AssemblyName name = new AssemblyName ();
1794
1795                         try {
1796                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1797                                         name,
1798                                         AssemblyBuilderAccess.Run,
1799                                         new List<CustomAttributeBuilder> ());
1800                                 Assert.Fail ("#B1");
1801                         } catch (ArgumentException ex) {
1802                                 // AssemblyName.Name cannot be null or an empty string
1803                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1804                                 Assert.IsNull (ex.InnerException, "#B3");
1805                                 Assert.IsNotNull (ex.Message, "#B4");
1806                                 Assert.IsNull (ex.ParamName, "#B5");
1807                         }
1808
1809                         name.Name = string.Empty;
1810
1811                         try {
1812                                 AppDomain.CurrentDomain.DefineDynamicAssembly (
1813                                         name,
1814                                         AssemblyBuilderAccess.Run,
1815                                         new List<CustomAttributeBuilder> ());
1816                                 Assert.Fail ("#C1");
1817                         } catch (ArgumentException ex) {
1818                                 // AssemblyName.Name cannot be null or an empty string
1819                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1820                                 Assert.IsNull (ex.InnerException, "#C3");
1821                                 Assert.IsNotNull (ex.Message, "#C4");
1822                                 Assert.IsNull (ex.ParamName, "#C5");
1823                         }
1824                 }
1825
1826                 [Test] // ExecuteAssemblyByName (String)
1827                 public void ExecuteAssemblyByName1_NoEntryPoint ()
1828                 {
1829                         try {
1830                                 AppDomain.CurrentDomain.ExecuteAssemblyByName ("mscorlib");
1831                                 Assert.Fail ("#1");
1832                         } catch (MissingMethodException ex) {
1833                                 // Entry point not found in assembly '...'
1834                                 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1835                                 Assert.IsNull (ex.InnerException, "#3");
1836                                 Assert.IsNotNull (ex.Message, "#4");
1837                                 Assert.IsTrue (ex.Message.IndexOf (typeof (object).Assembly.FullName) != -1, "#5");
1838                         }
1839                 }
1840
1841                 [Test] // ExecuteAssemblyByName (String, Evidence)
1842                 public void ExecuteAssemblyByName2_NoEntryPoint ()
1843                 {
1844                         try {
1845                                 AppDomain.CurrentDomain.ExecuteAssemblyByName (
1846                                         "mscorlib", (Evidence) null);
1847                                 Assert.Fail ("#1");
1848                         } catch (MissingMethodException ex) {
1849                                 // Entry point not found in assembly '...'
1850                                 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1851                                 Assert.IsNull (ex.InnerException, "#3");
1852                                 Assert.IsNotNull (ex.Message, "#4");
1853                                 Assert.IsTrue (ex.Message.IndexOf (typeof (object).Assembly.FullName) != -1, "#5");
1854                         }
1855                 }
1856
1857                 [Test] // ExecuteAssemblyByName (String, Evidence, String [])
1858                 public void ExecuteAssemblyByName3_NoEntryPoint ()
1859                 {
1860                         try {
1861                                 AppDomain.CurrentDomain.ExecuteAssemblyByName (
1862                                         "mscorlib", (Evidence) null,
1863                                         new string [0]);
1864                                 Assert.Fail ("#1");
1865                         } catch (MissingMethodException ex) {
1866                                 // Entry point not found in assembly '...'
1867                                 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1868                                 Assert.IsNull (ex.InnerException, "#3");
1869                                 Assert.IsNotNull (ex.Message, "#4");
1870                                 Assert.IsTrue (ex.Message.IndexOf (typeof (object).Assembly.FullName) != -1, "#5");
1871                         }
1872                 }
1873
1874                 [Test] // ExecuteAssemblyByName (AssemblyName, Evidence, String [])
1875                 public void ExecuteAssemblyByName4_NoEntryPoint ()
1876                 {
1877                         AssemblyName aname = new AssemblyName ("mscorlib");
1878
1879                         try {
1880                                 AppDomain.CurrentDomain.ExecuteAssemblyByName (
1881                                         aname, (Evidence) null, new string [0]);
1882                                 Assert.Fail ("#1");
1883                         } catch (MissingMethodException ex) {
1884                                 // Entry point not found in assembly '...'
1885                                 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1886                                 Assert.IsNull (ex.InnerException, "#3");
1887                                 Assert.IsNotNull (ex.Message, "#4");
1888                                 Assert.IsTrue (ex.Message.IndexOf (typeof (object).Assembly.FullName) != -1, "#5");
1889                         }
1890                 }
1891 #endif
1892
1893                 [Test]
1894                 public void SetThreadPrincipal ()
1895                 {
1896                         IIdentity i = new GenericIdentity ("sebastien@ximian.com", "rfc822");
1897                         IPrincipal p = new GenericPrincipal (i, null);
1898                         ad = AppDomain.CreateDomain ("SetThreadPrincipal");
1899                         ad.SetThreadPrincipal (p);
1900                 }
1901
1902                 [Test]
1903                 [ExpectedException (typeof (ArgumentNullException))]
1904                 public void SetThreadPrincipalNull ()
1905                 {
1906                         AppDomain.CurrentDomain.SetThreadPrincipal (null);
1907                 }
1908
1909                 [Test]
1910                 [ExpectedException (typeof (PolicyException))]
1911                 public void SetThreadPrincipalTwice ()
1912                 {
1913                         IIdentity i = new GenericIdentity ("sebastien@ximian.com", "rfc822");
1914                         IPrincipal p = new GenericPrincipal (i, null);
1915                         ad = AppDomain.CreateDomain ("SetThreadPrincipalTwice");
1916                         ad.SetThreadPrincipal (p);
1917                         // you only live twice (or so James told me ;-)
1918                         ad.SetThreadPrincipal (p);
1919                 }
1920
1921                 [Test]
1922                 [ExpectedException (typeof (AppDomainUnloadedException))]
1923                 public void SetThreadPrincipalUnloaded ()
1924                 {
1925                         ad = AppDomain.CreateDomain ("Ximian");
1926                         AppDomain.Unload (ad);
1927                         IIdentity i = new GenericIdentity ("sebastien@ximian.com", "rfc822");
1928                         IPrincipal p = new GenericPrincipal (i, null);
1929                         ad.SetThreadPrincipal (p);
1930                 }
1931
1932                 [Test]
1933                 public void SetPrincipalPolicy_NoPrincipal ()
1934                 {
1935                         AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.NoPrincipal);
1936                 }
1937
1938                 [Test]
1939                 public void SetPrincipalPolicy_UnauthenticatedPrincipal ()
1940                 {
1941                         AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.UnauthenticatedPrincipal);
1942                 }
1943
1944                 [Test]
1945                 public void SetPrincipalPolicy_WindowsPrincipal ()
1946                 {
1947                         AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.WindowsPrincipal);
1948                 }
1949
1950                 [Test]
1951                 [ExpectedException (typeof (AppDomainUnloadedException))]
1952                 public void SetPrincipalPolicyUnloaded ()
1953                 {
1954                         ad = AppDomain.CreateDomain ("Ximian");
1955                         AppDomain.Unload (ad);
1956                         ad.SetPrincipalPolicy (PrincipalPolicy.NoPrincipal);
1957                 }
1958
1959                 [Test]
1960                 public void CreateDomain_String ()
1961                 {
1962                         ad = AppDomain.CreateDomain ("CreateDomain_String");
1963                         Assert.IsNotNull (ad.Evidence, "Evidence");
1964                         // Evidence are copied (or referenced?) from default app domain
1965                         // we can't get default so we use the current (which should have copied the default)
1966                         Assert.AreEqual (AppDomain.CurrentDomain.Evidence.Count, ad.Evidence.Count, "Evidence.Count");
1967                 }
1968
1969                 [Test]
1970                 [ExpectedException (typeof (ArgumentNullException))]
1971                 public void CreateDomain_String_Null ()
1972                 {
1973                         ad = AppDomain.CreateDomain (null);
1974                 }
1975
1976                 [Test]
1977                 [Category ("NotDotNet")]
1978                 public void CreateDomain_StringEvidence ()
1979                 {
1980                         Evidence e = new Evidence ();
1981                         ad = AppDomain.CreateDomain ("CreateDomain_StringEvidence", e);
1982                         Assert.IsNotNull (ad.Evidence, "Evidence");
1983                         Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
1984
1985                         e.AddHost (new Zone (SecurityZone.MyComputer));
1986                         Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
1987                         // evidence isn't copied but referenced
1988                 }
1989
1990                 [Test]
1991                 [ExpectedException (typeof (ArgumentNullException))]
1992                 public void CreateDomain_StringNullEvidence ()
1993                 {
1994                         ad = AppDomain.CreateDomain (null, new Evidence ());
1995                 }
1996
1997                 [Test]
1998                 public void CreateDomain_StringEvidenceNull ()
1999                 {
2000                         ad = AppDomain.CreateDomain ("CreateDomain_StringEvidenceNull", null);
2001                         Assert.IsNotNull (ad.Evidence, "Evidence");
2002                         // Evidence are copied (or referenced?) from default app domain
2003                         // we can't get default so we use the current (which should have copied the default)
2004                         Evidence e = AppDomain.CurrentDomain.Evidence;
2005                         Assert.AreEqual (e.Count, ad.Evidence.Count, "Evidence.Count-1");
2006                         e.AddHost (new Zone (SecurityZone.MyComputer));
2007                         Assert.AreEqual (e.Count - 1, ad.Evidence.Count, "Evidence.Count-2");
2008                         // evidence are copied
2009                 }
2010
2011                 [Test]
2012                 [Category ("NotDotNet")]
2013                 public void CreateDomain_StringEvidenceAppDomainSetup ()
2014                 {
2015                         Evidence e = new Evidence ();
2016                         AppDomainSetup info = new AppDomainSetup ();
2017                         info.ApplicationName = "ApplicationName";
2018
2019                         ad = AppDomain.CreateDomain ("CreateDomain_StringEvidenceAppDomainSetup", e, info);
2020                         Assert.IsNotNull (ad.Evidence, "Evidence");
2021                         Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
2022                         Assert.IsNotNull (ad.SetupInformation, "SetupInformation");
2023                         Assert.AreEqual ("ApplicationName", ad.SetupInformation.ApplicationName);
2024
2025                         e.AddHost (new Zone (SecurityZone.MyComputer));
2026                         Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
2027                         // evidence isn't copied but referenced
2028                 }
2029
2030                 [Test]
2031                 [ExpectedException (typeof (ArgumentNullException))]
2032                 public void CreateDomain_StringNullEvidenceAppDomainSetup ()
2033                 {
2034                         AppDomainSetup info = new AppDomainSetup ();
2035                         ad = AppDomain.CreateDomain (null, new Evidence (), info);
2036                 }
2037
2038                 [Test]
2039                 public void CreateDomain_StringEvidenceNullAppDomainSetup ()
2040                 {
2041                         AppDomainSetup info = new AppDomainSetup ();
2042                         info.ApplicationName = "ApplicationName";
2043                         ad = AppDomain.CreateDomain ("CreateDomain_StringEvidenceNullAppDomainSetup", null, info);
2044                         Assert.IsNotNull (ad.Evidence, "Evidence");
2045                         // Evidence are copied (or referenced?) from default app domain
2046                         // we can't get default so we use the current (which should have copied the default)
2047                         Assert.AreEqual (AppDomain.CurrentDomain.Evidence.Count, ad.Evidence.Count, "Evidence.Count");
2048                         Assert.AreEqual ("ApplicationName", ad.SetupInformation.ApplicationName, "ApplicationName-1");
2049                         info.ApplicationName = "Test";
2050                         Assert.AreEqual ("Test", info.ApplicationName, "ApplicationName-2");
2051                         Assert.AreEqual ("ApplicationName", ad.SetupInformation.ApplicationName, "ApplicationName-3");
2052                         // copied
2053                 }
2054
2055                 [Test]
2056                 [Category ("NotDotNet")]
2057                 public void CreateDomain_StringEvidenceAppDomainSetupNull ()
2058                 {
2059                         Evidence e = new Evidence ();
2060                         ad = AppDomain.CreateDomain ("CreateDomain_StringEvidenceAppDomainSetupNull", e, null);
2061                         Assert.IsNotNull (ad.Evidence, "Evidence");
2062                         Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
2063                         // SetupInformation is copied from default app domain
2064                         Assert.IsNotNull (ad.SetupInformation, "SetupInformation");
2065                 }
2066
2067                 [Test] // ExecuteAssembly (String)
2068                 public void ExecuteAssembly1_NoEntryPoint ()
2069                 {
2070                         Assembly assembly = typeof (AppDomainTest).Assembly;
2071
2072                         try {
2073                                 AppDomain.CurrentDomain.ExecuteAssembly (
2074                                         assembly.Location);
2075                                 Assert.Fail ("#1");
2076 #if NET_2_0
2077                         } catch (MissingMethodException ex) {
2078                                 // Entry point not found in assembly '...'
2079                                 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
2080                                 Assert.IsNull (ex.InnerException, "#3");
2081                                 Assert.IsNotNull (ex.Message, "#4");
2082                                 Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#5");
2083                         }
2084 #else
2085                         } catch (COMException ex) {
2086                                 // Unspecified error
2087                                 Assert.AreEqual (typeof (COMException), ex.GetType (), "#2");
2088                                 Assert.AreEqual (-2147467259, ex.ErrorCode, "#3");
2089                                 Assert.IsNull (ex.InnerException, "#4");
2090                                 Assert.IsNotNull (ex.Message, "#5");
2091                         }
2092 #endif
2093                 }
2094
2095                 [Test] // ExecuteAssembly (String, Evidence)
2096                 public void ExecuteAssembly2_NoEntryPoint ()
2097                 {
2098                         Assembly assembly = typeof (AppDomainTest).Assembly;
2099
2100                         try {
2101                                 AppDomain.CurrentDomain.ExecuteAssembly (
2102                                         assembly.Location,
2103                                         (Evidence) null);
2104                                 Assert.Fail ("#1");
2105 #if NET_2_0
2106                         } catch (MissingMethodException ex) {
2107                                 // Entry point not found in assembly '...'
2108                                 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
2109                                 Assert.IsNull (ex.InnerException, "#3");
2110                                 Assert.IsNotNull (ex.Message, "#4");
2111                                 Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#5");
2112                         }
2113 #else
2114                         } catch (COMException ex) {
2115                                 // Unspecified error
2116                                 Assert.AreEqual (typeof (COMException), ex.GetType (), "#2");
2117                                 Assert.AreEqual (-2147467259, ex.ErrorCode, "#3");
2118                                 Assert.IsNull (ex.InnerException, "#4");
2119                                 Assert.IsNotNull (ex.Message, "#5");
2120                         }
2121 #endif
2122                 }
2123
2124                 [Test] // ExecuteAssembly (String, Evidence, String [])
2125                 public void ExecuteAssembly3_NoEntryPoint ()
2126                 {
2127                         Assembly assembly = typeof (AppDomainTest).Assembly;
2128
2129                         try {
2130                                 AppDomain.CurrentDomain.ExecuteAssembly (
2131                                         assembly.Location,
2132                                         (Evidence) null,
2133                                         new string [0]);
2134                                 Assert.Fail ("#1");
2135 #if NET_2_0
2136                         } catch (MissingMethodException ex) {
2137                                 // Entry point not found in assembly '...'
2138                                 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
2139                                 Assert.IsNull (ex.InnerException, "#3");
2140                                 Assert.IsNotNull (ex.Message, "#4");
2141                                 Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#5");
2142                         }
2143 #else
2144                         } catch (COMException ex) {
2145                                 // Unspecified error
2146                                 Assert.AreEqual (typeof (COMException), ex.GetType (), "#2");
2147                                 Assert.AreEqual (-2147467259, ex.ErrorCode, "#3");
2148                                 Assert.IsNull (ex.InnerException, "#4");
2149                                 Assert.IsNotNull (ex.Message, "#5");
2150                         }
2151 #endif
2152                 }
2153
2154                 [Test] // ExecuteAssembly (String, Evidence, String [], Byte [], AssemblyHashAlgorithm)
2155                 [Category ("NotWorking")] // Not implemented
2156                 public void ExecuteAssembly4_NoEntryPoint ()
2157                 {
2158                         Assembly assembly = typeof (AppDomainTest).Assembly;
2159
2160                         try {
2161                                 AppDomain.CurrentDomain.ExecuteAssembly (
2162                                         assembly.Location,
2163                                         (Evidence) null,
2164                                         new string [0],
2165                                         (byte []) null,
2166                                         AssemblyHashAlgorithm.SHA1);
2167                                 Assert.Fail ("#1");
2168 #if NET_2_0
2169                         } catch (MissingMethodException ex) {
2170                                 // Entry point not found in assembly '...'
2171                                 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
2172                                 Assert.IsNull (ex.InnerException, "#3");
2173                                 Assert.IsNotNull (ex.Message, "#4");
2174                                 Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#5");
2175                         }
2176 #else
2177                         } catch (COMException ex) {
2178                                 // Unspecified error
2179                                 Assert.AreEqual (typeof (COMException), ex.GetType (), "#2");
2180                                 Assert.AreEqual (-2147467259, ex.ErrorCode, "#3");
2181                                 Assert.IsNull (ex.InnerException, "#4");
2182                                 Assert.IsNotNull (ex.Message, "#5");
2183                         }
2184 #endif
2185                 }
2186
2187                 [Test] // bug #79720
2188                 [Category ("NotWorking")]
2189                 public void Load_Loaded_Ignore ()
2190                 {
2191                         int assemblyStartCount = AppDomain.CurrentDomain.GetAssemblies ().Length;
2192
2193                         // PART A
2194
2195                         string assemblyFile = Path.Combine (tempDir, "bug79720A.dll");
2196                         AssemblyName aname = new AssemblyName ();
2197                         aname.Name = "bug79720A";
2198                         aname.Version = new Version (2, 4);
2199
2200                         GenerateAssembly (aname, assemblyFile);
2201
2202                         Assert.AreEqual (assemblyStartCount, AppDomain.CurrentDomain.GetAssemblies ().Length, "#A1");
2203
2204                         aname = new AssemblyName ();
2205                         aname.Name = "bug79720A";
2206                         try {
2207                                 AppDomain.CurrentDomain.Load (aname);
2208                                 Assert.Fail ("#A2");
2209                         } catch (FileNotFoundException) {
2210                         }
2211
2212                         aname = new AssemblyName ();
2213                         aname.Name = "bug79720A";
2214                         aname.Version = new Version (0, 0, 0, 0);
2215                         try {
2216                                 AppDomain.CurrentDomain.Load (aname);
2217                                 Assert.Fail ("#A3");
2218                         } catch (FileNotFoundException) {
2219                         }
2220
2221                         aname = new AssemblyName ();
2222                         aname.Name = "bug79720A";
2223                         aname.Version = new Version (2, 4);
2224                         try {
2225                                 AppDomain.CurrentDomain.Load (aname);
2226                                 Assert.Fail ("#A4");
2227                         } catch (FileNotFoundException) {
2228                         }
2229
2230                         Assert.AreEqual (assemblyStartCount, AppDomain.CurrentDomain.GetAssemblies ().Length, "#A5");
2231
2232                         Assembly.LoadFrom (assemblyFile);
2233
2234                         Assert.AreEqual (assemblyStartCount + 1, AppDomain.CurrentDomain.GetAssemblies ().Length, "#A6");
2235
2236                         aname = new AssemblyName ();
2237                         aname.Name = "bug79720A";
2238                         try {
2239                                 AppDomain.CurrentDomain.Load (aname);
2240                                 Assert.Fail ("#A7");
2241                         } catch (FileNotFoundException) {
2242                         }
2243
2244                         aname = new AssemblyName ();
2245                         aname.Name = "bug79720A";
2246                         aname.Version = new Version (0, 0, 0, 0);
2247                         try {
2248                                 AppDomain.CurrentDomain.Load (aname);
2249                                 Assert.Fail ("#A8");
2250                         } catch (FileNotFoundException) {
2251                         }
2252
2253                         aname = new AssemblyName ();
2254                         aname.Name = "bug79720A";
2255                         aname.Version = new Version (2, 4);
2256                         try {
2257                                 AppDomain.CurrentDomain.Load (aname);
2258                                 Assert.Fail ("#A9");
2259                         } catch (FileNotFoundException) {
2260                         }
2261
2262                         aname = new AssemblyName ();
2263                         aname.Name = "bug79720A";
2264                         aname.Version = new Version (2, 4);
2265                         aname.CultureInfo = CultureInfo.InvariantCulture;
2266                         try {
2267                                 AppDomain.CurrentDomain.Load (aname);
2268                                 Assert.Fail ("#A10");
2269                         } catch (FileNotFoundException) {
2270                         }
2271
2272                         aname = new AssemblyName ();
2273                         aname.Name = "bug79720A";
2274                         aname.Version = new Version (2, 4, 0, 0);
2275                         aname.CultureInfo = CultureInfo.InvariantCulture;
2276                         try {
2277                                 AppDomain.CurrentDomain.Load (aname);
2278                                 Assert.Fail ("#A11");
2279                         } catch (FileNotFoundException) {
2280                         }
2281
2282                         Assert.AreEqual (assemblyStartCount + 1, AppDomain.CurrentDomain.GetAssemblies ().Length, "#A12");
2283
2284                         // PART B
2285
2286                         assemblyFile = Path.Combine (tempDir, "bug79720B.dll");
2287                         aname = new AssemblyName ();
2288                         aname.Name = "bug79720B";
2289                         aname.Version = new Version (2, 4, 1);
2290                         aname.CultureInfo = new CultureInfo ("nl-BE");
2291
2292                         GenerateAssembly (aname, assemblyFile);
2293
2294                         Assert.AreEqual (assemblyStartCount + 1, AppDomain.CurrentDomain.GetAssemblies ().Length, "#B1");
2295
2296                         aname = new AssemblyName ();
2297                         aname.Name = "bug79720B";
2298                         try {
2299                                 AppDomain.CurrentDomain.Load (aname);
2300                                 Assert.Fail ("#B2");
2301                         } catch (FileNotFoundException) {
2302                         }
2303
2304                         aname = new AssemblyName ();
2305                         aname.Name = "bug79720B";
2306                         aname.Version = new Version (0, 0, 0, 0);
2307                         try {
2308                                 AppDomain.CurrentDomain.Load (aname);
2309                                 Assert.Fail ("#B3");
2310                         } catch (FileNotFoundException) {
2311                         }
2312
2313                         aname = new AssemblyName ();
2314                         aname.Name = "bug79720B";
2315                         aname.Version = new Version (2, 4, 1);
2316                         try {
2317                                 AppDomain.CurrentDomain.Load (aname);
2318                                 Assert.Fail ("#B4");
2319                         } catch (FileNotFoundException) {
2320                         }
2321
2322                         aname = new AssemblyName ();
2323                         aname.Name = "bug79720B";
2324                         aname.Version = new Version (2, 4, 1);
2325                         aname.CultureInfo = new CultureInfo ("nl-BE");
2326                         try {
2327                                 AppDomain.CurrentDomain.Load (aname);
2328                                 Assert.Fail ("#B5");
2329                         } catch (FileNotFoundException) {
2330                         }
2331
2332                         Assert.AreEqual (assemblyStartCount + 1, AppDomain.CurrentDomain.GetAssemblies ().Length, "#B6");
2333
2334                         Assembly.LoadFrom (assemblyFile);
2335
2336                         Assert.AreEqual (assemblyStartCount + 2, AppDomain.CurrentDomain.GetAssemblies ().Length, "#B7");
2337
2338                         aname = new AssemblyName ();
2339                         aname.Name = "bug79720B";
2340                         try {
2341                                 AppDomain.CurrentDomain.Load (aname);
2342                                 Assert.Fail ("#B8");
2343                         } catch (FileNotFoundException) {
2344                         }
2345
2346                         aname = new AssemblyName ();
2347                         aname.Name = "bug79720B";
2348                         aname.Version = new Version (0, 0, 0, 0);
2349                         try {
2350                                 AppDomain.CurrentDomain.Load (aname);
2351                                 Assert.Fail ("#B9");
2352                         } catch (FileNotFoundException) {
2353                         }
2354
2355                         aname = new AssemblyName ();
2356                         aname.Name = "bug79720B";
2357                         aname.Version = new Version (2, 4, 1);
2358                         try {
2359                                 AppDomain.CurrentDomain.Load (aname);
2360                                 Assert.Fail ("#B10");
2361                         } catch (FileNotFoundException) {
2362                         }
2363
2364                         aname = new AssemblyName ();
2365                         aname.Name = "bug79720B";
2366                         aname.Version = new Version (2, 4, 1);
2367                         aname.CultureInfo = new CultureInfo ("nl-BE");
2368                         try {
2369                                 AppDomain.CurrentDomain.Load (aname);
2370                                 Assert.Fail ("#B11");
2371                         } catch (FileNotFoundException) {
2372                         }
2373
2374                         Assert.AreEqual (assemblyStartCount + 2, AppDomain.CurrentDomain.GetAssemblies ().Length, "#B12");
2375
2376                         // PART C
2377
2378                         assemblyFile = Path.Combine (tempDir, "bug79720C.dll");
2379                         aname = new AssemblyName ();
2380                         aname.Name = "bug79720C";
2381                         aname.CultureInfo = new CultureInfo ("nl-BE");
2382                         aname.Version = new Version (2, 4);
2383                         aname.KeyPair = new StrongNameKeyPair (keyPair);
2384
2385                         GenerateAssembly (aname, assemblyFile);
2386
2387                         Assert.AreEqual (assemblyStartCount + 2, AppDomain.CurrentDomain.GetAssemblies ().Length, "#C1");
2388
2389                         aname = new AssemblyName ();
2390                         aname.Name = "bug79720C";
2391                         try {
2392                                 AppDomain.CurrentDomain.Load (aname);
2393                                 Assert.Fail ("#C2");
2394                         } catch (FileNotFoundException) {
2395                         }
2396
2397                         aname = new AssemblyName ();
2398                         aname.Name = "bug79720C";
2399                         aname.Version = new Version (0, 0, 0, 0);
2400                         try {
2401                                 AppDomain.CurrentDomain.Load (aname);
2402                                 Assert.Fail ("#C3");
2403                         } catch (FileNotFoundException) {
2404                         }
2405
2406                         aname = new AssemblyName ();
2407                         aname.Name = "bug79720C";
2408                         aname.Version = new Version (2, 4, 1);
2409                         try {
2410                                 AppDomain.CurrentDomain.Load (aname);
2411                                 Assert.Fail ("#C4");
2412                         } catch (FileNotFoundException) {
2413                         }
2414
2415                         aname = new AssemblyName ();
2416                         aname.Name = "bug79720C";
2417                         aname.Version = new Version (2, 4, 1);
2418                         aname.CultureInfo = new CultureInfo ("nl-BE");
2419                         try {
2420                                 AppDomain.CurrentDomain.Load (aname);
2421                                 Assert.Fail ("#C5");
2422                         } catch (FileNotFoundException) {
2423                         }
2424
2425                         aname = new AssemblyName ();
2426                         aname.Name = "bug79720C";
2427                         aname.Version = new Version (2, 4, 1);
2428                         aname.CultureInfo = new CultureInfo ("nl-BE");
2429                         aname.SetPublicKey (publicKey);
2430                         try {
2431                                 AppDomain.CurrentDomain.Load (aname);
2432                                 Assert.Fail ("#C6");
2433                         } catch (FileNotFoundException) {
2434                         }
2435
2436                         Assert.AreEqual (assemblyStartCount + 2, AppDomain.CurrentDomain.GetAssemblies ().Length, "#C7");
2437
2438                         Assembly.LoadFrom (assemblyFile);
2439
2440                         Assert.AreEqual (assemblyStartCount + 3, AppDomain.CurrentDomain.GetAssemblies ().Length, "#C8");
2441
2442                         aname = new AssemblyName ();
2443                         aname.Name = "bug79720C";
2444                         try {
2445                                 AppDomain.CurrentDomain.Load (aname);
2446                                 Assert.Fail ("#C9");
2447                         } catch (FileNotFoundException) {
2448                         }
2449
2450                         aname = new AssemblyName ();
2451                         aname.Name = "bug79720C";
2452                         aname.Version = new Version (0, 0, 0, 0);
2453                         try {
2454                                 AppDomain.CurrentDomain.Load (aname);
2455                                 Assert.Fail ("#C10");
2456                         } catch (FileNotFoundException) {
2457                         }
2458
2459                         aname = new AssemblyName ();
2460                         aname.Name = "bug79720C";
2461                         aname.Version = new Version (2, 4);
2462                         try {
2463                                 AppDomain.CurrentDomain.Load (aname);
2464                                 Assert.Fail ("#C11");
2465                         } catch (FileNotFoundException) {
2466                         }
2467
2468                         aname = new AssemblyName ();
2469                         aname.Name = "bug79720C";
2470                         aname.Version = new Version (2, 4);
2471                         aname.CultureInfo = new CultureInfo ("nl-BE");
2472                         try {
2473                                 AppDomain.CurrentDomain.Load (aname);
2474                                 Assert.Fail ("#C12");
2475                         } catch (FileNotFoundException) {
2476                         }
2477
2478                         aname = new AssemblyName ();
2479                         aname.Name = "bug79720C";
2480                         aname.Version = new Version (2, 4);
2481                         aname.CultureInfo = new CultureInfo ("nl-BE");
2482                         aname.SetPublicKey (publicKey);
2483                         try {
2484                                 AppDomain.CurrentDomain.Load (aname);
2485                                 Assert.Fail ("#C13");
2486                         } catch (FileNotFoundException) {
2487                         }
2488
2489                         Assert.AreEqual (assemblyStartCount + 3, AppDomain.CurrentDomain.GetAssemblies ().Length, "#C14");
2490                 }
2491
2492                 [Test]
2493                 [Category ("NotWorking")]
2494                 public void Load_Loaded_Multiple ()
2495                 {
2496                         string cultureDir = Path.Combine (tempDir, "nl-BE");
2497                         if (!Directory.Exists (cultureDir))
2498                                 Directory.CreateDirectory (cultureDir);
2499
2500                         AppDomain ad = CreateTestDomain (tempDir, true);
2501                         try {
2502                                 CrossDomainTester cdt = CreateCrossDomainTester (ad);
2503
2504                                 int assemblyCount = cdt.AssemblyCount;
2505
2506                                 // PART A
2507
2508                                 AssemblyName aname = new AssemblyName ();
2509                                 aname.Name = "multipleA";
2510                                 aname.Version = new Version (1, 2, 3, 4);
2511                                 cdt.GenerateAssembly (aname, Path.Combine (tempDir, "multipleA.dll"));
2512
2513                                 Assert.AreEqual (assemblyCount + 1, cdt.AssemblyCount, "#A1");
2514
2515                                 aname = new AssemblyName ();
2516                                 aname.Name = "multipleA";
2517                                 Assert.IsTrue (cdt.AssertLoad (aname), "#A2");
2518
2519                                 Assert.AreEqual (assemblyCount + 2, cdt.AssemblyCount, "#A3");
2520
2521                                 aname = new AssemblyName ();
2522                                 aname.Name = "multipleA";
2523                                 Assert.IsTrue (cdt.AssertLoad (aname), "#A4");
2524
2525                                 aname = new AssemblyName ();
2526                                 aname.Name = "multipleA";
2527                                 aname.CultureInfo = CultureInfo.InvariantCulture;
2528                                 Assert.IsTrue (cdt.AssertLoad (aname), "#A5");
2529
2530                                 aname = new AssemblyName ();
2531                                 aname.Name = "multipleA";
2532                                 aname.CultureInfo = CultureInfo.InvariantCulture;
2533                                 Assert.IsTrue (cdt.AssertLoad (aname), "#A6");
2534
2535                                 aname = new AssemblyName ();
2536                                 aname.Name = "multipleA";
2537                                 aname.CultureInfo = CultureInfo.InvariantCulture;
2538                                 aname.Version = new Version (1, 2, 3, 4);
2539                                 Assert.IsTrue (cdt.AssertLoad (aname), "#A7");
2540
2541                                 aname = new AssemblyName ();
2542                                 aname.Name = "multipleA";
2543                                 aname.CultureInfo = CultureInfo.InvariantCulture;
2544                                 aname.Version = new Version (1, 2, 3, 4);
2545                                 Assert.IsTrue (cdt.AssertLoad (aname), "#A8");
2546
2547                                 Assert.AreEqual (assemblyCount + 2, cdt.AssemblyCount, "#A9");
2548
2549                                 // PART B
2550
2551                                 aname = new AssemblyName ();
2552                                 aname.Name = "multipleB";
2553                                 aname.CultureInfo = new CultureInfo ("nl-BE");
2554                                 aname.Version = new Version (2, 4, 1, 0);
2555                                 cdt.GenerateAssembly (aname, Path.Combine (tempDir, "nl-BE/multipleB.dll"));
2556
2557                                 Assert.AreEqual (assemblyCount + 3, cdt.AssemblyCount, "#B1");
2558
2559                                 aname = new AssemblyName ();
2560                                 aname.Name = "multipleB";
2561                                 Assert.IsTrue (cdt.AssertLoad (aname), "#B2");
2562
2563                                 Assert.AreEqual (assemblyCount + 4, cdt.AssemblyCount, "#B3");
2564
2565                                 aname = new AssemblyName ();
2566                                 aname.Name = "multipleB";
2567                                 Assert.IsTrue (cdt.AssertLoad (aname), "#B4");
2568
2569                                 aname = new AssemblyName ();
2570                                 aname.Name = "multipleB";
2571                                 aname.CultureInfo = new CultureInfo ("nl-BE");
2572                                 Assert.IsTrue (cdt.AssertLoad (aname), "#B5");
2573
2574                                 aname = new AssemblyName ();
2575                                 aname.Name = "multipleB";
2576                                 aname.CultureInfo = new CultureInfo ("nl-BE");
2577                                 Assert.IsTrue (cdt.AssertLoad (aname), "#B6");
2578
2579                                 aname = new AssemblyName ();
2580                                 aname.Name = "multipleB";
2581                                 aname.CultureInfo = new CultureInfo ("nl-BE");
2582                                 aname.Version = new Version (2, 4, 1, 0);
2583                                 Assert.IsTrue (cdt.AssertLoad (aname), "#B7");
2584
2585                                 aname = new AssemblyName ();
2586                                 aname.Name = "multipleB";
2587                                 aname.CultureInfo = new CultureInfo ("nl-BE");
2588                                 aname.Version = new Version (2, 4, 1, 0);
2589                                 Assert.IsTrue (cdt.AssertLoad (aname), "#B8");
2590
2591                                 Assert.AreEqual (assemblyCount + 4, cdt.AssemblyCount, "#B9");
2592
2593                                 // PART C
2594
2595                                 aname = new AssemblyName ();
2596                                 aname.Name = "multipleC";
2597                                 aname.CultureInfo = new CultureInfo ("nl-BE");
2598                                 aname.Version = new Version (2, 4, 0, 0);
2599                                 aname.KeyPair = new StrongNameKeyPair (keyPair);
2600                                 cdt.GenerateAssembly (aname, Path.Combine (tempDir, "nl-BE/multipleC.dll"));
2601
2602                                 Assert.AreEqual (assemblyCount + 5, cdt.AssemblyCount, "#C1");
2603
2604                                 aname = new AssemblyName ();
2605                                 aname.Name = "multipleC";
2606                                 aname.CultureInfo = new CultureInfo ("nl-BE");
2607                                 aname.Version = new Version (2, 4, 0, 0);
2608                                 aname.SetPublicKey (publicKey);
2609                                 Assert.IsTrue (cdt.AssertLoad (aname), "#C2");
2610
2611                                 Assert.AreEqual (assemblyCount + 6, cdt.AssemblyCount, "#C3");
2612
2613                                 aname = new AssemblyName ();
2614                                 aname.Name = "multipleC";
2615                                 aname.CultureInfo = new CultureInfo ("nl-BE");
2616                                 aname.Version = new Version (2, 4, 0, 0);
2617                                 aname.SetPublicKey (publicKey);
2618                                 Assert.IsTrue (cdt.AssertLoad (aname), "#C4");
2619
2620                                 Assert.AreEqual (assemblyCount + 6, cdt.AssemblyCount, "#C5");
2621                         } finally {
2622                                 AppDomain.Unload (ad);
2623                         }
2624                 }
2625
2626                 [Test] // bug #79522
2627                 [Category ("NotWorking")]
2628                 public void Load_Manifest_Mismatch ()
2629                 {
2630                         string assemblyFile = Path.Combine (tempDir, "bug79522A.dll");
2631                         AssemblyName aname = new AssemblyName ();
2632                         aname.Name = "bug79522A";
2633                         aname.Version = new Version (2, 4);
2634
2635                         GenerateAssembly (aname, assemblyFile);
2636
2637                         aname = new AssemblyName ();
2638                         aname.CodeBase = assemblyFile;
2639                         aname.Name = "whateveryouwant";
2640                         aname.Version = new Version (1, 1);
2641
2642                         // despite the fact that no assembly with the specified name
2643                         // exists, the assembly pointed to by the CodeBase of the
2644                         // AssemblyName will be loaded
2645                         //
2646                         // however the display name of the loaded assembly does not
2647                         // match the display name of the AssemblyName, and as a result
2648                         // a FileLoadException is thrown
2649                         try {
2650                                 AppDomain.CurrentDomain.Load (aname);
2651                                 Assert.Fail ("#A1");
2652                         } catch (FileLoadException) {
2653                         }
2654
2655                         // if we set CodeBase to some garbage, then we'll get a
2656                         // FileNotFoundException instead
2657                         aname.CodeBase = "whatever";
2658                         try {
2659                                 AppDomain.CurrentDomain.Load (aname);
2660                                 Assert.Fail ("#A2");
2661                         } catch (FileNotFoundException) {
2662                         }
2663
2664                         aname = new AssemblyName ();
2665                         aname.Name = "bug79522A";
2666                         aname.CodeBase = assemblyFile;
2667 #if NET_2_0
2668                         AppDomain.CurrentDomain.Load (aname);
2669 #else
2670                         try {
2671                                 AppDomain.CurrentDomain.Load (aname);
2672                                 Assert.Fail ("#A3");
2673                         } catch (FileLoadException) {
2674                         }
2675 #endif
2676
2677                         aname = new AssemblyName ();
2678                         aname.Name = "bug79522A";
2679                         aname.CodeBase = assemblyFile;
2680                         aname.Version = new Version (2, 5);
2681 #if NET_2_0
2682                         // the version number is not considered when comparing the manifest
2683                         // of the assembly found using codebase
2684                         AppDomain.CurrentDomain.Load (aname);
2685 #else
2686                         try {
2687                                 AppDomain.CurrentDomain.Load (aname);
2688                                 Assert.Fail ("#A4");
2689                         } catch (FileLoadException) {
2690                         }
2691 #endif
2692
2693                         aname = new AssemblyName ();
2694                         aname.Name = "bug79522A";
2695                         aname.CodeBase = assemblyFile;
2696                         aname.Version = new Version (2, 4, 1);
2697 #if NET_2_0
2698                         // the version number is not considered when comparing the manifest
2699                         // of the assembly found using codebase
2700                         AppDomain.CurrentDomain.Load (aname);
2701 #else
2702                         try {
2703                                 AppDomain.CurrentDomain.Load (aname);
2704                                 Assert.Fail ("#A5");
2705                         } catch (FileLoadException) {
2706                         }
2707 #endif
2708
2709                         // if version is set, then culture must also be set
2710                         aname = new AssemblyName ();
2711                         aname.Name = "bug79522A";
2712                         aname.CodeBase = assemblyFile;
2713                         aname.Version = new Version (2, 4);
2714 #if NET_2_0
2715                         AppDomain.CurrentDomain.Load (aname);
2716 #else
2717                         try {
2718                                 AppDomain.CurrentDomain.Load (aname);
2719                                 Assert.Fail ("#A6");
2720                         } catch (FileLoadException) {
2721                         }
2722 #endif
2723
2724                         // version number does not need to be set
2725                         aname = new AssemblyName ();
2726                         aname.Name = "bug79522A";
2727                         aname.CodeBase = assemblyFile;
2728                         aname.CultureInfo = CultureInfo.InvariantCulture;
2729                         AppDomain.CurrentDomain.Load (aname);
2730
2731                         // if set, the version number must match exactly
2732                         aname = new AssemblyName ();
2733                         aname.Name = "bug79522A";
2734                         aname.CodeBase = assemblyFile;
2735                         aname.CultureInfo = CultureInfo.InvariantCulture;
2736                         aname.Version = new Version (2, 4);
2737                         AppDomain.CurrentDomain.Load (aname);
2738
2739                         // if both culture and version are set, then the version diff
2740                         // is ignored
2741                         aname = new AssemblyName ();
2742                         aname.Name = "bug79522A";
2743                         aname.CodeBase = assemblyFile;
2744                         aname.CultureInfo = CultureInfo.InvariantCulture;
2745                         aname.Version = new Version (2, 5);
2746                         AppDomain.CurrentDomain.Load (aname);
2747
2748                         // loaded assembly is not signed
2749                         aname = new AssemblyName ();
2750                         aname.Name = "bug79522A";
2751                         aname.CodeBase = assemblyFile;
2752                         aname.CultureInfo = CultureInfo.InvariantCulture;
2753                         aname.Version = new Version (2, 4);
2754                         aname.SetPublicKey (publicKey);
2755                         try {
2756                                 AppDomain.CurrentDomain.Load (aname);
2757                                 Assert.Fail ("#A7");
2758                         } catch (FileLoadException) {
2759                         }
2760
2761                         // if set, the culture must match
2762                         aname = new AssemblyName ();
2763                         aname.Name = "bug79522A";
2764                         aname.CodeBase = assemblyFile;
2765                         aname.Version = new Version (2, 4);
2766                         aname.CultureInfo = new CultureInfo ("en-US");
2767                         try {
2768                                 AppDomain.CurrentDomain.Load (aname);
2769                                 Assert.Fail ("#A8");
2770                         } catch (FileLoadException) {
2771                         }
2772
2773                         // PART B
2774
2775                         assemblyFile = Path.Combine (tempDir, "bug79522B.dll");
2776                         aname = new AssemblyName ();
2777                         aname.Name = "bug79522B";
2778                         aname.CultureInfo = new CultureInfo ("nl-BE");
2779                         aname.Version = new Version (2, 4, 1);
2780
2781                         GenerateAssembly (aname, assemblyFile);
2782
2783                         aname = new AssemblyName ();
2784                         aname.CodeBase = assemblyFile;
2785                         aname.Name = "whateveryouwant";
2786                         aname.CultureInfo = new CultureInfo ("nl-BE");
2787                         aname.Version = new Version (1, 1);
2788
2789                         // despite the fact that no assembly with the specified name
2790                         // exists, the assembly pointed to by the CodeBase of the
2791                         // AssemblyName will be loaded
2792                         //
2793                         // however the display name of the loaded assembly does not
2794                         // match the display name of the AssemblyName, and as a result
2795                         // a FileLoadException is thrown
2796                         try {
2797                                 AppDomain.CurrentDomain.Load (aname);
2798                                 Assert.Fail ("#B1");
2799                         } catch (FileLoadException) {
2800                         }
2801
2802                         // if we set CodeBase to some garbage, then we'll get a
2803                         // FileNotFoundException instead
2804                         aname.CodeBase = "whatever";
2805                         try {
2806                                 AppDomain.CurrentDomain.Load (aname);
2807                                 Assert.Fail ("#B2");
2808                         } catch (FileNotFoundException) {
2809                         }
2810
2811                         aname = new AssemblyName ();
2812                         aname.Name = "bug79522B";
2813                         aname.CodeBase = assemblyFile;
2814 #if NET_2_0
2815                         // the version number is not considered when comparing the manifest
2816                         // of the assembly found using codebase
2817                         AppDomain.CurrentDomain.Load (aname);
2818 #else
2819                         try {
2820                                 AppDomain.CurrentDomain.Load (aname);
2821                                 Assert.Fail ("#B3");
2822                         } catch (FileLoadException) {
2823                         }
2824 #endif
2825
2826                         aname = new AssemblyName ();
2827                         aname.Name = "bug79522B";
2828                         aname.CodeBase = assemblyFile;
2829                         aname.Version = new Version (5, 5);
2830 #if NET_2_0
2831                         // the version number is not considered when comparing the manifest
2832                         // of the assembly found using codebase
2833                         AppDomain.CurrentDomain.Load (aname);
2834 #else
2835                         try {
2836                                 AppDomain.CurrentDomain.Load (aname);
2837                                 Assert.Fail ("#B3");
2838                         } catch (FileLoadException) {
2839                         }
2840 #endif
2841
2842                         aname = new AssemblyName ();
2843                         aname.Name = "bug79522B";
2844                         aname.CodeBase = assemblyFile;
2845                         aname.Version = new Version (2, 4, 1);
2846 #if NET_2_0
2847                         AppDomain.CurrentDomain.Load (aname);
2848 #else
2849                         // when the loaded assembly has a specific culture, then that
2850                         // culture must be set if you set the Version on the aname
2851                         try {
2852                                 AppDomain.CurrentDomain.Load (aname);
2853                                 Assert.Fail ("#B4");
2854                         } catch (FileLoadException) {
2855                         }
2856 #endif
2857
2858                         // version does not need to be set
2859                         aname = new AssemblyName ();
2860                         aname.Name = "bug79522B";
2861                         aname.CodeBase = assemblyFile;
2862                         aname.CultureInfo = new CultureInfo ("nl-BE");
2863                         AppDomain.CurrentDomain.Load (aname);
2864
2865                         // if both culture and version are set, then the version diff
2866                         // is ignored
2867                         aname = new AssemblyName ();
2868                         aname.Name = "bug79522B";
2869                         aname.CodeBase = assemblyFile;
2870                         aname.CultureInfo = new CultureInfo ("nl-BE");
2871                         aname.Version = new Version (6, 5);
2872                         AppDomain.CurrentDomain.Load (aname);
2873
2874                         // loaded assembly is not signed
2875                         aname = new AssemblyName ();
2876                         aname.Name = "bug79522B";
2877                         aname.CodeBase = assemblyFile;
2878                         aname.CultureInfo = new CultureInfo ("nl-BE");
2879                         aname.SetPublicKey (publicKey);
2880                         try {
2881                                 AppDomain.CurrentDomain.Load (aname);
2882                                 Assert.Fail ("#B5");
2883                         } catch (FileLoadException) {
2884                         }
2885
2886                         // if set, the culture must match
2887                         aname = new AssemblyName ();
2888                         aname.Name = "bug79522B";
2889                         aname.CodeBase = assemblyFile;
2890                         aname.Version = new Version (2, 4, 1);
2891                         aname.CultureInfo = new CultureInfo ("en-US");
2892                         try {
2893                                 AppDomain.CurrentDomain.Load (aname);
2894                                 Assert.Fail ("#B6");
2895                         } catch (FileLoadException) {
2896                         }
2897
2898                         // PART C
2899
2900                         assemblyFile = Path.Combine (tempDir, "bug79522C.dll");
2901                         aname = new AssemblyName ();
2902                         aname.Name = "bug79522C";
2903                         aname.CultureInfo = new CultureInfo ("nl-BE");
2904                         aname.Version = new Version (2, 4);
2905                         aname.KeyPair = new StrongNameKeyPair (keyPair);
2906
2907                         GenerateAssembly (aname, assemblyFile);
2908
2909                         aname = new AssemblyName ();
2910                         aname.CodeBase = assemblyFile;
2911                         aname.Name = "whateveryouwant";
2912                         aname.CultureInfo = new CultureInfo ("nl-BE");
2913                         aname.Version = new Version (1, 1);
2914                         aname.SetPublicKey (publicKey);
2915
2916                         // despite the fact that no assembly with the specified name
2917                         // exists, the assembly pointed to by the CodeBase of the
2918                         // AssemblyName will be loaded
2919                         //
2920                         // however the display name of the loaded assembly does not
2921                         // match the display name of the AssemblyName, and as a result
2922                         // a FileLoadException is thrown
2923                         try {
2924                                 AppDomain.CurrentDomain.Load (aname);
2925                                 Assert.Fail ("#C1");
2926                         } catch (FileLoadException) {
2927                         }
2928
2929                         // if we set CodeBase to some garbage, then we'll get a
2930                         // FileNotFoundException instead
2931                         aname.CodeBase = "whatever";
2932                         try {
2933                                 AppDomain.CurrentDomain.Load (aname);
2934                                 Assert.Fail ("#C2");
2935                         } catch (FileNotFoundException) {
2936                         }
2937
2938                         aname = new AssemblyName ();
2939                         aname.Name = "bug79522C";
2940                         aname.CodeBase = assemblyFile;
2941 #if NET_2_0
2942                         AppDomain.CurrentDomain.Load (aname);
2943 #else
2944                         try {
2945                                 AppDomain.CurrentDomain.Load (aname);
2946                                 Assert.Fail ("#C3");
2947                         } catch (FileLoadException) {
2948                         }
2949 #endif
2950
2951                         aname = new AssemblyName ();
2952                         aname.Name = "bug79522C";
2953                         aname.CodeBase = assemblyFile;
2954                         aname.Version = new Version (5, 5);
2955                         try {
2956                                 AppDomain.CurrentDomain.Load (aname);
2957                                 Assert.Fail ("#C3");
2958                         } catch (FileLoadException) {
2959                         }
2960
2961                         aname = new AssemblyName ();
2962                         aname.Name = "bug79522C";
2963                         aname.CodeBase = assemblyFile;
2964                         aname.Version = new Version (2, 4);
2965 #if NET_2_0
2966                         AppDomain.CurrentDomain.Load (aname);
2967 #else
2968                         // when the loaded assembly has a specific culture/publickey,
2969                         // then that culture/publickey must be set if you set the
2970                         // Version on the aname
2971                         try {
2972                                 AppDomain.CurrentDomain.Load (aname);
2973                                 Assert.Fail ("#C4");
2974                         } catch (FileLoadException) {
2975                         }
2976 #endif
2977
2978                         aname = new AssemblyName ();
2979                         aname.Name = "bug79522C";
2980                         aname.CodeBase = assemblyFile;
2981                         aname.CultureInfo = new CultureInfo ("nl-BE");
2982                         aname.Version = new Version (2, 4);
2983 #if NET_2_0
2984                         AppDomain.CurrentDomain.Load (aname);
2985 #else
2986                         // if loaded assembly is signed, then the public key must be set
2987                         try {
2988                                 AppDomain.CurrentDomain.Load (aname);
2989                                 Assert.Fail ("#C5");
2990                         } catch (FileLoadException) {
2991                         }
2992 #endif
2993
2994                         aname = new AssemblyName ();
2995                         aname.Name = "bug79522C";
2996                         aname.CodeBase = assemblyFile;
2997                         aname.CultureInfo = new CultureInfo ("nl-BE");
2998                         aname.SetPublicKey (publicKey);
2999 #if NET_2_0
3000                         AppDomain.CurrentDomain.Load (aname);
3001 #else
3002                         // if public key is set, then version must be set
3003                         try {
3004                                 AppDomain.CurrentDomain.Load (aname);
3005                                 Assert.Fail ("#C6");
3006                         } catch (FileLoadException) {
3007                         }
3008 #endif
3009
3010                         aname = new AssemblyName ();
3011                         aname.Name = "bug79522C";
3012                         aname.CodeBase = assemblyFile;
3013                         aname.CultureInfo = new CultureInfo ("nl-BE");
3014 #if NET_2_0
3015                         AppDomain.CurrentDomain.Load (aname);
3016 #else
3017                         try {
3018                                 AppDomain.CurrentDomain.Load (aname);
3019                                 Assert.Fail ("#C7");
3020                         } catch (FileLoadException) {
3021                         }
3022 #endif
3023
3024                         // if culture and version are set, then the version must match
3025                         aname = new AssemblyName ();
3026                         aname.Name = "bug79522C";
3027                         aname.CodeBase = assemblyFile;
3028                         aname.CultureInfo = new CultureInfo ("nl-BE");
3029                         aname.SetPublicKey (publicKey);
3030                         aname.Version = new Version (5, 6);
3031                         try {
3032                                 AppDomain.CurrentDomain.Load (aname);
3033                                 Assert.Fail ("#C8");
3034                         } catch (FileLoadException) {
3035                         }
3036
3037                         // publickey must match
3038                         aname = new AssemblyName ();
3039                         aname.Name = "bug79522C";
3040                         aname.CodeBase = assemblyFile;
3041                         aname.CultureInfo = new CultureInfo ("nl-BE");
3042                         aname.Version = new Version (2, 4);
3043                         aname.SetPublicKey (publicKey2);
3044                         try {
3045                                 AppDomain.CurrentDomain.Load (aname);
3046                                 Assert.Fail ("#C9");
3047 #if NET_2_0
3048                         } catch (SecurityException) {
3049                                 // Invalid assembly public key
3050                         }
3051 #else
3052                         } catch (FileLoadException) {
3053                         }
3054 #endif
3055
3056                         aname = new AssemblyName ();
3057                         aname.Name = "bug79522C";
3058                         aname.CodeBase = assemblyFile;
3059                         aname.SetPublicKey (publicKey);
3060                         aname.CultureInfo = new CultureInfo ("nl-BE");
3061                         aname.Version = new Version (2, 4);
3062                         AppDomain.CurrentDomain.Load (aname);
3063                 }
3064
3065                 [Test] // bug #79715
3066                 public void Load_PartialVersion ()
3067                 {
3068                         AppDomain ad = CreateTestDomain (tempDir, true);
3069                         try {
3070                                 CrossDomainTester cdt = CreateCrossDomainTester (ad);
3071
3072                                 AssemblyName aname = new AssemblyName ();
3073                                 aname.Name = "bug79715";
3074                                 aname.Version = new Version (1, 2, 3, 4);
3075                                 cdt.GenerateAssembly (aname, Path.Combine (tempDir, "bug79715.dll"));
3076
3077                                 aname = new AssemblyName ();
3078                                 aname.Name = "bug79715";
3079                                 aname.Version = new Version (1, 2);
3080                                 Assert.IsTrue (cdt.AssertLoad (aname), "#A1");
3081                                 Assert.IsTrue (cdt.AssertLoad (aname.FullName), "#A2");
3082
3083                                 aname = new AssemblyName ();
3084                                 aname.Name = "bug79715";
3085                                 aname.Version = new Version (1, 2, 3);
3086                                 Assert.IsTrue (cdt.AssertLoad (aname), "#B1");
3087                                 Assert.IsTrue (cdt.AssertLoad (aname.FullName), "#B2");
3088
3089                                 aname = new AssemblyName ();
3090                                 aname.Name = "bug79715";
3091                                 aname.Version = new Version (1, 2, 3, 4);
3092                                 Assert.IsTrue (cdt.AssertLoad (aname), "#C1");
3093                                 Assert.IsTrue (cdt.AssertLoad (aname.FullName), "#C2");
3094                         } finally {
3095                                 AppDomain.Unload (ad);
3096                         }
3097                 }
3098
3099                 [Test]
3100                 [ExpectedException (typeof (ArgumentException))]
3101                 public void Load_EmptyString ()
3102                 {
3103                         AppDomain.CurrentDomain.Load ("");
3104                 }
3105
3106                 [Test]
3107                 public void SetAppDomainPolicy ()
3108                 {
3109                         ad = AppDomain.CreateDomain ("SetAppDomainPolicy_Null");
3110                         ad.SetAppDomainPolicy (PolicyLevel.CreateAppDomainLevel ());
3111                         // not much to see
3112                 }
3113
3114                 [Test]
3115                 [ExpectedException (typeof (ArgumentNullException))]
3116                 public void SetAppDomainPolicy_Null ()
3117                 {
3118                         ad = AppDomain.CreateDomain ("SetAppDomainPolicy_Null");
3119                         ad.SetAppDomainPolicy (null);
3120                 }
3121
3122                 [Test]
3123                 [ExpectedException (typeof (PolicyException))]
3124                 public void SetAppDomainPolicy_Dual ()
3125                 {
3126                         ad = AppDomain.CreateDomain ("SetAppDomainPolicy_Dual");
3127                         PolicyLevel pl = PolicyLevel.CreateAppDomainLevel ();
3128                         PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
3129                         pl.RootCodeGroup.PolicyStatement = new PolicyStatement (ps);
3130                         ad.SetAppDomainPolicy (pl);
3131
3132                         // only one time!
3133                         pl = PolicyLevel.CreateAppDomainLevel ();
3134                         ps = new PermissionSet (PermissionState.None);
3135                         pl.RootCodeGroup.PolicyStatement = new PolicyStatement (ps);
3136                         ad.SetAppDomainPolicy (pl);
3137                 }
3138
3139                 [Test]
3140                 [ExpectedException (typeof (AppDomainUnloadedException))]
3141                 public void SetAppDomainPolicy_Unloaded ()
3142                 {
3143                         ad = AppDomain.CreateDomain ("SetAppDomainPolicy_Unloaded");
3144                         AppDomain.Unload (ad);
3145                         ad.SetAppDomainPolicy (PolicyLevel.CreateAppDomainLevel ());
3146                 }
3147
3148                 [Test]
3149                 [ExpectedException (typeof (ArgumentNullException))]
3150                 public void GetData_Null ()
3151                 {
3152                         AppDomain.CurrentDomain.GetData (null);
3153                 }
3154
3155                 [Test]
3156                 public void SetData ()
3157                 {
3158                         AppDomain.CurrentDomain.SetData ("data", "data");
3159                         Assert.AreEqual ("data", AppDomain.CurrentDomain.GetData ("data"), "GetData");
3160                         AppDomain.CurrentDomain.SetData ("data", null);
3161                         Assert.IsNull (AppDomain.CurrentDomain.GetData ("data"), "GetData-Null");
3162                 }
3163
3164                 [Test]
3165                 [ExpectedException (typeof (ArgumentNullException))]
3166                 public void SetData_Null ()
3167                 {
3168                         AppDomain.CurrentDomain.SetData (null, "data");
3169                 }
3170
3171 #if NET_2_0
3172                 [Test]
3173                 public void ApplyPolicy ()
3174                 {
3175                         ad = AppDomain.CreateDomain ("ApplyPolicy");
3176                         string fullname = Assembly.GetExecutingAssembly ().FullName;
3177                         string result = ad.ApplyPolicy (fullname);
3178                         Assert.AreEqual (fullname, result, "ApplyPolicy");
3179                         // doesn't even requires an assembly name
3180                         Assert.AreEqual ("123", ad.ApplyPolicy ("123"), "Invalid FullName");
3181                 }
3182
3183                 [Test]
3184                 [ExpectedException (typeof (ArgumentException))]
3185                 public void ApplyPolicy_Empty ()
3186                 {
3187                         ad = AppDomain.CreateDomain ("ApplyPolicy_Empty");
3188                         ad.ApplyPolicy (String.Empty);
3189                 }
3190
3191                 [Test]
3192                 [ExpectedException (typeof (ArgumentNullException))]
3193                 public void ApplyPolicy_Null ()
3194                 {
3195                         ad = AppDomain.CreateDomain ("ApplyPolicy_Null");
3196                         ad.ApplyPolicy (null);
3197                 }
3198
3199                 [Test]
3200                 public void DomainManager ()
3201                 {
3202                         Assert.IsNull (AppDomain.CurrentDomain.DomainManager, "CurrentDomain.DomainManager");
3203                         ad = AppDomain.CreateDomain ("DomainManager");
3204                         Assert.IsNull (ad.DomainManager, "ad.DomainManager");
3205                 }
3206
3207                 [Test]
3208                 public void IsDefaultAppDomain ()
3209                 {
3210                         ad = AppDomain.CreateDomain ("ReflectionOnlyGetAssemblies");
3211                         Assert.IsFalse (ad.IsDefaultAppDomain (), "IsDefaultAppDomain");
3212                         // we have no public way to get the default appdomain
3213                 }
3214
3215                 [Test]
3216                 public void ReflectionOnlyGetAssemblies ()
3217                 {
3218                         ad = AppDomain.CreateDomain ("ReflectionOnlyGetAssemblies");
3219                         Assembly [] a = ad.ReflectionOnlyGetAssemblies ();
3220                         Assert.IsNotNull (a, "ReflectionOnlyGetAssemblies");
3221                         Assert.AreEqual (0, a.Length, "Count");
3222
3223                         string assemblyFile = Path.Combine (tempDir, "bug499013.dll");
3224                         AssemblyName aname = new AssemblyName ();
3225                         aname.Name = "bug499013";
3226                         aname.Version = new Version (2, 4);
3227
3228                         GenerateAssembly (aname, assemblyFile);
3229
3230                         Assembly.ReflectionOnlyLoadFrom (assemblyFile);
3231                         foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies ())
3232                                 Assert.IsTrue (assembly.GetName ().Name != "bug499013");
3233                 }
3234
3235                 [Test]
3236                 public void ReflectionOnlyAssemblyResolve ()
3237                 {
3238                         AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(CurrentDomain_ReflectionOnlyAssemblyResolve);
3239                         Assembly asm = Assembly.ReflectionOnlyLoad(Assembly.LoadWithPartialName("System").FullName);
3240                         asm.GetTypes();
3241                 }
3242
3243         [Test]
3244                 public void ResourceResolve ()
3245                 {
3246                         bool called = false;
3247
3248                         ResolveEventHandler del = delegate (object sender, ResolveEventArgs args) {
3249                                         called = true;
3250                                         return null;
3251                         };
3252                         AppDomain.CurrentDomain.ResourceResolve += del;
3253                         Stream st = Assembly.GetExecutingAssembly ().GetManifestResourceStream ("NOT_EXISTING");
3254                         Assert.IsTrue (called);
3255                         AppDomain.CurrentDomain.ResourceResolve -= del;
3256                 }
3257
3258                 private static Assembly CurrentDomain_ReflectionOnlyAssemblyResolve(object sender, ResolveEventArgs args)
3259                 {
3260                         return Assembly.ReflectionOnlyLoad(args.Name);
3261                 }
3262 #endif
3263
3264                 public class StuffToPick
3265                 {
3266                         public StuffToPick () {}
3267                         public void Method () {}
3268                         public int Property { get; set; }
3269                         public event Action Event;
3270                         public int Field;
3271                         public void GenericMethod<T> () {}
3272                 }
3273
3274                 public class StuffToPick<T>
3275                 {
3276                         public StuffToPick () {}
3277                         public void Method () {}
3278                         public int Property { get; set; }
3279                         public event Action Event;
3280                         public int Field;
3281                         public void GenericMethod<T> () {}
3282                 }
3283
3284                 static void TestSerialization (CrossDomainTester tester, object o)
3285                 {
3286                         Assert.AreSame (o, tester.ReturnArg0 (o), "serializing_type_" + o.GetType ());
3287                 }
3288
3289                 [Test] //BXC #12611
3290                 public void ReflectionObjectsAreSerializableTest ()
3291                 {
3292                         ad = CreateTestDomain (tempDir, true);
3293                         CrossDomainTester tester = CreateCrossDomainTester (ad);
3294
3295                         TestSerialization (tester, typeof (StuffToPick));
3296                         TestSerialization (tester, typeof (StuffToPick).GetConstructor(new Type [0]));
3297                         TestSerialization (tester, typeof (StuffToPick).GetMethod ("Method"));
3298                         TestSerialization (tester, typeof (StuffToPick).GetProperty ("Property"));
3299                         TestSerialization (tester, typeof (StuffToPick).GetEvent ("Event"));
3300                         TestSerialization (tester, typeof (StuffToPick).GetField ("Field"));
3301                         TestSerialization (tester, typeof (StuffToPick).GetMethod ("GenericMethod"));
3302
3303                         TestSerialization (tester, typeof (StuffToPick<>));
3304                         TestSerialization (tester, typeof (StuffToPick<>).GetConstructor(new Type [0]));
3305                         TestSerialization (tester, typeof (StuffToPick<>).GetMethod ("Method"));
3306                         TestSerialization (tester, typeof (StuffToPick<>).GetProperty ("Property"));
3307                         TestSerialization (tester, typeof (StuffToPick<>).GetEvent ("Event"));
3308                         TestSerialization (tester, typeof (StuffToPick<>).GetField ("Field"));
3309                         TestSerialization (tester, typeof (StuffToPick<>).GetMethod ("GenericMethod"));
3310
3311                         TestSerialization (tester, typeof (StuffToPick<int>));
3312                         TestSerialization (tester, typeof (StuffToPick<int>).GetConstructor(new Type [0]));
3313                         TestSerialization (tester, typeof (StuffToPick<int>).GetMethod ("Method"));
3314                         TestSerialization (tester, typeof (StuffToPick<int>).GetProperty ("Property"));
3315                         TestSerialization (tester, typeof (StuffToPick<int>).GetEvent ("Event"));
3316                         TestSerialization (tester, typeof (StuffToPick<int>).GetField ("Field"));
3317                         TestSerialization (tester, typeof (StuffToPick<int>).GetMethod ("GenericMethod"));
3318                 }
3319
3320                 [Test] //BXC #12611
3321                 [Category ("NotWorking")] // Serialization can't handle generic methods
3322                 public void GenericReflectionObjectsAreSerializableTest ()
3323                 {
3324                         ad = CreateTestDomain (tempDir, true);
3325                         CrossDomainTester tester = CreateCrossDomainTester (ad);
3326
3327                         TestSerialization (tester, typeof (StuffToPick).GetMethod ("GenericMethod").MakeGenericMethod (typeof (int)));
3328                         TestSerialization (tester, typeof (StuffToPick<>).GetMethod ("GenericMethod").MakeGenericMethod (typeof (int)));
3329                         TestSerialization (tester, typeof (StuffToPick<int>).GetMethod ("GenericMethod").MakeGenericMethod (typeof (int)));
3330                 }
3331
3332                 private static AppDomain CreateTestDomain (string baseDirectory, bool assemblyResolver)
3333                 {
3334                         AppDomainSetup setup = new AppDomainSetup ();
3335                         setup.ApplicationBase = baseDirectory;
3336                         setup.ApplicationName = "testdomain";
3337                         return CreateTestDomain (setup, assemblyResolver);
3338                 }
3339
3340                 private static AppDomain CreateTestDomain (AppDomainSetup setup, bool assemblyResolver)
3341                 {
3342                         AppDomain ad = AppDomain.CreateDomain ("testdomain",
3343                                 AppDomain.CurrentDomain.Evidence, setup);
3344
3345                         if (assemblyResolver) {
3346                                 Assembly ea = Assembly.GetExecutingAssembly ();
3347                                 ad.CreateInstanceFrom (ea.CodeBase,
3348                                         typeof (AssemblyResolveHandler).FullName,
3349                                         false,
3350                                         BindingFlags.Public | BindingFlags.Instance,
3351                                         null,
3352                                         new object [] { ea.Location, ea.FullName },
3353                                         CultureInfo.InvariantCulture,
3354                                         null,
3355                                         null);
3356                         }
3357
3358                         return ad;
3359                 }
3360
3361
3362                 private static CrossDomainTester CreateCrossDomainTester (AppDomain domain)
3363                 {
3364                         Type testerType = typeof (CrossDomainTester);
3365                         return (CrossDomainTester) domain.CreateInstanceAndUnwrap (
3366                                 testerType.Assembly.FullName, testerType.FullName, false,
3367                                 BindingFlags.Public | BindingFlags.Instance, null, new object [0],
3368                                 CultureInfo.InvariantCulture, new object [0], null);
3369                 }
3370
3371                 private static void GenerateAssembly (AssemblyName aname, string path)
3372                 {
3373                         AppDomain ad = CreateTestDomain (AppDomain.CurrentDomain.BaseDirectory,
3374                                 false);
3375                         try {
3376                                 CrossDomainTester cdt = CreateCrossDomainTester (ad);
3377                                 cdt.GenerateAssembly (aname, path);
3378                         } finally {
3379                                 AppDomain.Unload (ad);
3380                         }
3381                 }
3382
3383                 private bool RunningOnUnix {
3384                         get {
3385                                 // check for Unix platforms - see FAQ for more details
3386                                 // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
3387                                 int platform = (int) Environment.OSVersion.Platform;
3388                                 return ((platform == 4) || (platform == 128) || (platform == 6));
3389                         }
3390                 }
3391
3392                 private class CrossDomainTester : MarshalByRefObject
3393                 {
3394                         public void GenerateAssembly (AssemblyName aname, string path)
3395                         {
3396                                 AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
3397                                         aname, AssemblyBuilderAccess.Save, Path.GetDirectoryName (path));
3398                                 ab.Save (Path.GetFileName (path));
3399                         }
3400
3401                         public int AssemblyCount {
3402                                 get {
3403                                         return AppDomain.CurrentDomain.GetAssemblies ().Length;
3404                                 }
3405                         }
3406
3407                         public string GetApplicationBase ()
3408                         {
3409                                 return AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
3410                         }
3411
3412                         public string GetConfigurationFile ()
3413                         {
3414                                 return AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
3415                         }
3416
3417                         public void Load (AssemblyName assemblyRef)
3418                         {
3419                                 AppDomain.CurrentDomain.Load (assemblyRef);
3420                         }
3421
3422                         public void LoadFrom (string assemblyFile)
3423                         {
3424                                 Assembly.LoadFrom (assemblyFile);
3425                         }
3426
3427                         public bool AssertLoad (AssemblyName assemblyRef)
3428                         {
3429                                 try {
3430                                         AppDomain.CurrentDomain.Load (assemblyRef);
3431                                         return true;
3432                                 } catch {
3433                                         return false;
3434                                 }
3435                         }
3436
3437                         public bool AssertLoad (string assemblyString)
3438                         {
3439                                 try {
3440                                         AppDomain.CurrentDomain.Load (assemblyString);
3441                                         return true;
3442                                 } catch {
3443                                         return false;
3444                                 }
3445                         }
3446
3447                         public bool AssertFileLoadException (AssemblyName assemblyRef)
3448                         {
3449                                 try {
3450                                         AppDomain.CurrentDomain.Load (assemblyRef);
3451                                         return false;
3452                                 } catch (FileLoadException) {
3453                                         return true;
3454                                 }
3455                         }
3456
3457                         public bool AssertFileNotFoundException (AssemblyName assemblyRef)
3458                         {
3459                                 try {
3460                                         AppDomain.CurrentDomain.Load (assemblyRef);
3461                                         return false;
3462                                 } catch (FileNotFoundException) {
3463                                         return true;
3464                                 }
3465                         }
3466
3467                         public object ReturnArg0 (object obj)
3468                         {
3469                                 return obj;
3470                         }
3471                 }
3472
3473                 [Serializable ()]
3474                 private class AssemblyResolveHandler
3475                 {
3476                         public AssemblyResolveHandler (string assemblyFile, string assemblyName)
3477                         {
3478                                 _assemblyFile = assemblyFile;
3479                                 _assemblyName = assemblyName;
3480
3481                                 AppDomain.CurrentDomain.AssemblyResolve +=
3482                                         new ResolveEventHandler (ResolveAssembly);
3483                         }
3484
3485                         private Assembly ResolveAssembly (object sender, ResolveEventArgs args)
3486                         {
3487                                 if (args.Name == _assemblyName)
3488                                         return Assembly.LoadFrom (_assemblyFile);
3489
3490                                 return null;
3491                         }
3492
3493                         private readonly string _assemblyFile;
3494                         private readonly string _assemblyName;
3495                 }
3496
3497                 static byte [] keyPair = {
3498                         0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41,
3499                         0x32, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x3D, 0xBD,
3500                         0x72, 0x08, 0xC6, 0x2B, 0x0E, 0xA8, 0xC1, 0xC0, 0x58, 0x07, 0x2B,
3501                         0x63, 0x5F, 0x7C, 0x9A, 0xBD, 0xCB, 0x22, 0xDB, 0x20, 0xB2, 0xA9,
3502                         0xDA, 0xDA, 0xEF, 0xE8, 0x00, 0x64, 0x2F, 0x5D, 0x8D, 0xEB, 0x78,
3503                         0x02, 0xF7, 0xA5, 0x36, 0x77, 0x28, 0xD7, 0x55, 0x8D, 0x14, 0x68,
3504                         0xDB, 0xEB, 0x24, 0x09, 0xD0, 0x2B, 0x13, 0x1B, 0x92, 0x6E, 0x2E,
3505                         0x59, 0x54, 0x4A, 0xAC, 0x18, 0xCF, 0xC9, 0x09, 0x02, 0x3F, 0x4F,
3506                         0xA8, 0x3E, 0x94, 0x00, 0x1F, 0xC2, 0xF1, 0x1A, 0x27, 0x47, 0x7D,
3507                         0x10, 0x84, 0xF5, 0x14, 0xB8, 0x61, 0x62, 0x1A, 0x0C, 0x66, 0xAB,
3508                         0xD2, 0x4C, 0x4B, 0x9F, 0xC9, 0x0F, 0x3C, 0xD8, 0x92, 0x0F, 0xF5,
3509                         0xFF, 0xCE, 0xD7, 0x6E, 0x5C, 0x6F, 0xB1, 0xF5, 0x7D, 0xD3, 0x56,
3510                         0xF9, 0x67, 0x27, 0xA4, 0xA5, 0x48, 0x5B, 0x07, 0x93, 0x44, 0x00,
3511                         0x4A, 0xF8, 0xFF, 0xA4, 0xCB, 0x73, 0xC0, 0x6A, 0x62, 0xB4, 0xB7,
3512                         0xC8, 0x92, 0x58, 0x87, 0xCD, 0x07, 0x0C, 0x7D, 0x6C, 0xC1, 0x4A,
3513                         0xFC, 0x82, 0x57, 0x0E, 0x43, 0x85, 0x09, 0x75, 0x98, 0x51, 0xBB,
3514                         0x35, 0xF5, 0x64, 0x83, 0xC7, 0x79, 0x89, 0x5C, 0x55, 0x36, 0x66,
3515                         0xAB, 0x27, 0xA4, 0xD9, 0xD4, 0x7E, 0x6B, 0x67, 0x64, 0xC1, 0x54,
3516                         0x4E, 0x37, 0xF1, 0x4E, 0xCA, 0xB3, 0xE5, 0x63, 0x91, 0x57, 0x12,
3517                         0x14, 0xA6, 0xEA, 0x8F, 0x8F, 0x2B, 0xFE, 0xF3, 0xE9, 0x16, 0x08,
3518                         0x2B, 0x86, 0xBC, 0x26, 0x0D, 0xD0, 0xC6, 0xC4, 0x1A, 0x72, 0x43,
3519                         0x76, 0xDC, 0xFF, 0x28, 0x52, 0xA1, 0xDE, 0x8D, 0xFA, 0xD5, 0x1F,
3520                         0x0B, 0xB5, 0x4F, 0xAF, 0x06, 0x79, 0x11, 0xEE, 0xA8, 0xEC, 0xD3,
3521                         0x74, 0x55, 0xA2, 0x80, 0xFC, 0xF8, 0xD9, 0x50, 0x69, 0x48, 0x01,
3522                         0xC2, 0x5A, 0x04, 0x56, 0xB4, 0x3E, 0x24, 0x32, 0x20, 0xB5, 0x2C,
3523                         0xDE, 0xBB, 0xBD, 0x13, 0xFD, 0x13, 0xF7, 0x03, 0x3E, 0xE3, 0x37,
3524                         0x84, 0x74, 0xE7, 0xD0, 0x5E, 0x9E, 0xB6, 0x26, 0xAE, 0x6E, 0xB0,
3525                         0x55, 0x6A, 0x52, 0x63, 0x6F, 0x5A, 0x9D, 0xF2, 0x67, 0xD6, 0x61,
3526                         0x4F, 0x7A, 0x45, 0xEE, 0x5C, 0x3D, 0x2B, 0x7C, 0xB2, 0x40, 0x79,
3527                         0x54, 0x84, 0xD1, 0xBE, 0x61, 0x3E, 0x5E, 0xD6, 0x18, 0x8E, 0x14,
3528                         0x98, 0xFC, 0x35, 0xBF, 0x5F, 0x1A, 0x20, 0x2E, 0x1A, 0xD8, 0xFF,
3529                         0xC4, 0x6B, 0xC0, 0xC9, 0x7D, 0x06, 0xEF, 0x09, 0xF9, 0xF3, 0x69,
3530                         0xFC, 0xBC, 0xA2, 0xE6, 0x80, 0x22, 0xB9, 0x79, 0x7E, 0xEF, 0x57,
3531                         0x9F, 0x49, 0xE1, 0xBC, 0x0D, 0xB6, 0xA1, 0xFE, 0x8D, 0xBC, 0xBB,
3532                         0xA3, 0x05, 0x02, 0x6B, 0x04, 0x45, 0xF7, 0x5D, 0xEE, 0x43, 0x06,
3533                         0xD6, 0x9C, 0x94, 0x48, 0x1A, 0x0B, 0x9C, 0xBC, 0xB4, 0x4E, 0x93,
3534                         0x60, 0x87, 0xCD, 0x58, 0xD6, 0x9A, 0x39, 0xA6, 0xC0, 0x7F, 0x8E,
3535                         0xFF, 0x25, 0xC1, 0xD7, 0x2C, 0xF6, 0xF4, 0x6F, 0x24, 0x52, 0x0B,
3536                         0x39, 0x42, 0x1B, 0x0D, 0x04, 0xC1, 0x93, 0x2A, 0x19, 0x1C, 0xF0,
3537                         0xB1, 0x9B, 0xC1, 0x24, 0x6D, 0x1B, 0x0B, 0xDA, 0x1C, 0x8B, 0x72,
3538                         0x48, 0xF0, 0x3E, 0x52, 0xBF, 0x0A, 0x84, 0x3A, 0x9B, 0xC8, 0x6D,
3539                         0x13, 0x1E, 0x72, 0xF4, 0x46, 0x93, 0x88, 0x1A, 0x5F, 0x4C, 0x3C,
3540                         0xE5, 0x9D, 0x6E, 0xBB, 0x4E, 0xDD, 0x5D, 0x1F, 0x11, 0x40, 0xF4,
3541                         0xD7, 0xAF, 0xB3, 0xAB, 0x9A, 0x99, 0x15, 0xF0, 0xDC, 0xAA, 0xFF,
3542                         0x9F, 0x2D, 0x9E, 0x56, 0x4F, 0x35, 0x5B, 0xBA, 0x06, 0x99, 0xEA,
3543                         0xC6, 0xB4, 0x48, 0x51, 0x17, 0x1E, 0xD1, 0x95, 0x84, 0x81, 0x18,
3544                         0xC0, 0xF1, 0x71, 0xDE, 0x44, 0x42, 0x02, 0x06, 0xAC, 0x0E, 0xA8,
3545                         0xE2, 0xF3, 0x1F, 0x96, 0x1F, 0xBE, 0xB6, 0x1F, 0xB5, 0x3E, 0xF6,
3546                         0x81, 0x05, 0x20, 0xFA, 0x2E, 0x40, 0x2E, 0x4D, 0xA0, 0x0E, 0xDA,
3547                         0x42, 0x9C, 0x05, 0xAA, 0x9E, 0xAF, 0x5C, 0xF7, 0x3A, 0x3F, 0xBB,
3548                         0x91, 0x73, 0x45, 0x27, 0xA8, 0xA2, 0x07, 0x4A, 0xEF, 0x59, 0x1E,
3549                         0x97, 0x9D, 0xE0, 0x30, 0x5A, 0x83, 0xCE, 0x1E, 0x57, 0x32, 0x89,
3550                         0x43, 0x41, 0x28, 0x7D, 0x14, 0x8D, 0x8B, 0x41, 0x1A, 0x56, 0x76,
3551                         0x43, 0xDB, 0x64, 0x86, 0x41, 0x64, 0x8D, 0x4C, 0x91, 0x83, 0x4E,
3552                         0xF5, 0x6C };
3553
3554                 static byte [] publicKey2 = {
3555                         0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41,
3556                         0x32, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x7F, 0x7C,
3557                         0xEA, 0x4A, 0x28, 0x33, 0xD8, 0x3C, 0x86, 0x90, 0x86, 0x91, 0x11,
3558                         0xBB, 0x30, 0x0D, 0x3D, 0x69, 0x04, 0x4C, 0x48, 0xF5, 0x4F, 0xE7,
3559                         0x64, 0xA5, 0x82, 0x72, 0x5A, 0x92, 0xC4, 0x3D, 0xC5, 0x90, 0x93,
3560                         0x41, 0xC9, 0x1D, 0x34, 0x16, 0x72, 0x2B, 0x85, 0xC1, 0xF3, 0x99,
3561                         0x62, 0x07, 0x32, 0x98, 0xB7, 0xE4, 0xFA, 0x75, 0x81, 0x8D, 0x08,
3562                         0xB9, 0xFD, 0xDB, 0x00, 0x25, 0x30, 0xC4, 0x89, 0x13, 0xB6, 0x43,
3563                         0xE8, 0xCC, 0xBE, 0x03, 0x2E, 0x1A, 0x6A, 0x4D, 0x36, 0xB1, 0xEB,
3564                         0x49, 0x26, 0x6C, 0xAB, 0xC4, 0x29, 0xD7, 0x8F, 0x25, 0x11, 0xA4,
3565                         0x7C, 0x81, 0x61, 0x97, 0xCB, 0x44, 0x2D, 0x80, 0x49, 0x93, 0x48,
3566                         0xA7, 0xC9, 0xAB, 0xDB, 0xCF, 0xA3, 0x34, 0xCB, 0x6B, 0x86, 0xE0,
3567                         0x4D, 0x27, 0xFC, 0xA7, 0x4F, 0x36, 0xCA, 0x13, 0x42, 0xD3, 0x83,
3568                         0xC4, 0x06, 0x6E, 0x12, 0xE0, 0xA1, 0x3D, 0x9F, 0xA9, 0xEC, 0xD1,
3569                         0xC6, 0x08, 0x1B, 0x3D, 0xF5, 0xDB, 0x4C, 0xD4, 0xF0, 0x2C, 0xAA,
3570                         0xFC, 0xBA, 0x18, 0x6F, 0x48, 0x7E, 0xB9, 0x47, 0x68, 0x2E, 0xF6,
3571                         0x1E, 0x67, 0x1C, 0x7E, 0x0A, 0xCE, 0x10, 0x07, 0xC0, 0x0C, 0xAD,
3572                         0x5E, 0xC1, 0x53, 0x70, 0xD5, 0xE7, 0x25, 0xCA, 0x37, 0x5E, 0x49,
3573                         0x59, 0xD0, 0x67, 0x2A, 0xBE, 0x92, 0x36, 0x86, 0x8A, 0xBF, 0x3E,
3574                         0x17, 0x04, 0xFB, 0x1F, 0x46, 0xC8, 0x10, 0x5C, 0x93, 0x02, 0x43,
3575                         0x14, 0x96, 0x6A, 0xD9, 0x87, 0x17, 0x62, 0x7D, 0x3A, 0x45, 0xBE,
3576                         0x35, 0xDE, 0x75, 0x0B, 0x2A, 0xCE, 0x7D, 0xF3, 0x19, 0x85, 0x4B,
3577                         0x0D, 0x6F, 0x8D, 0x15, 0xA3, 0x60, 0x61, 0x28, 0x55, 0x46, 0xCE,
3578                         0x78, 0x31, 0x04, 0x18, 0x3C, 0x56, 0x4A, 0x3F, 0xA4, 0xC9, 0xB1,
3579                         0x41, 0xED, 0x22, 0x80, 0xA1, 0xB3, 0xE2, 0xC7, 0x1B, 0x62, 0x85,
3580                         0xE4, 0x81, 0x39, 0xCB, 0x1F, 0x95, 0xCC, 0x61, 0x61, 0xDF, 0xDE,
3581                         0xF3, 0x05, 0x68, 0xB9, 0x7D, 0x4F, 0xFF, 0xF3, 0xC0, 0x0A, 0x25,
3582                         0x62, 0xD9, 0x8A, 0x8A, 0x9E, 0x99, 0x0B, 0xFB, 0x85, 0x27, 0x8D,
3583                         0xF6, 0xD4, 0xE1, 0xB9, 0xDE, 0xB4, 0x16, 0xBD, 0xDF, 0x6A, 0x25,
3584                         0x9C, 0xAC, 0xCD, 0x91, 0xF7, 0xCB, 0xC1, 0x81, 0x22, 0x0D, 0xF4,
3585                         0x7E, 0xEC, 0x0C, 0x84, 0x13, 0x5A, 0x74, 0x59, 0x3F, 0x3E, 0x61,
3586                         0x00, 0xD6, 0xB5, 0x4A, 0xA1, 0x04, 0xB5, 0xA7, 0x1C, 0x29, 0xD0,
3587                         0xE1, 0x11, 0x19, 0xD7, 0x80, 0x5C, 0xEE, 0x08, 0x15, 0xEB, 0xC9,
3588                         0xA8, 0x98, 0xF5, 0xA0, 0xF0, 0x92, 0x2A, 0xB0, 0xD3, 0xC7, 0x8C,
3589                         0x8D, 0xBB, 0x88, 0x96, 0x4F, 0x18, 0xF0, 0x8A, 0xF9, 0x31, 0x9E,
3590                         0x44, 0x94, 0x75, 0x6F, 0x78, 0x04, 0x10, 0xEC, 0xF3, 0xB0, 0xCE,
3591                         0xA0, 0xBE, 0x7B, 0x25, 0xE1, 0xF7, 0x8A, 0xA8, 0xD4, 0x63, 0xC2,
3592                         0x65, 0x47, 0xCC, 0x5C, 0xED, 0x7D, 0x8B, 0x07, 0x4D, 0x76, 0x29,
3593                         0x53, 0xAC, 0x27, 0x8F, 0x5D, 0x78, 0x56, 0xFA, 0x99, 0x45, 0xA2,
3594                         0xCC, 0x65, 0xC4, 0x54, 0x13, 0x9F, 0x38, 0x41, 0x7A, 0x61, 0x0E,
3595                         0x0D, 0x34, 0xBC, 0x11, 0xAF, 0xE2, 0xF1, 0x8B, 0xFA, 0x2B, 0x54,
3596                         0x6C, 0xA3, 0x6C, 0x09, 0x1F, 0x0B, 0x43, 0x9B, 0x07, 0x95, 0x83,
3597                         0x3F, 0x97, 0x99, 0x89, 0xF5, 0x51, 0x41, 0xF6, 0x8E, 0x5D, 0xEF,
3598                         0x6D, 0x24, 0x71, 0x41, 0x7A, 0xAF, 0xBE, 0x81, 0x71, 0xAB, 0x76,
3599                         0x2F, 0x1A, 0x5A, 0xBA, 0xF3, 0xA6, 0x65, 0x7A, 0x80, 0x50, 0xCE,
3600                         0x23, 0xC3, 0xC7, 0x53, 0xB0, 0x7C, 0x97, 0x77, 0x27, 0x70, 0x98,
3601                         0xAE, 0xB5, 0x24, 0x66, 0xE1, 0x60, 0x39, 0x41, 0xDA, 0x54, 0x01,
3602                         0x64, 0xFB, 0x10, 0x33, 0xCE, 0x8B, 0xBE, 0x27, 0xD4, 0x21, 0x57,
3603                         0xCC, 0x0F, 0x1A, 0xC1, 0x3D, 0xF3, 0xCC, 0x39, 0xF0, 0x2F, 0xAE,
3604                         0xF1, 0xC0, 0xCD, 0x3B, 0x23, 0x87, 0x49, 0x7E, 0x40, 0x32, 0x6A,
3605                         0xD3, 0x96, 0x4A, 0xE5, 0x5E, 0x6E, 0x26, 0xFD, 0x8A, 0xCF, 0x7E,
3606                         0xFC, 0x37, 0xDE, 0x39, 0x0C, 0x53, 0x81, 0x75, 0x08, 0xAF, 0x6B,
3607                         0x39, 0x6C, 0xFB, 0xC9, 0x79, 0xC0, 0x9B, 0x5F, 0x34, 0x86, 0xB2,
3608                         0xDE, 0xC4, 0x19, 0x84, 0x5F, 0x0E, 0xED, 0x9B, 0xB8, 0xD3, 0x17,
3609                         0xDA, 0x78 };
3610
3611                 static byte [] publicKey = {
3612                         0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00, 0x00,
3613                         0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53,
3614                         0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x3d,
3615                         0xbd, 0x72, 0x08, 0xc6, 0x2b, 0x0e, 0xa8, 0xc1, 0xc0, 0x58, 0x07,
3616                         0x2b, 0x63, 0x5f, 0x7c, 0x9a, 0xbd, 0xcb, 0x22, 0xdb, 0x20, 0xb2,
3617                         0xa9, 0xda, 0xda, 0xef, 0xe8, 0x00, 0x64, 0x2f, 0x5d, 0x8d, 0xeb,
3618                         0x78, 0x02, 0xf7, 0xa5, 0x36, 0x77, 0x28, 0xd7, 0x55, 0x8d, 0x14,
3619                         0x68, 0xdb, 0xeb, 0x24, 0x09, 0xd0, 0x2b, 0x13, 0x1b, 0x92, 0x6e,
3620                         0x2e, 0x59, 0x54, 0x4a, 0xac, 0x18, 0xcf, 0xc9, 0x09, 0x02, 0x3f,
3621                         0x4f, 0xa8, 0x3e, 0x94, 0x00, 0x1f, 0xc2, 0xf1, 0x1a, 0x27, 0x47,
3622                         0x7d, 0x10, 0x84, 0xf5, 0x14, 0xb8, 0x61, 0x62, 0x1a, 0x0c, 0x66,
3623                         0xab, 0xd2, 0x4c, 0x4b, 0x9f, 0xc9, 0x0f, 0x3c, 0xd8, 0x92, 0x0f,
3624                         0xf5, 0xff, 0xce, 0xd7, 0x6e, 0x5c, 0x6f, 0xb1, 0xf5, 0x7d, 0xd3,
3625                         0x56, 0xf9, 0x67, 0x27, 0xa4, 0xa5, 0x48, 0x5b, 0x07, 0x93, 0x44,
3626                         0x00, 0x4a, 0xf8, 0xff, 0xa4, 0xcb };
3627
3628                 static byte [] pk_token = { 0xce, 0x52, 0x76, 0xd8, 0x68, 0x7e, 0Xc6, 0xdc };
3629         }
3630 }
3631
3632 #endif