mcs/class/corlib/Test/System.Reflection/AssemblyNameTest.cs

   1 //
   2 // AssemblyNameTest.cs - NUnit Test Cases for AssemblyName
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2002 Motus Technologies Inc. (http://www.motus.com)
   8 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13 using System.Configuration.Assemblies;
  14 using System.IO;
  15 using System.Reflection;
  16 #if !TARGET_JVM
  17 using System.Reflection.Emit;
  18 #endif
  19 using System.Runtime.Serialization;
  20 using System.Threading;
  21 using System.Globalization;
  22 using System.Runtime.Serialization.Formatters.Binary;
  23 using System.Security;
  24 using System.Security.Permissions;
  25
  26 namespace MonoTests.System.Reflection {
  27
  28 [TestFixture]
  29 public class AssemblyNameTest {
  30         private AssemblyName an;
  31
  32         private string tempDir = Path.Combine (Path.GetTempPath (), "MonoTests.System.Reflection.AssemblyNameTest");
  33
  34 #if !TARGET_JVM // Thread.GetDomain is not supported for TARGET_JVM.
  35         private AppDomain domain;
  36 #endif // TARGET_JVM
  37
  38         // created with "sn -o test.snk test.txt"
  39         static byte[] keyPair = {
  40                 0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53,
  41                 0x41, 0x32, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,
  42                 0x3D, 0xBD, 0x72, 0x08, 0xC6, 0x2B, 0x0E, 0xA8, 0xC1, 0xC0,
  43                 0x58, 0x07, 0x2B, 0x63, 0x5F, 0x7C, 0x9A, 0xBD, 0xCB, 0x22,
  44                 0xDB, 0x20, 0xB2, 0xA9, 0xDA, 0xDA, 0xEF, 0xE8, 0x00, 0x64,
  45                 0x2F, 0x5D, 0x8D, 0xEB, 0x78, 0x02, 0xF7, 0xA5, 0x36, 0x77,
  46                 0x28, 0xD7, 0x55, 0x8D, 0x14, 0x68, 0xDB, 0xEB, 0x24, 0x09,
  47                 0xD0, 0x2B, 0x13, 0x1B, 0x92, 0x6E, 0x2E, 0x59, 0x54, 0x4A,
  48                 0xAC, 0x18, 0xCF, 0xC9, 0x09, 0x02, 0x3F, 0x4F, 0xA8, 0x3E,
  49                 0x94, 0x00, 0x1F, 0xC2, 0xF1, 0x1A, 0x27, 0x47, 0x7D, 0x10,
  50                 0x84, 0xF5, 0x14, 0xB8, 0x61, 0x62, 0x1A, 0x0C, 0x66, 0xAB,
  51                 0xD2, 0x4C, 0x4B, 0x9F, 0xC9, 0x0F, 0x3C, 0xD8, 0x92, 0x0F,
  52                 0xF5, 0xFF, 0xCE, 0xD7, 0x6E, 0x5C, 0x6F, 0xB1, 0xF5, 0x7D,
  53                 0xD3, 0x56, 0xF9, 0x67, 0x27, 0xA4, 0xA5, 0x48, 0x5B, 0x07,
  54                 0x93, 0x44, 0x00, 0x4A, 0xF8, 0xFF, 0xA4, 0xCB, 0x73, 0xC0,
  55                 0x6A, 0x62, 0xB4, 0xB7, 0xC8, 0x92, 0x58, 0x87, 0xCD, 0x07,
  56                 0x0C, 0x7D, 0x6C, 0xC1, 0x4A, 0xFC, 0x82, 0x57, 0x0E, 0x43,
  57                 0x85, 0x09, 0x75, 0x98, 0x51, 0xBB, 0x35, 0xF5, 0x64, 0x83,
  58                 0xC7, 0x79, 0x89, 0x5C, 0x55, 0x36, 0x66, 0xAB, 0x27, 0xA4,
  59                 0xD9, 0xD4, 0x7E, 0x6B, 0x67, 0x64, 0xC1, 0x54, 0x4E, 0x37,
  60                 0xF1, 0x4E, 0xCA, 0xB3, 0xE5, 0x63, 0x91, 0x57, 0x12, 0x14,
  61                 0xA6, 0xEA, 0x8F, 0x8F, 0x2B, 0xFE, 0xF3, 0xE9, 0x16, 0x08,
  62                 0x2B, 0x86, 0xBC, 0x26, 0x0D, 0xD0, 0xC6, 0xC4, 0x1A, 0x72,
  63                 0x43, 0x76, 0xDC, 0xFF, 0x28, 0x52, 0xA1, 0xDE, 0x8D, 0xFA,
  64                 0xD5, 0x1F, 0x0B, 0xB5, 0x4F, 0xAF, 0x06, 0x79, 0x11, 0xEE,
  65                 0xA8, 0xEC, 0xD3, 0x74, 0x55, 0xA2, 0x80, 0xFC, 0xF8, 0xD9,
  66                 0x50, 0x69, 0x48, 0x01, 0xC2, 0x5A, 0x04, 0x56, 0xB4, 0x3E,
  67                 0x24, 0x32, 0x20, 0xB5, 0x2C, 0xDE, 0xBB, 0xBD, 0x13, 0xFD,
  68                 0x13, 0xF7, 0x03, 0x3E, 0xE3, 0x37, 0x84, 0x74, 0xE7, 0xD0,
  69                 0x5E, 0x9E, 0xB6, 0x26, 0xAE, 0x6E, 0xB0, 0x55, 0x6A, 0x52,
  70                 0x63, 0x6F, 0x5A, 0x9D, 0xF2, 0x67, 0xD6, 0x61, 0x4F, 0x7A,
  71                 0x45, 0xEE, 0x5C, 0x3D, 0x2B, 0x7C, 0xB2, 0x40, 0x79, 0x54,
  72                 0x84, 0xD1, 0xBE, 0x61, 0x3E, 0x5E, 0xD6, 0x18, 0x8E, 0x14,
  73                 0x98, 0xFC, 0x35, 0xBF, 0x5F, 0x1A, 0x20, 0x2E, 0x1A, 0xD8,
  74                 0xFF, 0xC4, 0x6B, 0xC0, 0xC9, 0x7D, 0x06, 0xEF, 0x09, 0xF9,
  75                 0xF3, 0x69, 0xFC, 0xBC, 0xA2, 0xE6, 0x80, 0x22, 0xB9, 0x79,
  76                 0x7E, 0xEF, 0x57, 0x9F, 0x49, 0xE1, 0xBC, 0x0D, 0xB6, 0xA1,
  77                 0xFE, 0x8D, 0xBC, 0xBB, 0xA3, 0x05, 0x02, 0x6B, 0x04, 0x45,
  78                 0xF7, 0x5D, 0xEE, 0x43, 0x06, 0xD6, 0x9C, 0x94, 0x48, 0x1A,
  79                 0x0B, 0x9C, 0xBC, 0xB4, 0x4E, 0x93, 0x60, 0x87, 0xCD, 0x58,
  80                 0xD6, 0x9A, 0x39, 0xA6, 0xC0, 0x7F, 0x8E, 0xFF, 0x25, 0xC1,
  81                 0xD7, 0x2C, 0xF6, 0xF4, 0x6F, 0x24, 0x52, 0x0B, 0x39, 0x42,
  82                 0x1B, 0x0D, 0x04, 0xC1, 0x93, 0x2A, 0x19, 0x1C, 0xF0, 0xB1,
  83                 0x9B, 0xC1, 0x24, 0x6D, 0x1B, 0x0B, 0xDA, 0x1C, 0x8B, 0x72,
  84                 0x48, 0xF0, 0x3E, 0x52, 0xBF, 0x0A, 0x84, 0x3A, 0x9B, 0xC8,
  85                 0x6D, 0x13, 0x1E, 0x72, 0xF4, 0x46, 0x93, 0x88, 0x1A, 0x5F,
  86                 0x4C, 0x3C, 0xE5, 0x9D, 0x6E, 0xBB, 0x4E, 0xDD, 0x5D, 0x1F,
  87                 0x11, 0x40, 0xF4, 0xD7, 0xAF, 0xB3, 0xAB, 0x9A, 0x99, 0x15,
  88                 0xF0, 0xDC, 0xAA, 0xFF, 0x9F, 0x2D, 0x9E, 0x56, 0x4F, 0x35,
  89                 0x5B, 0xBA, 0x06, 0x99, 0xEA, 0xC6, 0xB4, 0x48, 0x51, 0x17,
  90                 0x1E, 0xD1, 0x95, 0x84, 0x81, 0x18, 0xC0, 0xF1, 0x71, 0xDE,
  91                 0x44, 0x42, 0x02, 0x06, 0xAC, 0x0E, 0xA8, 0xE2, 0xF3, 0x1F,
  92                 0x96, 0x1F, 0xBE, 0xB6, 0x1F, 0xB5, 0x3E, 0xF6, 0x81, 0x05,
  93                 0x20, 0xFA, 0x2E, 0x40, 0x2E, 0x4D, 0xA0, 0x0E, 0xDA, 0x42,
  94                 0x9C, 0x05, 0xAA, 0x9E, 0xAF, 0x5C, 0xF7, 0x3A, 0x3F, 0xBB,
  95                 0x91, 0x73, 0x45, 0x27, 0xA8, 0xA2, 0x07, 0x4A, 0xEF, 0x59,
  96                 0x1E, 0x97, 0x9D, 0xE0, 0x30, 0x5A, 0x83, 0xCE, 0x1E, 0x57,
  97                 0x32, 0x89, 0x43, 0x41, 0x28, 0x7D, 0x14, 0x8D, 0x8B, 0x41,
  98                 0x1A, 0x56, 0x76, 0x43, 0xDB, 0x64, 0x86, 0x41, 0x64, 0x8D,
  99                 0x4C, 0x91, 0x83, 0x4E, 0xF5, 0x6C };
 100
 101         static byte [] kp_token = { 0xff, 0xef, 0x94, 0x53, 0x67, 0x69, 0xda, 0x06 };
 102
 103         static byte [] publicKey1 = {
 104                 0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00,
 105                 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
 106                 0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00,
 107                 0x01, 0x00, 0x3d, 0xbd, 0x72, 0x08, 0xc6, 0x2b, 0x0e, 0xa8,
 108                 0xc1, 0xc0, 0x58, 0x07, 0x2b, 0x63, 0x5f, 0x7c, 0x9a, 0xbd,
 109                 0xcb, 0x22, 0xdb, 0x20, 0xb2, 0xa9, 0xda, 0xda, 0xef, 0xe8,
 110                 0x00, 0x64, 0x2f, 0x5d, 0x8d, 0xeb, 0x78, 0x02, 0xf7, 0xa5,
 111                 0x36, 0x77, 0x28, 0xd7, 0x55, 0x8d, 0x14, 0x68, 0xdb, 0xeb,
 112                 0x24, 0x09, 0xd0, 0x2b, 0x13, 0x1b, 0x92, 0x6e, 0x2e, 0x59,
 113                 0x54, 0x4a, 0xac, 0x18, 0xcf, 0xc9, 0x09, 0x02, 0x3f, 0x4f,
 114                 0xa8, 0x3e, 0x94, 0x00, 0x1f, 0xc2, 0xf1, 0x1a, 0x27, 0x47,
 115                 0x7d, 0x10, 0x84, 0xf5, 0x14, 0xb8, 0x61, 0x62, 0x1a, 0x0c,
 116                 0x66, 0xab, 0xd2, 0x4c, 0x4b, 0x9f, 0xc9, 0x0f, 0x3c, 0xd8,
 117                 0x92, 0x0f, 0xf5, 0xff, 0xce, 0xd7, 0x6e, 0x5c, 0x6f, 0xb1,
 118                 0xf5, 0x7d, 0xd3, 0x56, 0xf9, 0x67, 0x27, 0xa4, 0xa5, 0x48,
 119                 0x5b, 0x07, 0x93, 0x44, 0x00, 0x4a, 0xf8, 0xff, 0xa4, 0xcb };
 120
 121         static byte [] pk_token1 = { 0xce, 0x52, 0x76, 0xd8, 0x68, 0x7e, 0Xc6, 0xdc };
 122
 123         static byte [] publicKey2 = {
 124                 0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00,
 125                 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
 126                 0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00,
 127                 0x01, 0x00, 0x6d, 0xfd, 0xba, 0xb9, 0x9d, 0x43, 0xf1, 0xef,
 128                 0x33, 0xe2, 0xbd, 0x2d, 0x7c, 0x26, 0xe2, 0x9d, 0x37, 0x4a,
 129                 0xdf, 0xb5, 0x63, 0x12, 0x90, 0x35, 0x90, 0x24, 0x8a, 0xe7,
 130                 0x5a, 0xc5, 0xa3, 0x3a, 0x84, 0xee, 0x9b, 0xd1, 0xac, 0x3a,
 131                 0x59, 0x2b, 0x91, 0x97, 0x83, 0x01, 0x4f, 0x92, 0x01, 0xc6,
 132                 0x3b, 0x96, 0x20, 0x19, 0xeb, 0xdc, 0x2c, 0x6f, 0x1f, 0xbb,
 133                 0x04, 0x9b, 0x62, 0x39, 0xc0, 0xff, 0x58, 0x64, 0x17, 0x48,
 134                 0xc2, 0x5b, 0x94, 0x98, 0x35, 0x50, 0x1f, 0x27, 0xbc, 0xea,
 135                 0x91, 0x92, 0x3f, 0x5c, 0x33, 0x12, 0x17, 0x65, 0x56, 0x3e,
 136                 0x40, 0x44, 0x27, 0x1d, 0xef, 0x0e, 0x72, 0xab, 0xd4, 0xf0,
 137                 0x49, 0xa3, 0x95, 0x1a, 0x61, 0xb4, 0x47, 0x90, 0x20, 0xcc,
 138                 0x50, 0xa4, 0x4d, 0x8b, 0x8a, 0x58, 0x17, 0x70, 0xa4, 0x53,
 139                 0xe4, 0xdc, 0x73, 0x5d, 0x8c, 0x4e, 0xb8, 0xd3, 0xa9, 0xbf };
 140
 141         static byte [] pk_token2 = { 0x22, 0x7c, 0x9c, 0x2c, 0x3c, 0x00, 0x63, 0xe9 };
 142
 143         static byte [] publicKey3 = {
 144                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
 145                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 146
 147         static byte [] pk_token3 = { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 };
 148
 149         [SetUp]
 150         public void SetUp ()
 151         {
 152                 try {
 153                         if (Directory.Exists (tempDir))
 154                                 Directory.Delete (tempDir, true);
 155                 }
 156                 catch (Exception) {
 157                 }
 158
 159                 Directory.CreateDirectory (tempDir);
 160
 161 #if !TARGET_JVM // Thread.GetDomain is not supported for TARGET_JVM.
 162                 domain = Thread.GetDomain ();
 163 #endif // TARGET_JVM
 164         }
 165
 166         [TearDown]
 167         public void TearDown ()
 168         {
 169                 try {
 170                         if (Directory.Exists (tempDir))
 171                                 Directory.Delete (tempDir, true);
 172                 }
 173                 catch (Exception) {
 174                         // This can happen on windows when the directory contains
 175                         // files opened by the CLR
 176                 }
 177         }
 178
 179         [Test] // ctor ()
 180         public void Constructor0 ()
 181         {
 182                 an = new AssemblyName ();
 183                 Assert.IsNull (an.CodeBase, "CodeBase");
 184                 Assert.IsNull (an.CultureInfo, "CultureInfo");
 185                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
 186                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
 187 #if NET_2_0
 188                 Assert.AreEqual (String.Empty, an.FullName, "FullName");
 189 #else
 190                 Assert.IsNull (an.FullName, "FullName");
 191 #endif
 192                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
 193                 Assert.IsNull (an.KeyPair, "KeyPair");
 194                 Assert.IsNull (an.Name, "Name");
 195 #if NET_2_0
 196                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
 197 #endif
 198                 Assert.IsNull (an.Version, "Version");
 199                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
 200                         an.VersionCompatibility, "VersionCompatibility");
 201                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
 202                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
 203 #if NET_2_0
 204                 Assert.AreEqual (string.Empty, an.ToString (), "ToString");
 205 #else
 206                 Assert.AreEqual (typeof (AssemblyName).FullName, an.ToString (), "ToString");
 207 #endif
 208         }
 209
 210         [Test]
 211         public void SetPublicKey ()
 212         {
 213                 an = new AssemblyName ();
 214                 Assert.IsNull (an.GetPublicKey (), "#A1");
 215                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A2");
 216                 Assert.IsNull (an.KeyPair, "#A3");
 217                 Assert.IsNull (an.GetPublicKeyToken (), "#A4");
 218
 219                 an.SetPublicKey (publicKey1);
 220
 221                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "#B1");
 222                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#B2");
 223                 Assert.IsNull (an.KeyPair, "#B3");
 224                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B4");
 225                 an.SetPublicKey (keyPair);
 226                 Assert.AreEqual (keyPair, an.GetPublicKey (), "#B5");
 227                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B6");
 228
 229                 an.SetPublicKey ((byte []) null);
 230
 231                 Assert.IsNull (an.GetPublicKey (), "#C1");
 232 #if NET_2_0
 233                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#C2");
 234 #else
 235                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#C2");
 236 #endif
 237                 Assert.IsNull (an.KeyPair, "#C3");
 238                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C4");
 239
 240                 an.SetPublicKey (publicKey1);
 241                 an.SetPublicKeyToken (pk_token1);
 242                 an.SetPublicKey ((byte []) null);
 243
 244                 Assert.IsNull (an.GetPublicKey (), "#D1");
 245 #if NET_2_0
 246                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#D2");
 247 #else
 248                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#D2");
 249 #endif
 250                 Assert.IsNull (an.KeyPair, "#D3");
 251                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#D4");
 252
 253                 an.SetPublicKey ((byte []) null);
 254                 an.SetPublicKeyToken (pk_token1);
 255                 an.SetPublicKey ((byte []) null);
 256
 257                 Assert.IsNull (an.GetPublicKey (), "#E1");
 258 #if NET_2_0
 259                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#E2");
 260 #else
 261                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#E2");
 262 #endif
 263                 Assert.IsNull (an.KeyPair, "#E3");
 264                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#E4");
 265
 266                 an = new AssemblyName ();
 267                 an.SetPublicKey (publicKey1);
 268                 an.SetPublicKey ((byte []) null);
 269                 an.SetPublicKeyToken (pk_token1);
 270                 an.SetPublicKey ((byte []) null);
 271
 272                 Assert.IsNull (an.GetPublicKey (), "#F1");
 273                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#F2");
 274                 Assert.IsNull (an.KeyPair, "#F3");
 275                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#F4");
 276
 277                 an = new AssemblyName ();
 278                 an.SetPublicKey (publicKey1);
 279                 an.SetPublicKey ((byte []) null);
 280                 an.SetPublicKeyToken (pk_token1);
 281
 282                 Assert.IsNull (an.GetPublicKey (), "#G1");
 283 #if NET_2_0
 284                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#G2");
 285 #else
 286                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#G2");
 287 #endif
 288                 Assert.IsNull (an.KeyPair, "#G3");
 289                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#G4");
 290
 291                 an = new AssemblyName ();
 292                 an.SetPublicKey (new byte [0]);
 293
 294                 Assert.IsNotNull (an.GetPublicKey (), "#H1");
 295                 Assert.AreEqual (0, an.GetPublicKey ().Length, "#H2");
 296                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#H3");
 297                 Assert.IsNull (an.KeyPair, "#H4");
 298 #if NET_2_0
 299                 Assert.IsNotNull (an.GetPublicKeyToken (), "#H5");
 300                 Assert.AreEqual (0, an.GetPublicKeyToken ().Length, "#H6");
 301 #else
 302                 Assert.IsNull (an.GetPublicKeyToken (), "#H5");
 303 #endif
 304
 305                 an = new AssemblyName ();
 306                 an.SetPublicKey (publicKey1);
 307                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#I1");
 308                 an.SetPublicKey (publicKey1);
 309                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#I2");
 310
 311                 an = new AssemblyName ();
 312                 an.SetPublicKey ((byte []) null);
 313                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J1");
 314                 an.SetPublicKey ((byte []) null);
 315 #if NET_2_0
 316                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#J2");
 317 #else
 318                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J2");
 319 #endif
 320                 an.SetPublicKey ((byte []) null);
 321                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J3");
 322                 an.SetPublicKey (publicKey1);
 323                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J4");
 324                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "#J5");
 325                 an.SetPublicKey (publicKey2);
 326                 Assert.AreEqual (publicKey2, an.GetPublicKey (), "#J6");
 327         }
 328
 329         [Test]
 330         public void SetPublicKey_PublicKey_Invalid ()
 331         {
 332                 an = new AssemblyName ();
 333                 an.SetPublicKey (new byte [] { 0x0b, 0x0a });
 334                 Assert.AreEqual (new byte [] { 0x0b, 0x0a }, an.GetPublicKey (), "#1");
 335         }
 336
 337         [Test]
 338         public void SetPublicKeyToken ()
 339         {
 340                 an = new AssemblyName ();
 341                 an.SetPublicKeyToken (pk_token1);
 342
 343                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A1");
 344                 Assert.IsNull (an.KeyPair, "#A2");
 345                 Assert.IsNull (an.GetPublicKey (), "#A3");
 346                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A4");
 347
 348                 an.SetPublicKeyToken ((byte []) null);
 349
 350                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B1");
 351                 Assert.IsNull (an.KeyPair, "#B2");
 352                 Assert.IsNull (an.GetPublicKey (), "#B3");
 353                 Assert.IsNull (an.GetPublicKeyToken (), "#B4");
 354
 355                 an.SetPublicKeyToken (new byte [0]);
 356
 357                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#C1");
 358                 Assert.IsNull (an.KeyPair, "#C2");
 359                 Assert.IsNull (an.GetPublicKey (), "#C3");
 360                 Assert.IsNotNull (an.GetPublicKeyToken (), "#C4");
 361                 Assert.AreEqual (0, an.GetPublicKeyToken ().Length, "#C5");
 362         }
 363
 364         [Test]
 365         public void KeyPair ()
 366         {
 367                 an = new AssemblyName ();
 368                 an.Name = "test";
 369                 an.KeyPair = new StrongNameKeyPair (keyPair);
 370
 371                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A1");
 372                 Assert.IsNotNull (an.KeyPair, "#A2");
 373                 Assert.IsNull (an.GetPublicKey (), "#A3");
 374                 Assert.IsNull (an.GetPublicKeyToken (), "#A4");
 375                 Assert.AreEqual ("test", an.FullName, "#A5");
 376
 377                 an.KeyPair = null;
 378
 379                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B1");
 380                 Assert.IsNull (an.KeyPair, "#B2");
 381                 Assert.IsNull (an.GetPublicKey (), "#B3");
 382                 Assert.IsNull (an.GetPublicKeyToken (), "#B4");
 383                 Assert.AreEqual ("test", an.FullName, "#B5");
 384         }
 385
 386         // !!! this assembly MUST NOT use a StrongName !!!
 387         [Test]
 388         public void Self ()
 389         {
 390                 Assembly a = Assembly.GetExecutingAssembly ();
 391                 an = a.GetName ();
 392
 393                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo");
 394                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags");
 395                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1, an.HashAlgorithm, "HashAlgorithm");
 396                 Assert.IsNull (an.KeyPair, "KeyPair");
 397                 Assert.IsNotNull (an.Name, "Name");
 398 #if NET_2_0
 399                 //Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "PA");
 400 #endif
 401                 Assert.AreEqual (new Version (0, 0, 0, 0), an.Version, "Version");
 402                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
 403                         an.VersionCompatibility, "VersionCompatibility");
 404                 Assert.AreEqual (new byte [0], an.GetPublicKey (), "GetPublicKey");
 405                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
 406         }
 407
 408         [Test]
 409         public void Flags_Corlib ()
 410         {
 411                 an = typeof (int).Assembly.GetName ();
 412                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags);
 413         }
 414
 415         [Test]
 416         public void Flags_Self ()
 417         {
 418                 Assembly a = Assembly.GetExecutingAssembly ();
 419                 an = a.GetName ();
 420                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags);
 421         }
 422
 423         [Test]
 424         public void FullName_Corlib ()
 425         {
 426                 an = typeof(int).Assembly.GetName ();
 427                 Assert.IsNotNull (an.FullName, "#1");
 428                 Assert.AreEqual (Consts.AssemblyCorlib, an.FullName, "#2");
 429         }
 430
 431         [Test]
 432         public void FullName_Self ()
 433         {
 434                 Assembly a = Assembly.GetExecutingAssembly ();
 435                 an = a.GetName ();
 436
 437                 Assert.IsNotNull (an.FullName, "#1");
 438                 Assert.IsTrue (an.FullName.IndexOf ("Version=0.0.0.0") != -1, "#2");
 439                 Assert.IsTrue (an.FullName.IndexOf ("Culture=neutral") != -1, "#3");
 440                 Assert.IsTrue (an.FullName.IndexOf ("PublicKeyToken=null") != -1, "#4");
 441         }
 442
 443         [Test]
 444         public void FullName_Name ()
 445         {
 446                 const string assemblyName = "TestAssembly";
 447
 448                 // tests for AssemblyName with only name
 449                 an = new AssemblyName ();
 450                 an.Name = assemblyName;
 451                 Assert.IsNotNull (an.FullName, "FullName2#1");
 452                 Assert.AreEqual (an.Name, an.FullName, "FullName2#2");
 453                 Assert.AreEqual (-1, an.FullName.IndexOf ("Culture="), "FullName2#3");
 454                 Assert.AreEqual (-1, an.FullName.IndexOf ("PublicKeyToken="), "FullName2#4");
 455         }
 456
 457         [Test]
 458         public void FullName_Version ()
 459         {
 460                 const string assemblyName = "TestAssembly";
 461                 const string assemblyVersion = "1.2";
 462
 463                 // tests for AssemblyName with name and version
 464                 an = new AssemblyName ();
 465                 an.Name = assemblyName;
 466                 an.Version = new Version (assemblyVersion);
 467                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion, an.FullName, "FullName3#1");
 468         }
 469
 470         [Test]
 471         public void FullName_Culture ()
 472         {
 473                 const string assemblyName = "TestAssembly";
 474
 475                 // tests for AssemblyName with name and neutral culture
 476                 an = new AssemblyName ();
 477                 an.Name = assemblyName;
 478                 an.CultureInfo = CultureInfo.InvariantCulture;
 479                 Assert.AreEqual (assemblyName + ", Culture=neutral", an.FullName, "FullName4#1");
 480         }
 481
 482         [Test]
 483         public void FullName_PublicKey ()
 484         {
 485                 const string assemblyName = "TestAssembly";
 486
 487                 // tests for AssemblyName with name and public key
 488                 an = new AssemblyName ();
 489                 an.Name = assemblyName;
 490                 an.SetPublicKey (publicKey1);
 491                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1");
 492                 an.SetPublicKey ((byte []) null);
 493                 Assert.AreEqual (assemblyName, an.FullName, "#A2");
 494                 an.SetPublicKey (new byte [0]);
 495                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3");
 496                 an.Name = null;
 497 #if NET_2_0
 498                 Assert.AreEqual (string.Empty, an.FullName, "#A4");
 499 #else
 500                 Assert.IsNull (an.FullName, "#A4");
 501 #endif
 502
 503                 an = new AssemblyName ();
 504                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 505                 an.Name = assemblyName;
 506                 an.SetPublicKey (publicKey1);
 507                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1");
 508                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 509 #if NET_2_0
 510                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2");
 511 #else
 512                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B2");
 513 #endif
 514                 an.SetPublicKeyToken ((byte []) null);
 515                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B3");
 516                 an.Name = null;
 517 #if NET_2_0
 518                 Assert.AreEqual (string.Empty, an.FullName, "#B4");
 519 #else
 520                 Assert.IsNull (an.FullName, "#B4");
 521 #endif
 522
 523                 an = new AssemblyName ();
 524                 an.HashAlgorithm = AssemblyHashAlgorithm.None;
 525                 an.Name = assemblyName;
 526                 an.SetPublicKey (publicKey1);
 527                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1");
 528                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 529 #if NET_2_0
 530                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#C2");
 531 #else
 532                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C2");
 533 #endif
 534                 an.SetPublicKeyToken ((byte []) null);
 535                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C3");
 536                 an.Name = null;
 537 #if NET_2_0
 538                 Assert.AreEqual (string.Empty, an.FullName, "#C4");
 539 #else
 540                 Assert.IsNull (an.FullName, "#C4");
 541 #endif
 542
 543                 an = new AssemblyName ();
 544                 an.Name = assemblyName;
 545                 an.SetPublicKey (new byte [0]);
 546                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1");
 547                 an.Name = null;
 548 #if NET_2_0
 549                 Assert.AreEqual (string.Empty, an.FullName, "#D2");
 550 #else
 551                 Assert.IsNull (an.FullName, "#D2");
 552 #endif
 553                 an.SetPublicKey (publicKey3);
 554 #if NET_2_0
 555                 Assert.AreEqual (string.Empty, an.FullName, "#D3");
 556 #else
 557                 Assert.IsNull (an.FullName, "#D3");
 558 #endif
 559                 an.Name = assemblyName;
 560                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "#D4");
 561         }
 562
 563         [Test]
 564         public void FullName_PublicKey_KeyPair ()
 565         {
 566                 const string assemblyName = "TestAssembly";
 567
 568                 // tests for AssemblyName with name and public key
 569                 an = new AssemblyName ();
 570                 an.Name = assemblyName;
 571                 an.SetPublicKey (keyPair);
 572 #if NET_2_0
 573                 try {
 574                         Assert.Fail ("#A1: " + an.FullName);
 575                 } catch (SecurityException ex) {
 576                         // Invalid assembly public key
 577                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#A2");
 578                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#A3");
 579                         Assert.IsNull (ex.InnerException, "#A4");
 580                         Assert.IsNotNull (ex.Message, "#A5");
 581                 }
 582 #else
 583                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#A1");
 584 #endif
 585
 586                 an.SetPublicKeyToken (new byte [0]);
 587 #if NET_2_0
 588                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#B1");
 589 #else
 590                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#B1");
 591 #endif
 592
 593                 an.SetPublicKeyToken ((byte []) null);
 594 #if NET_2_0
 595                 try {
 596                         Assert.Fail ("#C1: " + an.FullName);
 597                 } catch (SecurityException ex) {
 598                         // Invalid assembly public key
 599                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#C2");
 600                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#C3");
 601                         Assert.IsNull (ex.InnerException, "#C4");
 602                         Assert.IsNotNull (ex.Message, "#C5");
 603                 }
 604 #else
 605                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#C1");
 606 #endif
 607
 608                 an.SetPublicKeyToken (new byte [0]);
 609 #if NET_2_0
 610                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1");
 611 #else
 612                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#D1");
 613 #endif
 614                 an.SetPublicKey (publicKey1);
 615 #if NET_2_0
 616                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2");
 617 #else
 618                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D2");
 619 #endif
 620                 an.SetPublicKeyToken ((byte []) null);
 621                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3");
 622         }
 623
 624         [Test]
 625         public void FullName_PublicKeyToken ()
 626         {
 627                 const string assemblyName = "TestAssembly";
 628
 629                 an = new AssemblyName ();
 630                 an.Name = assemblyName;
 631                 an.SetPublicKeyToken (pk_token1);
 632                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1");
 633                 an.SetPublicKeyToken ((byte []) null);
 634                 Assert.AreEqual (assemblyName, an.FullName, "#A2");
 635                 an.SetPublicKeyToken (new byte [0]);
 636                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3");
 637                 an.SetPublicKeyToken (pk_token1);
 638                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A4");
 639                 an.Name = null;
 640 #if NET_2_0
 641                 Assert.AreEqual (string.Empty, an.FullName, "#A5");
 642 #else
 643                 Assert.IsNull (an.FullName, "#A5");
 644 #endif
 645
 646                 an = new AssemblyName ();
 647                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 648                 an.Name = assemblyName;
 649                 an.SetPublicKeyToken (pk_token1);
 650                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1");
 651                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 652                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2");
 653                 an.SetPublicKeyToken ((byte []) null);
 654                 Assert.AreEqual (assemblyName, an.FullName, "#B3");
 655                 an.Name = null;
 656 #if NET_2_0
 657                 Assert.AreEqual (string.Empty, an.FullName, "#B4");
 658 #else
 659                 Assert.IsNull (an.FullName, "#B4");
 660 #endif
 661
 662                 an = new AssemblyName ();
 663                 an.Name = assemblyName;
 664                 an.SetPublicKey (publicKey1);
 665                 an.SetPublicKeyToken (pk_token1);
 666                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1");
 667                 an.SetPublicKey ((byte []) null);
 668 #if NET_2_0
 669                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C2");
 670 #else
 671                 Assert.AreEqual (assemblyName, an.FullName, "#C2");
 672 #endif
 673                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C3");
 674                 an.SetPublicKey (new byte [0]);
 675 #if NET_2_0
 676                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C4");
 677 #else
 678                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#C4");
 679 #endif
 680                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C5");
 681
 682                 an = new AssemblyName ();
 683                 an.Name = assemblyName;
 684                 an.SetPublicKey (publicKey1);
 685                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D1");
 686                 an.SetPublicKey (new byte [0]);
 687                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2");
 688                 an.SetPublicKeyToken (pk_token1);
 689 #if NET_2_0
 690                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3");
 691 #else
 692                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D3");
 693 #endif
 694                 an.SetPublicKey ((byte []) null);
 695 #if NET_2_0
 696                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D4");
 697 #else
 698                 Assert.AreEqual (assemblyName, an.FullName, "#D4");
 699 #endif
 700         }
 701
 702         [Test]
 703         public void FullName_VersionCulture ()
 704         {
 705                 const string assemblyName = "TestAssembly";
 706                 const string assemblyVersion = "1.2";
 707
 708                 // tests for AssemblyName with name, version and neutral culture
 709                 an = new AssemblyName ();
 710                 an.Name = assemblyName;
 711                 an.Version = new Version (assemblyVersion);
 712                 an.CultureInfo = CultureInfo.InvariantCulture;
 713                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 714                         + ", Culture=neutral", an.FullName, "#1");
 715                 an.CultureInfo = new CultureInfo ("en-US");
 716                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 717                         + ", Culture=en-US", an.FullName, "#2");
 718                 an.CultureInfo = new CultureInfo ("en");
 719                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 720                         + ", Culture=en", an.FullName, "#3");
 721         }
 722
 723         [Test]
 724         public void FullName_VersionPublicKey ()
 725         {
 726                 const string assemblyName = "TestAssembly";
 727                 const string assemblyVersion = "1.2";
 728
 729                 // tests for AssemblyName with name, version and public key
 730                 an = new AssemblyName ();
 731                 an.Name = assemblyName;
 732                 an.Version = new Version (assemblyVersion);
 733                 an.SetPublicKey (publicKey1);
 734                 an.SetPublicKeyToken (pk_token1);
 735                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 736                         + ", PublicKeyToken=" + GetTokenString (pk_token1),
 737                         an.FullName, "#1");
 738         }
 739
 740         [Test]
 741         public void FullName_CulturePublicKey ()
 742         {
 743                 const string assemblyName = "TestAssembly";
 744
 745                 // tests for AssemblyName with name, culture and public key
 746                 an = new AssemblyName ();
 747                 an.Name = assemblyName;
 748                 an.CultureInfo = CultureInfo.InvariantCulture;
 749                 an.SetPublicKey (publicKey1);
 750                 an.SetPublicKeyToken (pk_token1);
 751                 Assert.AreEqual (assemblyName + ", Culture=neutral"
 752                         + ", PublicKeyToken=" + GetTokenString (pk_token1),
 753                         an.FullName, "#1");
 754         }
 755
 756         [Test]
 757         public void GetPublicKeyToken ()
 758         {
 759                 const string assemblyName = "TestAssembly";
 760
 761                 an = new AssemblyName ();
 762                 an.SetPublicKey (publicKey1);
 763                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A1");
 764                 an.SetPublicKey (publicKey2);
 765                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A2");
 766                 an.SetPublicKeyToken (new byte [] { 0x0a });
 767                 Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A3");
 768                 an.SetPublicKey (publicKey1);
 769                 Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A4");
 770                 an.SetPublicKeyToken (new byte [0]);
 771                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A5");
 772                 an.Name = assemblyName;
 773                 an.SetPublicKey (publicKey2);
 774                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A6");
 775 #if NET_2_0
 776                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A7");
 777 #else
 778                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token2), an.FullName, "#A7");
 779 #endif
 780
 781                 an = new AssemblyName ();
 782                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 783                 an.SetPublicKey (publicKey1);
 784                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B1");
 785
 786                 an = new AssemblyName ();
 787                 an.HashAlgorithm = AssemblyHashAlgorithm.None;
 788                 an.SetPublicKey (publicKey1);
 789                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C1");
 790
 791                 an = new AssemblyName ();
 792                 an.SetPublicKeyToken (new byte [0]);
 793                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#D1");
 794                 an.SetPublicKeyToken (new byte [] { 0x0b, 0xff });
 795                 Assert.AreEqual (new byte [] { 0x0b, 0xff }, an.GetPublicKeyToken (), "#D2");
 796                 an.SetPublicKeyToken ((byte []) null);
 797                 Assert.IsNull (an.GetPublicKeyToken (), "#D3");
 798
 799                 an = new AssemblyName ();
 800                 an.SetPublicKey (keyPair);
 801 #if NET_2_0
 802                 try {
 803                         an.GetPublicKeyToken ();
 804                         Assert.Fail ("#E1");
 805                 } catch (SecurityException ex) {
 806                         // Invalid assembly public key
 807                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#E2");
 808                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#E3");
 809                         Assert.IsNull (ex.InnerException, "#E4");
 810                         Assert.IsNotNull (ex.Message, "#E5");
 811                 }
 812 #else
 813                 Assert.AreEqual (kp_token, an.GetPublicKeyToken (), "#E1");
 814 #endif
 815         }
 816
 817         [Test]
 818         public void GetPublicKeyToken_Corlib ()
 819         {
 820                 an = typeof (int).Assembly.GetName ();
 821                 Assert.IsNotNull (an.GetPublicKeyToken (), "#1");
 822                 Assert.IsTrue (an.GetPublicKeyToken ().Length > 0, "#2");
 823         }
 824
 825         [Test]
 826         public void GetPublicGetToken_Ecma ()
 827         {
 828                 const string assemblyName = "TestAssembly";
 829
 830                 an = new AssemblyName ();
 831                 an.Name = assemblyName;
 832                 an.SetPublicKey (publicKey3);
 833                 Assert.IsNotNull (an.GetPublicKeyToken (), "#1");
 834                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "#2");
 835         }
 836
 837         [Test]
 838         public void GetPublicKeyToken_Self ()
 839         {
 840                 Assembly a = Assembly.GetExecutingAssembly ();
 841                 an = a.GetName ();
 842 #if NET_2_0
 843                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken ());
 844 #else
 845                 Assert.IsNull (an.GetPublicKeyToken ());
 846 #endif
 847         }
 848
 849         static int nameIndex = 0;
 850
 851         private AssemblyName GenAssemblyName ()
 852         {
 853                 AssemblyName assemblyName = new AssemblyName();
 854                 assemblyName.Name = "MonoTests.System.Reflection.AssemblyNameTest" + (nameIndex ++);
 855                 return assemblyName;
 856         }
 857
 858 #if !TARGET_JVM // Reflection.Emit is not supported for TARGET_JVM.
 859         private Assembly GenerateAssembly (AssemblyName name)
 860         {
 861                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 862                         name,
 863                         AssemblyBuilderAccess.RunAndSave,
 864                         tempDir);
 865                 ab.DefineDynamicModule ("def_module");
 866                 ab.Save (name.Name + ".dll");
 867
 868                 return Assembly.LoadFrom (Path.Combine (tempDir, name.Name + ".dll"));
 869         }
 870
 871         private AssemblyBuilder GenerateDynamicAssembly (AssemblyName name)
 872         {
 873                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 874                                 name,
 875                                 AssemblyBuilderAccess.Run);
 876
 877                 return ab;
 878         }
 879
 880         [Test]
 881         public void TestCultureInfo ()
 882         {
 883                 AssemblyName name;
 884                 Assembly a;
 885                 CultureInfo culture;
 886
 887                 name = GenAssemblyName ();
 888                 name.CultureInfo = CultureInfo.CreateSpecificCulture ("ar-DZ");
 889                 a = GenerateAssembly (name);
 890                 culture = a.GetName ().CultureInfo;
 891                 Assert.IsFalse (culture.IsNeutralCulture, "#A1");
 892                 Assert.IsFalse (culture.IsReadOnly, "#A2");
 893                 Assert.AreEqual (5121, culture.LCID, "#A3");
 894                 Assert.AreEqual ("ar-DZ", culture.Name, "#A4");
 895                 Assert.IsTrue (culture.UseUserOverride, "#A5");
 896
 897                 name = GenAssemblyName ();
 898                 name.CultureInfo = new CultureInfo ("en");
 899                 a = GenerateAssembly (name);
 900                 culture = a.GetName ().CultureInfo;
 901                 Assert.IsTrue (culture.IsNeutralCulture, "#B1");
 902                 Assert.IsFalse (culture.IsReadOnly, "#B2");
 903                 Assert.AreEqual (9, culture.LCID, "#B3");
 904                 Assert.AreEqual ("en", culture.Name, "#B4");
 905                 Assert.IsTrue (culture.UseUserOverride, "#B5");
 906
 907                 name = GenAssemblyName ();
 908                 name.CultureInfo = CultureInfo.InvariantCulture;
 909                 a = GenerateAssembly (name);
 910                 culture = a.GetName ().CultureInfo;
 911                 Assert.IsFalse (culture.IsNeutralCulture, "#C1");
 912 #if NET_2_0
 913                 Assert.IsFalse (culture.IsReadOnly, "#C2");
 914 #else
 915                 Assert.IsTrue (culture.IsReadOnly, "#C2");
 916 #endif
 917                 Assert.AreEqual (127, culture.LCID, "#C3");
 918                 Assert.AreEqual (string.Empty, culture.Name, "#C4");
 919                 Assert.IsFalse (culture.UseUserOverride, "#C5");
 920
 921                 a = typeof (int).Assembly;
 922                 name = a.GetName ();
 923                 culture = name.CultureInfo;
 924                 Assert.IsFalse (culture.IsNeutralCulture, "#D1");
 925 #if NET_2_0
 926                 Assert.IsFalse (culture.IsReadOnly, "#D2");
 927 #else
 928                 Assert.IsTrue (culture.IsReadOnly, "#D2");
 929 #endif
 930                 Assert.AreEqual (127, culture.LCID, "#D3");
 931                 Assert.AreEqual (string.Empty, culture.Name, "#D4");
 932                 Assert.IsFalse (culture.UseUserOverride, "#D5");
 933
 934                 a = Assembly.GetExecutingAssembly ();
 935                 name = a.GetName ();
 936                 culture = name.CultureInfo;
 937                 Assert.IsFalse (culture.IsNeutralCulture, "#E1");
 938 #if NET_2_0
 939                 Assert.IsFalse (culture.IsReadOnly, "#E2");
 940 #else
 941                 Assert.IsTrue (culture.IsReadOnly, "#E2");
 942 #endif
 943                 Assert.AreEqual (127, culture.LCID, "#E3");
 944                 Assert.AreEqual (string.Empty, culture.Name, "#E4");
 945                 Assert.IsFalse (culture.UseUserOverride, "#E5");
 946
 947                 AssemblyName [] names = a.GetReferencedAssemblies ();
 948                 foreach (AssemblyName an in names) {
 949                         culture = an.CultureInfo;
 950                         Assert.IsFalse (culture.IsNeutralCulture, "#F1:" + an.Name);
 951                         Assert.IsFalse (culture.IsReadOnly, "#F2:" + an.Name);
 952                         Assert.AreEqual (127, culture.LCID, "#F3:" + an.Name);
 953                         Assert.AreEqual (string.Empty, culture.Name, "#F4:" + an.Name);
 954 #if NET_2_0
 955                         Assert.IsFalse (culture.UseUserOverride, "#F5:" + an.Name);
 956 #else
 957                         Assert.IsTrue (culture.UseUserOverride, "#F5:" + an.Name);
 958 #endif
 959                 }
 960         }
 961
 962         [Test]
 963         public void Version ()
 964         {
 965                 AssemblyName name = GenAssemblyName ();
 966                 name.Version = new Version (1, 2, 3, 4);
 967
 968                 Assembly a = GenerateAssembly (name);
 969                 Assert.AreEqual ("1.2.3.4", a.GetName ().Version.ToString (), "1.2.3.4 normal");
 970
 971                 name = GenAssemblyName ();
 972                 name.Version = new Version (1, 2, 3);
 973
 974                 a = GenerateAssembly (name);
 975                 Assert.AreEqual ("1.2.3.0", a.GetName ().Version.ToString (), "1.2.3.0 normal");
 976
 977                 name = GenAssemblyName ();
 978                 name.Version = new Version (1, 2);
 979
 980                 a = GenerateAssembly (name);
 981                 Assert.AreEqual ("1.2.0.0", a.GetName ().Version.ToString (), "1.2.0.0 normal");
 982         }
 983
 984         [Test]
 985         [Category ("NotWorking")]
 986         public void Version_Dynamic ()
 987         {
 988                 AssemblyName name = GenAssemblyName ();
 989                 name.Version = new Version (1, 2, 3, 4);
 990
 991                 AssemblyBuilder ab = GenerateDynamicAssembly (name);
 992                 Assert.AreEqual ("1.2.3.4", ab.GetName ().Version.ToString (), "1.2.3.4 dynamic");
 993
 994                 name = GenAssemblyName ();
 995                 name.Version = new Version (1, 2, 3);
 996
 997                 ab = GenerateDynamicAssembly (name);
 998 #if NET_2_0
 999                 Assert.AreEqual ("1.2.3.0", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
1000 #else
1001                 Assert.AreEqual ("1.2.3.65535", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
1002 #endif
1003
1004                 name = GenAssemblyName ();
1005                 name.Version = new Version (1, 2);
1006
1007                 ab = GenerateDynamicAssembly (name);
1008 #if NET_2_0
1009                 Assert.AreEqual ("1.2.0.0", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
1010 #else
1011                 Assert.AreEqual ("1.2.65535.65535", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
1012 #endif
1013         }
1014 #endif // TARGET_JVM
1015
1016         [Test]
1017         public void HashAlgorithm ()
1018         {
1019                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1,
1020                         typeof (int).Assembly.GetName ().HashAlgorithm);
1021         }
1022
1023         [Test]
1024         public void Serialization ()
1025         {
1026                 an = new AssemblyName ();
1027                 an.CodeBase = "http://www.test.com/test.dll";
1028                 an.CultureInfo = CultureInfo.InvariantCulture;
1029                 an.Flags = AssemblyNameFlags.PublicKey;
1030                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
1031                 an.KeyPair = new StrongNameKeyPair (publicKey1);
1032                 an.Name = "TestAssembly";
1033                 an.Version = new Version (1, 5);
1034                 an.VersionCompatibility = AssemblyVersionCompatibility.SameProcess;
1035
1036                 MemoryStream ms = new MemoryStream ();
1037                 BinaryFormatter bf = new BinaryFormatter ();
1038                 bf.Serialize (ms, an);
1039
1040                 // reset position of memorystream
1041                 ms.Position = 0;
1042
1043                 // deserialze assembly name
1044                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
1045
1046                 // close the memorystream
1047                 ms.Close ();
1048
1049                 // compare orginal and deserialized assembly name
1050                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
1051                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
1052                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
1053                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
1054                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
1055                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
1056                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
1057                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
1058                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
1059                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
1060                 Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey");
1061                 Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken");
1062         }
1063
1064         [Test]
1065         public void Serialization_WithoutStrongName ()
1066         {
1067                 an = new AssemblyName ();
1068                 an.CodeBase = "http://www.test.com/test.dll";
1069                 an.CultureInfo = CultureInfo.InvariantCulture;
1070                 an.Flags = AssemblyNameFlags.None;
1071                 an.HashAlgorithm = AssemblyHashAlgorithm.SHA1;
1072                 an.KeyPair = null;
1073                 an.Name = "TestAssembly2";
1074                 an.Version = new Version (1, 5, 0, 0);
1075                 an.VersionCompatibility = AssemblyVersionCompatibility.SameMachine;
1076
1077                 MemoryStream ms = new MemoryStream ();
1078                 BinaryFormatter bf = new BinaryFormatter ();
1079                 bf.Serialize (ms, an);
1080
1081                 // reset position of memorystream
1082                 ms.Position = 0;
1083
1084                 // deserialze assembly name
1085                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
1086
1087                 // close the memorystream
1088                 ms.Close ();
1089
1090                 // compare orginal and deserialized assembly name
1091                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
1092                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
1093                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
1094                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
1095                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
1096                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
1097                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
1098                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
1099                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
1100                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
1101                 Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey");
1102                 Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken");
1103         }
1104
1105 #if !TARGET_JVM // Assemblyname.GetObjectData not implemented yet for TARGET_JVM
1106         [Test]
1107         public void GetObjectData_Info_Null ()
1108         {
1109                 an = new AssemblyName ();
1110                 try {
1111                         an.GetObjectData (null, new StreamingContext (StreamingContextStates.All));
1112                         Assert.Fail ("#1");
1113                 } catch (ArgumentNullException ex) {
1114                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1115                         Assert.IsNull (ex.InnerException, "#3");
1116                         Assert.IsNotNull (ex.Message, "#4");
1117                         Assert.IsNotNull (ex.ParamName, "#5");
1118                         Assert.AreEqual ("info", ex.ParamName, "#6");
1119                 }
1120         }
1121 #endif // TARGET_JVM
1122
1123         [Test]
1124         public void Clone_Corlib ()
1125         {
1126                 an = typeof (int).Assembly.GetName ();
1127                 AssemblyName clone = (AssemblyName) an.Clone ();
1128
1129                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
1130                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
1131                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
1132                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
1133                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
1134                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
1135                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
1136                 Assert.AreEqual (an.Name, clone.Name, "Name");
1137 #if NET_2_0
1138                 Assert.AreEqual (an.ProcessorArchitecture, clone.ProcessorArchitecture, "PA");
1139 #endif
1140                 Assert.AreEqual (an.Version, clone.Version, "Version");
1141                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
1142                 Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
1143                 Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
1144                 Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
1145         }
1146
1147         [Test]
1148         public void Clone_Empty ()
1149         {
1150                 an = new AssemblyName ();
1151                 AssemblyName clone = (AssemblyName) an.Clone ();
1152
1153                 Assert.IsNull (clone.CodeBase, "CodeBase");
1154                 Assert.IsNull (clone.CultureInfo, "CultureInfo");
1155                 Assert.IsNull (clone.EscapedCodeBase, "EscapedCodeBase");
1156                 Assert.AreEqual (AssemblyNameFlags.None, clone.Flags, "Flags");
1157 #if NET_2_0
1158                 Assert.AreEqual (String.Empty, clone.FullName, "FullName");
1159 #else
1160                 Assert.IsNull (clone.FullName, "FullName");
1161 #endif
1162                 Assert.AreEqual (AssemblyHashAlgorithm.None, clone.HashAlgorithm, "HashAlgorithm");
1163                 Assert.IsNull (clone.KeyPair, "KeyPair");
1164                 Assert.IsNull (clone.Name, "Name");
1165 #if NET_2_0
1166                 Assert.AreEqual (ProcessorArchitecture.None, clone.ProcessorArchitecture, "PA");
1167 #endif
1168                 Assert.IsNull (clone.Version, "Version");
1169                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1170                         clone.VersionCompatibility, "VersionCompatibility");
1171         }
1172
1173         [Test]
1174         public void Clone_Self ()
1175         {
1176                 an = Assembly.GetExecutingAssembly ().GetName ();
1177                 AssemblyName clone = (AssemblyName) an.Clone ();
1178
1179                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
1180                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
1181                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
1182                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
1183                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
1184                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
1185                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
1186                 Assert.AreEqual (an.Name, clone.Name, "Name");
1187 #if NET_2_0
1188                 //Assert.AreEqual (ProcessorArchitecture.MSIL, clone.ProcessorArchitecture, "PA");
1189 #endif
1190                 Assert.AreEqual (an.Version, clone.Version, "Version");
1191                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
1192                 Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
1193                 Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
1194                 Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
1195         }
1196
1197         [Test]
1198         [ExpectedException (typeof (FileNotFoundException))]
1199         public void GetAssemblyName_AssemblyFile_DoesNotExist ()
1200         {
1201                 AssemblyName.GetAssemblyName (Path.Combine (tempDir, "doesnotexist.dll"));
1202         }
1203
1204         [Test]
1205         [Category ("NotWorking")]
1206         public void GetAssemblyName_AssemblyFile_ReadLock ()
1207         {
1208                 string file = Path.Combine (tempDir, "loadfailure.dll");
1209                 using (FileStream fs = File.Open (file, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None)) {
1210                         try {
1211                                 AssemblyName.GetAssemblyName (file);
1212                                 Assert.Fail ("#1");
1213                         } catch (FileLoadException ex) {
1214                                 // Could not load file or assembly '...' or one
1215                                 // of its dependencies. The process cannot access
1216                                 // the file because it is being used by another
1217                                 // process
1218                                 Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1219                                 Assert.IsNotNull (ex.FileName, "#3");
1220 #if NET_2_0
1221                                 Assert.AreEqual (file, ex.FileName, "#4");
1222 #else
1223                                 Assert.IsTrue (ex.FileName.IndexOf ("loadfailure.dll") != -1, "#4");
1224 #endif
1225                                 Assert.IsNull (ex.InnerException, "#5");
1226                                 Assert.IsNotNull (ex.Message, "#6");
1227                         }
1228                 }
1229                 File.Delete (file);
1230         }
1231
1232         [Test]
1233         public void GetAssemblyName_AssemblyFile_BadImage ()
1234         {
1235                 string file = Path.Combine (tempDir, "badimage.dll");
1236                 using (StreamWriter sw = File.CreateText (file)) {
1237                         sw.WriteLine ("somegarbage");
1238                 }
1239                 try {
1240                         AssemblyName.GetAssemblyName (file);
1241                         Assert.Fail ("#1");
1242                 } catch (BadImageFormatException ex) {
1243                         Assert.AreEqual (typeof (BadImageFormatException), ex.GetType (), "#2");
1244                         Assert.IsNotNull (ex.FileName, "#3");
1245 #if NET_2_0
1246                         Assert.AreEqual (file, ex.FileName, "#4");
1247 #else
1248                         Assert.IsTrue (ex.FileName.IndexOf ("badimage.dll") != -1, "#4");
1249 #endif
1250                         Assert.IsNull (ex.InnerException, "#5");
1251                         Assert.IsNotNull (ex.Message, "#6");
1252                 } finally {
1253                         File.Delete (file);
1254                 }
1255         }
1256
1257         [Test]
1258         public void GetAssemblyName_CodeBase ()
1259         {
1260                 Assembly execAssembly = Assembly.GetExecutingAssembly ();
1261
1262                 AssemblyName aname = AssemblyName.GetAssemblyName (execAssembly.Location);
1263                 Assert.IsNotNull (aname.CodeBase, "#1");
1264                 Assert.AreEqual (execAssembly.CodeBase, aname.CodeBase, "#2");
1265         }
1266
1267         // helpers
1268
1269         private string GetTokenString (byte[] value)
1270         {
1271                 string tokenString = "";
1272                 for (int i = 0; i < value.Length; i++) {
1273                         tokenString += value[i].ToString ("x2");
1274                 }
1275                 return tokenString;
1276         }
1277
1278 #if NET_2_0
1279         [Test] // ctor (String)
1280         public void Constructor1_Name ()
1281         {
1282                 const string assemblyName = "TestAssembly";
1283
1284                 an = new AssemblyName (assemblyName);
1285                 Assert.IsNull (an.CodeBase, "CodeBase");
1286                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1287                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1288                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1289                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1290                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1291                 Assert.IsNull (an.KeyPair, "KeyPair");
1292                 Assert.AreEqual (assemblyName, an.Name, "Name");
1293                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1294                 Assert.IsNull (an.Version, "Version");
1295                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1296                         an.VersionCompatibility, "VersionCompatibility");
1297                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1298                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1299                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1300         }
1301
1302         [Test] // ctor (String)
1303         [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM.
1304         public void Constructor1_Full ()
1305         {
1306                 const string assemblyName = "TestAssembly";
1307                 const string assemblyCulture = "neutral";
1308                 const string assemblyVersion = "1.2.3.4";
1309
1310                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion +
1311                                 ", Culture=" + assemblyCulture + ", PublicKeyToken=" + GetTokenString (pk_token1));
1312                 Assert.IsNull (an.CodeBase, "CodeBase");
1313                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo");
1314                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1315                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1316                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4, Culture=neutral, PublicKeyToken=" +
1317                         GetTokenString (pk_token1), an.FullName, "FullName");
1318                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1319                 Assert.IsNull (an.KeyPair, "KeyPair");
1320                 Assert.AreEqual (assemblyName, an.Name, "Name");
1321                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1322                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1323                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1324                         an.VersionCompatibility, "VersionCompatibility");
1325                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1326                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1327                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4, Culture=neutral, PublicKeyToken=" +
1328                         GetTokenString (pk_token1), an.ToString (), "ToString");
1329         }
1330
1331         [Test] // ctor (String)
1332         public void Constructor1_AssemblyName_Empty ()
1333         {
1334                 try {
1335                         new AssemblyName (string.Empty);
1336                         Assert.Fail ("#1");
1337                 } catch (ArgumentException ex) {
1338                         // String cannot have zero length
1339                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1340                         Assert.IsNull (ex.InnerException, "#3");
1341                         Assert.IsNotNull (ex.Message, "#4");
1342                         Assert.IsNull (ex.ParamName, "#5");
1343                 }
1344         }
1345
1346         [Test] // ctor (String)
1347         public void Constructor1_AssemblyName_Invalid ()
1348         {
1349                 const string assemblyName = "TestAssembly";
1350
1351                 try {
1352                         new AssemblyName (assemblyName + ", =1.2.4.5");
1353                         Assert.Fail ("#A1");
1354                 } catch (FileLoadException ex) {
1355                         // The given assembly name or codebase was invalid
1356                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1357                         Assert.IsNull (ex.FileName, "#3");
1358                         Assert.IsNull (ex.InnerException, "#3");
1359                         Assert.IsNotNull (ex.Message, "#4");
1360                 }
1361
1362                 try {
1363                         new AssemblyName (assemblyName + ", OtherAttribute");
1364                         Assert.Fail ("#B1");
1365                 } catch (FileLoadException ex) {
1366                         // The given assembly name or codebase was invalid
1367                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1368                         Assert.IsNull (ex.FileName, "#3");
1369                         Assert.IsNull (ex.InnerException, "#3");
1370                         Assert.IsNotNull (ex.Message, "#4");
1371                 }
1372         }
1373
1374         [Test] // ctor (String)
1375         public void Constructor1_AssemblyName_Null ()
1376         {
1377                 try {
1378                         new AssemblyName (null);
1379                         Assert.Fail ("#1");
1380                 } catch (ArgumentNullException ex) {
1381                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1382                         Assert.IsNull (ex.InnerException, "#3");
1383                         Assert.IsNotNull (ex.Message, "#4");
1384                         Assert.IsNotNull (ex.ParamName, "#5");
1385                         Assert.AreEqual ("assemblyName", ex.ParamName, "#6");
1386                 }
1387         }
1388
1389         [Test] // ctor (String)
1390         public void Constructor1_Culture ()
1391         {
1392                 const string assemblyName = "TestAssembly";
1393                 const string assemblyCulture = "en-US";
1394
1395                 an = new AssemblyName (assemblyName + ", Culture=" + assemblyCulture);
1396                 Assert.IsNull (an.CodeBase, "CodeBase");
1397                 Assert.AreEqual (new CultureInfo (assemblyCulture), an.CultureInfo, "CultureInfo");
1398                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1399                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1400                 Assert.AreEqual ("TestAssembly, Culture=en-US", an.FullName, "FullName");
1401                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1402                 Assert.IsNull (an.KeyPair, "KeyPair");
1403                 Assert.AreEqual (assemblyName, an.Name, "Name");
1404                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1405                 Assert.IsNull (an.Version, "Version");
1406                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1407                         an.VersionCompatibility, "VersionCompatibility");
1408                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1409                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1410                 Assert.AreEqual ("TestAssembly, Culture=en-US", an.ToString (), "ToString");
1411         }
1412
1413         [Test] // ctor (String)
1414         public void Constructor1_Culture_Incomplete ()
1415         {
1416                 const string assemblyName = "TestAssembly";
1417
1418                 try {
1419                         new AssemblyName (assemblyName + ", Culture=");
1420                         Assert.Fail ("#1");
1421                 } catch (FileLoadException ex) {
1422                         // The given assembly name or codebase was invalid
1423                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1424                         Assert.IsNull (ex.FileName, "#3");
1425                         Assert.IsNull (ex.InnerException, "#3");
1426                         Assert.IsNotNull (ex.Message, "#4");
1427                 }
1428         }
1429
1430         [Test] // ctor (String)
1431         public void Constructor1_Culture_NotSupported ()
1432         {
1433                 const string assemblyName = "TestAssembly";
1434
1435                 try {
1436                         new AssemblyName (assemblyName + ", Culture=aa-AA");
1437                         Assert.Fail ("#1");
1438                 } catch (ArgumentException ex) {
1439                         // Culture name 'aa-aa' is not supported
1440                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1441                         Assert.IsNull (ex.InnerException, "#3");
1442                         Assert.IsNotNull (ex.Message, "#4");
1443                         Assert.IsNotNull (ex.ParamName, "#5");
1444                         Assert.AreEqual ("name", ex.ParamName, "#6");
1445                 }
1446         }
1447
1448         [Test] // ctor (String)
1449         [Category ("NotWorking")] // bug #351708
1450         public void Constructor1_ProcessorArchitecture ()
1451         {
1452                 const string assemblyName = "TestAssembly";
1453
1454                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=X86");
1455                 Assert.IsNull (an.CodeBase, "CodeBase");
1456                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1457                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1458                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1459                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1460                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1461                 Assert.IsNull (an.KeyPair, "KeyPair");
1462                 Assert.AreEqual (assemblyName, an.Name, "Name");
1463                 Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA");
1464                 Assert.IsNull (an.Version, "Version");
1465                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1466                         an.VersionCompatibility, "VersionCompatibility");
1467                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1468                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1469                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1470         }
1471
1472         [Test] // ctor (String)
1473         [Category ("NotWorking")] // bug #351708
1474         public void Constructor1_ProcessorArchitecture_Incomplete ()
1475         {
1476                 const string assemblyName = "TestAssembly";
1477                 try {
1478                         new AssemblyName (assemblyName + ", ProcessorArchitecture=");
1479                         Assert.Fail ("#1");
1480                 } catch (FileLoadException ex) {
1481                         // The given assembly name or codebase was invalid
1482                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1483                         Assert.IsNull (ex.FileName, "#3");
1484                         Assert.IsNull (ex.InnerException, "#3");
1485                         Assert.IsNotNull (ex.Message, "#4");
1486                 }
1487         }
1488
1489         [Test] // ctor (String)
1490         [Category ("NotWorking")] // bug #351708
1491         public void Constructor1_ProcessorArchitecture_Invalid ()
1492         {
1493                 const string assemblyName = "TestAssembly";
1494                 try {
1495                         new AssemblyName (assemblyName + ", ProcessorArchitecture=XXX");
1496                         Assert.Fail ("#1");
1497                 } catch (FileLoadException ex) {
1498                         // The given assembly name or codebase was invalid
1499                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1500                         Assert.IsNull (ex.FileName, "#3");
1501                         Assert.IsNull (ex.InnerException, "#3");
1502                         Assert.IsNotNull (ex.Message, "#4");
1503                 }
1504         }
1505
1506         [Test] // ctor (String)
1507         [Category ("NotDotNet")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1508         public void Constructor1_PublicKey_Mono ()
1509         {
1510                 const string assemblyName = "TestAssembly";
1511
1512                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1513                 Assert.IsNull (an.CodeBase, "CodeBase");
1514                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1515                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1516                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags");
1517                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1518                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1519                 Assert.IsNull (an.KeyPair, "KeyPair");
1520                 Assert.AreEqual (assemblyName, an.Name, "Name");
1521                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1522                 Assert.IsNull (an.Version, "Version");
1523                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1524                         an.VersionCompatibility, "VersionCompatibility");
1525                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "GetPublicKey");
1526                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1527                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.ToString (), "ToString");
1528         }
1529
1530         [Test]
1531         [Category ("NotWorking")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1532         public void Constructor1_PublicKey_MS ()
1533         {
1534                 const string assemblyName = "TestAssembly";
1535
1536                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1537                 Assert.IsNull (an.CodeBase, "CodeBase");
1538                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1539                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1540                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1541                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1542                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1543                 Assert.IsNull (an.KeyPair, "KeyPair");
1544                 Assert.AreEqual (assemblyName, an.Name, "Name");
1545                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1546                 Assert.IsNull (an.Version, "Version");
1547                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1548                         an.VersionCompatibility, "VersionCompatibility");
1549                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1550                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1551                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.ToString (), "ToString");
1552         }
1553
1554         [Test] // ctor (String)
1555         [Category ("NotWorking")] // bug #351725
1556         public void Constructor1_PublicKey_Ecma ()
1557         {
1558                 const string assemblyName = "TestAssembly";
1559
1560                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey3));
1561                 Assert.IsNull (an.CodeBase, "CodeBase");
1562                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1563                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1564                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1565                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "FullName");
1566                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1567                 Assert.IsNull (an.KeyPair, "KeyPair");
1568                 Assert.AreEqual (assemblyName, an.Name, "Name");
1569                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1570                 Assert.IsNull (an.Version, "Version");
1571                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1572                         an.VersionCompatibility, "VersionCompatibility");
1573                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1574                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "GetPublicKeyToken");
1575                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token3), an.ToString (), "ToString");
1576         }
1577
1578         [Test] // ctor (String)
1579         public void Constructor1_PublicKey_Incomplete ()
1580         {
1581                 const string assemblyName = "TestAssembly";
1582
1583                 try {
1584                         new AssemblyName (assemblyName + ", PublicKey=");
1585                         Assert.Fail ("#1");
1586                 } catch (FileLoadException ex) {
1587                         // The given assembly name or codebase was invalid
1588                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1589                         Assert.IsNull (ex.FileName, "#3");
1590                         Assert.IsNull (ex.InnerException, "#3");
1591                         Assert.IsNotNull (ex.Message, "#4");
1592                 }
1593         }
1594
1595         [Test] // ctor (String)
1596         public void Constructor1_PublicKey_Invalid ()
1597         {
1598                 const string assemblyName = "TestAssembly";
1599
1600                 try {
1601                         new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e");
1602                         Assert.Fail ("#1");
1603                 } catch (FileLoadException ex) {
1604                         // The given assembly name or codebase was invalid
1605                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1606                         Assert.IsNull (ex.FileName, "#3");
1607                         Assert.IsNull (ex.InnerException, "#3");
1608                         Assert.IsNotNull (ex.Message, "#4");
1609                 }
1610         }
1611
1612         [Test] // ctor (String)
1613         [Category ("NotWorking")] // bug #351756
1614         public void Constructor1_PublicKey_KeyPair ()
1615         {
1616                 const string assemblyName = "TestAssembly";
1617
1618                 try {
1619                         new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (keyPair));
1620                         Assert.Fail ("#1");
1621                 } catch (SecurityException ex) {
1622                         // Invalid assembly public key
1623                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#2");
1624                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#3");
1625                         Assert.IsNull (ex.InnerException, "#4");
1626                         Assert.IsNotNull (ex.Message, "#5");
1627                 }
1628         }
1629
1630         [Test] // ctor (String)
1631         public void Constructor1_PublicKeyToken ()
1632         {
1633                 const string assemblyName = "TestAssembly";
1634
1635                 an = new AssemblyName (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1));
1636                 Assert.IsNull (an.CodeBase, "CodeBase");
1637                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1638                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1639                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1640                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1641                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1642                 Assert.IsNull (an.KeyPair, "KeyPair");
1643                 Assert.AreEqual (assemblyName, an.Name, "Name");
1644                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1645                 Assert.IsNull (an.Version, "Version");
1646                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1647                         an.VersionCompatibility, "VersionCompatibility");
1648                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1649                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1650                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.ToString (), "ToString");
1651         }
1652
1653         [Test] // ctor (String)
1654         public void Constructor1_PublicKeyToken_Incomplete ()
1655         {
1656                 const string assemblyName = "TestAssembly";
1657
1658                 try {
1659                         new AssemblyName (assemblyName + ", PublicKeyToken=");
1660                         Assert.Fail ("#1");
1661                 } catch (FileLoadException ex) {
1662                         // The given assembly name or codebase was invalid
1663                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1664                         Assert.IsNull (ex.FileName, "#3");
1665                         Assert.IsNull (ex.InnerException, "#3");
1666                         Assert.IsNotNull (ex.Message, "#4");
1667                 }
1668         }
1669
1670         [Test] // ctor (String)
1671         public void Constructor1_PublicKeyToken_Invalid ()
1672         {
1673                 const string assemblyName = "TestAssembly";
1674
1675                 try {
1676                         new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188");
1677                         Assert.Fail ("#1");
1678                 } catch (FileLoadException ex) {
1679                         // The given assembly name or codebase was invalid
1680                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1681                         Assert.IsNull (ex.FileName, "#3");
1682                         Assert.IsNull (ex.InnerException, "#3");
1683                         Assert.IsNotNull (ex.Message, "#4");
1684                 }
1685         }
1686
1687         [Test] // ctor (String)
1688         [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM.
1689         public void Constructor1_Version ()
1690         {
1691                 const string assemblyName = "TestAssembly";
1692                 const string assemblyVersion = "1.2.3.4";
1693
1694                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion);
1695                 Assert.IsNull (an.CodeBase, "CodeBase");
1696                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1697                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1698                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1699                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4", an.FullName, "FullName");
1700                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1701                 Assert.IsNull (an.KeyPair, "KeyPair");
1702                 Assert.AreEqual (assemblyName, an.Name, "Name");
1703                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1704                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1705                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1706                         an.VersionCompatibility, "VersionCompatibility");
1707                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1708                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1709                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4", an.ToString (), "ToString");
1710         }
1711
1712
1713         [Test] // ctor (String)
1714         public void Constructor1_Version_Incomplete ()
1715         {
1716                 const string assemblyName = "TestAssembly";
1717
1718                 try {
1719                         new AssemblyName (assemblyName + ", Version=, Culture=neutral");
1720                         Assert.Fail ("#1");
1721                 } catch (FileLoadException ex) {
1722                         // The given assembly name or codebase was invalid
1723                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1724                         Assert.IsNull (ex.FileName, "#3");
1725                         Assert.IsNull (ex.InnerException, "#3");
1726                         Assert.IsNotNull (ex.Message, "#4");
1727                 }
1728         }
1729
1730         [Test] // ctor (String)
1731         public void Constructor1_Version_Invalid ()
1732         {
1733                 const string assemblyName = "TestAssembly";
1734
1735                 try {
1736                         new AssemblyName (assemblyName + ", Version=a.b");
1737                         Assert.Fail ("#1");
1738                 } catch (FileLoadException ex) {
1739                         // The given assembly name or codebase was invalid
1740                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1741                         Assert.IsNull (ex.FileName, "#3");
1742                         Assert.IsNull (ex.InnerException, "#3");
1743                         Assert.IsNotNull (ex.Message, "#4");
1744                 }
1745         }
1746 #endif
1747 }
1748
1749 }