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_Flags ()
 445         {
 446                 const string assemblyName = "TestAssembly";
 447
 448                 // tests for AssemblyName with only name
 449                 an = new AssemblyName ();
 450 #if NET_2_0
 451                 an.Flags = AssemblyNameFlags.EnableJITcompileOptimizer |
 452                         AssemblyNameFlags.EnableJITcompileTracking |
 453                         AssemblyNameFlags.PublicKey |
 454                         AssemblyNameFlags.Retargetable;
 455 #else
 456                 an.Flags = AssemblyNameFlags.PublicKey |
 457                         AssemblyNameFlags.Retargetable;
 458 #endif
 459                 an.Name = assemblyName;
 460                 Assert.AreEqual (assemblyName + ", Retargetable=Yes", an.FullName, "#1");
 461                 an.Flags = AssemblyNameFlags.None;
 462                 Assert.AreEqual (assemblyName, an.FullName, "#2");
 463         }
 464
 465         [Test]
 466         public void FullName_Name ()
 467         {
 468                 const string assemblyName = "TestAssembly";
 469
 470                 // tests for AssemblyName with only name
 471                 an = new AssemblyName ();
 472                 an.Name = assemblyName;
 473                 Assert.IsNotNull (an.FullName, "FullName2#1");
 474                 Assert.AreEqual (an.Name, an.FullName, "FullName2#2");
 475                 Assert.AreEqual (-1, an.FullName.IndexOf ("Culture="), "FullName2#3");
 476                 Assert.AreEqual (-1, an.FullName.IndexOf ("PublicKeyToken="), "FullName2#4");
 477         }
 478
 479         [Test]
 480         public void FullName_Version ()
 481         {
 482                 const string assemblyName = "TestAssembly";
 483                 const string assemblyVersion = "1.2";
 484
 485                 // tests for AssemblyName with name and version
 486                 an = new AssemblyName ();
 487                 an.Name = assemblyName;
 488                 an.Version = new Version (assemblyVersion);
 489                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion, an.FullName, "FullName3#1");
 490         }
 491
 492         [Test]
 493         public void FullName_Culture ()
 494         {
 495                 const string assemblyName = "TestAssembly";
 496
 497                 // tests for AssemblyName with name and neutral culture
 498                 an = new AssemblyName ();
 499                 an.Name = assemblyName;
 500                 an.CultureInfo = CultureInfo.InvariantCulture;
 501                 Assert.AreEqual (assemblyName + ", Culture=neutral", an.FullName, "#1");
 502                 an.CultureInfo = new CultureInfo ("nl-BE");
 503                 Assert.AreEqual (assemblyName + ", Culture=nl-BE", an.FullName, "#2");
 504                 an.Name = null;
 505 #if NET_2_0
 506                 Assert.AreEqual (string.Empty, an.FullName, "#3");
 507 #else
 508                 Assert.IsNull (an.FullName, "#4");
 509 #endif
 510         }
 511
 512         [Test]
 513         public void FullName_PublicKey ()
 514         {
 515                 const string assemblyName = "TestAssembly";
 516
 517                 // tests for AssemblyName with name and public key
 518                 an = new AssemblyName ();
 519                 an.Name = assemblyName;
 520                 an.SetPublicKey (publicKey1);
 521                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1");
 522                 an.SetPublicKey ((byte []) null);
 523                 Assert.AreEqual (assemblyName, an.FullName, "#A2");
 524                 an.SetPublicKey (new byte [0]);
 525                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3");
 526                 an.Name = null;
 527 #if NET_2_0
 528                 Assert.AreEqual (string.Empty, an.FullName, "#A4");
 529 #else
 530                 Assert.IsNull (an.FullName, "#A4");
 531 #endif
 532
 533                 an = new AssemblyName ();
 534                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 535                 an.Name = assemblyName;
 536                 an.SetPublicKey (publicKey1);
 537                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1");
 538                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 539 #if NET_2_0
 540                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2");
 541 #else
 542                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B2");
 543 #endif
 544                 an.SetPublicKeyToken ((byte []) null);
 545                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B3");
 546                 an.Name = null;
 547 #if NET_2_0
 548                 Assert.AreEqual (string.Empty, an.FullName, "#B4");
 549 #else
 550                 Assert.IsNull (an.FullName, "#B4");
 551 #endif
 552
 553                 an = new AssemblyName ();
 554                 an.HashAlgorithm = AssemblyHashAlgorithm.None;
 555                 an.Name = assemblyName;
 556                 an.SetPublicKey (publicKey1);
 557                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1");
 558                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 559 #if NET_2_0
 560                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#C2");
 561 #else
 562                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C2");
 563 #endif
 564                 an.SetPublicKeyToken ((byte []) null);
 565                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C3");
 566                 an.Name = null;
 567 #if NET_2_0
 568                 Assert.AreEqual (string.Empty, an.FullName, "#C4");
 569 #else
 570                 Assert.IsNull (an.FullName, "#C4");
 571 #endif
 572
 573                 an = new AssemblyName ();
 574                 an.Name = assemblyName;
 575                 an.SetPublicKey (new byte [0]);
 576                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1");
 577                 an.Name = null;
 578 #if NET_2_0
 579                 Assert.AreEqual (string.Empty, an.FullName, "#D2");
 580 #else
 581                 Assert.IsNull (an.FullName, "#D2");
 582 #endif
 583                 an.SetPublicKey (publicKey3);
 584 #if NET_2_0
 585                 Assert.AreEqual (string.Empty, an.FullName, "#D3");
 586 #else
 587                 Assert.IsNull (an.FullName, "#D3");
 588 #endif
 589                 an.Name = assemblyName;
 590                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "#D4");
 591         }
 592
 593         [Test]
 594         public void FullName_PublicKey_KeyPair ()
 595         {
 596                 const string assemblyName = "TestAssembly";
 597
 598                 // tests for AssemblyName with name and public key
 599                 an = new AssemblyName ();
 600                 an.Name = assemblyName;
 601                 an.SetPublicKey (keyPair);
 602 #if NET_2_0
 603                 try {
 604                         Assert.Fail ("#A1: " + an.FullName);
 605                 } catch (SecurityException ex) {
 606                         // Invalid assembly public key
 607                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#A2");
 608                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#A3");
 609                         Assert.IsNull (ex.InnerException, "#A4");
 610                         Assert.IsNotNull (ex.Message, "#A5");
 611                 }
 612 #else
 613                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#A1");
 614 #endif
 615
 616                 an.SetPublicKeyToken (new byte [0]);
 617 #if NET_2_0
 618                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#B1");
 619 #else
 620                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#B1");
 621 #endif
 622
 623                 an.SetPublicKeyToken ((byte []) null);
 624 #if NET_2_0
 625                 try {
 626                         Assert.Fail ("#C1: " + an.FullName);
 627                 } catch (SecurityException ex) {
 628                         // Invalid assembly public key
 629                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#C2");
 630                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#C3");
 631                         Assert.IsNull (ex.InnerException, "#C4");
 632                         Assert.IsNotNull (ex.Message, "#C5");
 633                 }
 634 #else
 635                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#C1");
 636 #endif
 637
 638                 an.SetPublicKeyToken (new byte [0]);
 639 #if NET_2_0
 640                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1");
 641 #else
 642                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#D1");
 643 #endif
 644                 an.SetPublicKey (publicKey1);
 645 #if NET_2_0
 646                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2");
 647 #else
 648                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D2");
 649 #endif
 650                 an.SetPublicKeyToken ((byte []) null);
 651                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3");
 652         }
 653
 654         [Test]
 655         public void FullName_PublicKeyToken ()
 656         {
 657                 const string assemblyName = "TestAssembly";
 658
 659                 an = new AssemblyName ();
 660                 an.Name = assemblyName;
 661                 an.SetPublicKeyToken (pk_token1);
 662                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1");
 663                 an.SetPublicKeyToken ((byte []) null);
 664                 Assert.AreEqual (assemblyName, an.FullName, "#A2");
 665                 an.SetPublicKeyToken (new byte [0]);
 666                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3");
 667                 an.SetPublicKeyToken (pk_token1);
 668                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A4");
 669                 an.Name = null;
 670 #if NET_2_0
 671                 Assert.AreEqual (string.Empty, an.FullName, "#A5");
 672 #else
 673                 Assert.IsNull (an.FullName, "#A5");
 674 #endif
 675
 676                 an = new AssemblyName ();
 677                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 678                 an.Name = assemblyName;
 679                 an.SetPublicKeyToken (pk_token1);
 680                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1");
 681                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 682                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2");
 683                 an.SetPublicKeyToken ((byte []) null);
 684                 Assert.AreEqual (assemblyName, an.FullName, "#B3");
 685                 an.Name = null;
 686 #if NET_2_0
 687                 Assert.AreEqual (string.Empty, an.FullName, "#B4");
 688 #else
 689                 Assert.IsNull (an.FullName, "#B4");
 690 #endif
 691
 692                 an = new AssemblyName ();
 693                 an.Name = assemblyName;
 694                 an.SetPublicKey (publicKey1);
 695                 an.SetPublicKeyToken (pk_token1);
 696                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1");
 697                 an.SetPublicKey ((byte []) null);
 698 #if NET_2_0
 699                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C2");
 700 #else
 701                 Assert.AreEqual (assemblyName, an.FullName, "#C2");
 702 #endif
 703                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C3");
 704                 an.SetPublicKey (new byte [0]);
 705 #if NET_2_0
 706                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C4");
 707 #else
 708                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#C4");
 709 #endif
 710                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C5");
 711
 712                 an = new AssemblyName ();
 713                 an.Name = assemblyName;
 714                 an.SetPublicKey (publicKey1);
 715                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D1");
 716                 an.SetPublicKey (new byte [0]);
 717                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2");
 718                 an.SetPublicKeyToken (pk_token1);
 719 #if NET_2_0
 720                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3");
 721 #else
 722                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D3");
 723 #endif
 724                 an.SetPublicKey ((byte []) null);
 725 #if NET_2_0
 726                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D4");
 727 #else
 728                 Assert.AreEqual (assemblyName, an.FullName, "#D4");
 729 #endif
 730         }
 731
 732         [Test]
 733         public void FullName_VersionCulture ()
 734         {
 735                 const string assemblyName = "TestAssembly";
 736                 const string assemblyVersion = "1.2";
 737
 738                 // tests for AssemblyName with name, version and neutral culture
 739                 an = new AssemblyName ();
 740                 an.Name = assemblyName;
 741                 an.Version = new Version (assemblyVersion);
 742                 an.CultureInfo = CultureInfo.InvariantCulture;
 743                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 744                         + ", Culture=neutral", an.FullName, "#1");
 745                 an.CultureInfo = new CultureInfo ("en-US");
 746                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 747                         + ", Culture=en-US", an.FullName, "#2");
 748                 an.CultureInfo = new CultureInfo ("en");
 749                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 750                         + ", Culture=en", an.FullName, "#3");
 751         }
 752
 753         [Test]
 754         public void FullName_VersionPublicKey ()
 755         {
 756                 const string assemblyName = "TestAssembly";
 757                 const string assemblyVersion = "1.2";
 758
 759                 // tests for AssemblyName with name, version and public key
 760                 an = new AssemblyName ();
 761                 an.Name = assemblyName;
 762                 an.Version = new Version (assemblyVersion);
 763                 an.SetPublicKey (publicKey1);
 764                 an.SetPublicKeyToken (pk_token1);
 765                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 766                         + ", PublicKeyToken=" + GetTokenString (pk_token1),
 767                         an.FullName, "#1");
 768         }
 769
 770         [Test]
 771         public void FullName_CulturePublicKey ()
 772         {
 773                 const string assemblyName = "TestAssembly";
 774
 775                 // tests for AssemblyName with name, culture and public key
 776                 an = new AssemblyName ();
 777                 an.Name = assemblyName;
 778                 an.CultureInfo = CultureInfo.InvariantCulture;
 779                 an.SetPublicKey (publicKey1);
 780                 an.SetPublicKeyToken (pk_token1);
 781                 Assert.AreEqual (assemblyName + ", Culture=neutral"
 782                         + ", PublicKeyToken=" + GetTokenString (pk_token1),
 783                         an.FullName, "#1");
 784         }
 785
 786         [Test]
 787         public void GetPublicKeyToken ()
 788         {
 789                 const string assemblyName = "TestAssembly";
 790
 791                 an = new AssemblyName ();
 792                 an.SetPublicKey (publicKey1);
 793                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A1");
 794                 an.SetPublicKey (publicKey2);
 795                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A2");
 796                 an.SetPublicKeyToken (new byte [] { 0x0a });
 797                 Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A3");
 798                 an.SetPublicKey (publicKey1);
 799                 Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A4");
 800                 an.SetPublicKeyToken (new byte [0]);
 801                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A5");
 802                 an.Name = assemblyName;
 803                 an.SetPublicKey (publicKey2);
 804                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A6");
 805 #if NET_2_0
 806                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A7");
 807 #else
 808                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token2), an.FullName, "#A7");
 809 #endif
 810
 811                 an = new AssemblyName ();
 812                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 813                 an.SetPublicKey (publicKey1);
 814                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B1");
 815
 816                 an = new AssemblyName ();
 817                 an.HashAlgorithm = AssemblyHashAlgorithm.None;
 818                 an.SetPublicKey (publicKey1);
 819                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C1");
 820
 821                 an = new AssemblyName ();
 822                 an.SetPublicKeyToken (new byte [0]);
 823                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#D1");
 824                 an.SetPublicKeyToken (new byte [] { 0x0b, 0xff });
 825                 Assert.AreEqual (new byte [] { 0x0b, 0xff }, an.GetPublicKeyToken (), "#D2");
 826                 an.SetPublicKeyToken ((byte []) null);
 827                 Assert.IsNull (an.GetPublicKeyToken (), "#D3");
 828
 829                 an = new AssemblyName ();
 830                 an.SetPublicKey (keyPair);
 831 #if NET_2_0
 832                 try {
 833                         an.GetPublicKeyToken ();
 834                         Assert.Fail ("#E1");
 835                 } catch (SecurityException ex) {
 836                         // Invalid assembly public key
 837                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#E2");
 838                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#E3");
 839                         Assert.IsNull (ex.InnerException, "#E4");
 840                         Assert.IsNotNull (ex.Message, "#E5");
 841                 }
 842 #else
 843                 Assert.AreEqual (kp_token, an.GetPublicKeyToken (), "#E1");
 844 #endif
 845         }
 846
 847         [Test]
 848         public void GetPublicKeyToken_Corlib ()
 849         {
 850                 an = typeof (int).Assembly.GetName ();
 851                 Assert.IsNotNull (an.GetPublicKeyToken (), "#1");
 852                 Assert.IsTrue (an.GetPublicKeyToken ().Length > 0, "#2");
 853         }
 854
 855         [Test]
 856         public void GetPublicGetToken_Ecma ()
 857         {
 858                 const string assemblyName = "TestAssembly";
 859
 860                 an = new AssemblyName ();
 861                 an.Name = assemblyName;
 862                 an.SetPublicKey (publicKey3);
 863                 Assert.IsNotNull (an.GetPublicKeyToken (), "#1");
 864                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "#2");
 865         }
 866
 867         [Test]
 868         public void GetPublicKeyToken_Self ()
 869         {
 870                 Assembly a = Assembly.GetExecutingAssembly ();
 871                 an = a.GetName ();
 872 #if NET_2_0
 873                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken ());
 874 #else
 875                 Assert.IsNull (an.GetPublicKeyToken ());
 876 #endif
 877         }
 878
 879         static int nameIndex = 0;
 880
 881         private AssemblyName GenAssemblyName ()
 882         {
 883                 AssemblyName assemblyName = new AssemblyName();
 884                 assemblyName.Name = "MonoTests.System.Reflection.AssemblyNameTest" + (nameIndex ++);
 885                 return assemblyName;
 886         }
 887
 888 #if !TARGET_JVM // Reflection.Emit is not supported for TARGET_JVM.
 889         private Assembly GenerateAssembly (AssemblyName name)
 890         {
 891                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 892                         name,
 893                         AssemblyBuilderAccess.RunAndSave,
 894                         tempDir);
 895                 ab.DefineDynamicModule ("def_module");
 896                 ab.Save (name.Name + ".dll");
 897
 898                 return Assembly.LoadFrom (Path.Combine (tempDir, name.Name + ".dll"));
 899         }
 900
 901         private AssemblyBuilder GenerateDynamicAssembly (AssemblyName name)
 902         {
 903                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 904                                 name,
 905                                 AssemblyBuilderAccess.Run);
 906
 907                 return ab;
 908         }
 909
 910         [Test]
 911         public void TestCultureInfo ()
 912         {
 913                 AssemblyName name;
 914                 Assembly a;
 915                 CultureInfo culture;
 916
 917                 name = GenAssemblyName ();
 918                 name.CultureInfo = CultureInfo.CreateSpecificCulture ("ar-DZ");
 919                 a = GenerateAssembly (name);
 920                 culture = a.GetName ().CultureInfo;
 921                 Assert.IsFalse (culture.IsNeutralCulture, "#A1");
 922                 Assert.IsFalse (culture.IsReadOnly, "#A2");
 923                 Assert.AreEqual (5121, culture.LCID, "#A3");
 924                 Assert.AreEqual ("ar-DZ", culture.Name, "#A4");
 925                 Assert.IsTrue (culture.UseUserOverride, "#A5");
 926
 927                 name = GenAssemblyName ();
 928                 name.CultureInfo = new CultureInfo ("en");
 929                 a = GenerateAssembly (name);
 930                 culture = a.GetName ().CultureInfo;
 931                 Assert.IsTrue (culture.IsNeutralCulture, "#B1");
 932                 Assert.IsFalse (culture.IsReadOnly, "#B2");
 933                 Assert.AreEqual (9, culture.LCID, "#B3");
 934                 Assert.AreEqual ("en", culture.Name, "#B4");
 935                 Assert.IsTrue (culture.UseUserOverride, "#B5");
 936
 937                 name = GenAssemblyName ();
 938                 name.CultureInfo = CultureInfo.InvariantCulture;
 939                 a = GenerateAssembly (name);
 940                 culture = a.GetName ().CultureInfo;
 941                 Assert.IsFalse (culture.IsNeutralCulture, "#C1");
 942 #if NET_2_0
 943                 Assert.IsFalse (culture.IsReadOnly, "#C2");
 944 #else
 945                 Assert.IsTrue (culture.IsReadOnly, "#C2");
 946 #endif
 947                 Assert.AreEqual (127, culture.LCID, "#C3");
 948                 Assert.AreEqual (string.Empty, culture.Name, "#C4");
 949                 Assert.IsFalse (culture.UseUserOverride, "#C5");
 950
 951                 a = typeof (int).Assembly;
 952                 name = a.GetName ();
 953                 culture = name.CultureInfo;
 954                 Assert.IsFalse (culture.IsNeutralCulture, "#D1");
 955 #if NET_2_0
 956                 Assert.IsFalse (culture.IsReadOnly, "#D2");
 957 #else
 958                 Assert.IsTrue (culture.IsReadOnly, "#D2");
 959 #endif
 960                 Assert.AreEqual (127, culture.LCID, "#D3");
 961                 Assert.AreEqual (string.Empty, culture.Name, "#D4");
 962                 Assert.IsFalse (culture.UseUserOverride, "#D5");
 963
 964                 a = Assembly.GetExecutingAssembly ();
 965                 name = a.GetName ();
 966                 culture = name.CultureInfo;
 967                 Assert.IsFalse (culture.IsNeutralCulture, "#E1");
 968 #if NET_2_0
 969                 Assert.IsFalse (culture.IsReadOnly, "#E2");
 970 #else
 971                 Assert.IsTrue (culture.IsReadOnly, "#E2");
 972 #endif
 973                 Assert.AreEqual (127, culture.LCID, "#E3");
 974                 Assert.AreEqual (string.Empty, culture.Name, "#E4");
 975                 Assert.IsFalse (culture.UseUserOverride, "#E5");
 976
 977                 AssemblyName [] names = a.GetReferencedAssemblies ();
 978                 foreach (AssemblyName an in names) {
 979                         culture = an.CultureInfo;
 980                         Assert.IsFalse (culture.IsNeutralCulture, "#F1:" + an.Name);
 981                         Assert.IsFalse (culture.IsReadOnly, "#F2:" + an.Name);
 982                         Assert.AreEqual (127, culture.LCID, "#F3:" + an.Name);
 983                         Assert.AreEqual (string.Empty, culture.Name, "#F4:" + an.Name);
 984 #if NET_2_0
 985                         Assert.IsFalse (culture.UseUserOverride, "#F5:" + an.Name);
 986 #else
 987                         Assert.IsTrue (culture.UseUserOverride, "#F5:" + an.Name);
 988 #endif
 989                 }
 990         }
 991
 992         [Test]
 993         public void Version ()
 994         {
 995                 AssemblyName name = GenAssemblyName ();
 996                 name.Version = new Version (1, 2, 3, 4);
 997
 998                 Assembly a = GenerateAssembly (name);
 999                 Assert.AreEqual ("1.2.3.4", a.GetName ().Version.ToString (), "1.2.3.4 normal");
1000
1001                 name = GenAssemblyName ();
1002                 name.Version = new Version (1, 2, 3);
1003
1004                 a = GenerateAssembly (name);
1005                 Assert.AreEqual ("1.2.3.0", a.GetName ().Version.ToString (), "1.2.3.0 normal");
1006
1007                 name = GenAssemblyName ();
1008                 name.Version = new Version (1, 2);
1009
1010                 a = GenerateAssembly (name);
1011                 Assert.AreEqual ("1.2.0.0", a.GetName ().Version.ToString (), "1.2.0.0 normal");
1012         }
1013
1014         [Test]
1015         [Category ("NotWorking")]
1016         public void Version_Dynamic ()
1017         {
1018                 AssemblyName name = GenAssemblyName ();
1019                 name.Version = new Version (1, 2, 3, 4);
1020
1021                 AssemblyBuilder ab = GenerateDynamicAssembly (name);
1022                 Assert.AreEqual ("1.2.3.4", ab.GetName ().Version.ToString (), "1.2.3.4 dynamic");
1023
1024                 name = GenAssemblyName ();
1025                 name.Version = new Version (1, 2, 3);
1026
1027                 ab = GenerateDynamicAssembly (name);
1028 #if NET_2_0
1029                 Assert.AreEqual ("1.2.3.0", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
1030 #else
1031                 Assert.AreEqual ("1.2.3.65535", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
1032 #endif
1033
1034                 name = GenAssemblyName ();
1035                 name.Version = new Version (1, 2);
1036
1037                 ab = GenerateDynamicAssembly (name);
1038 #if NET_2_0
1039                 Assert.AreEqual ("1.2.0.0", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
1040 #else
1041                 Assert.AreEqual ("1.2.65535.65535", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
1042 #endif
1043         }
1044 #endif // TARGET_JVM
1045
1046         [Test]
1047         public void HashAlgorithm ()
1048         {
1049                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1,
1050                         typeof (int).Assembly.GetName ().HashAlgorithm);
1051         }
1052
1053         [Test]
1054         public void Serialization ()
1055         {
1056                 an = new AssemblyName ();
1057                 an.CodeBase = "http://www.test.com/test.dll";
1058                 an.CultureInfo = CultureInfo.InvariantCulture;
1059                 an.Flags = AssemblyNameFlags.PublicKey;
1060                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
1061                 an.KeyPair = new StrongNameKeyPair (publicKey1);
1062                 an.Name = "TestAssembly";
1063                 an.Version = new Version (1, 5);
1064                 an.VersionCompatibility = AssemblyVersionCompatibility.SameProcess;
1065
1066                 MemoryStream ms = new MemoryStream ();
1067                 BinaryFormatter bf = new BinaryFormatter ();
1068                 bf.Serialize (ms, an);
1069
1070                 // reset position of memorystream
1071                 ms.Position = 0;
1072
1073                 // deserialze assembly name
1074                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
1075
1076                 // close the memorystream
1077                 ms.Close ();
1078
1079                 // compare orginal and deserialized assembly name
1080                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
1081                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
1082                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
1083                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
1084                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
1085                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
1086                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
1087                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
1088                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
1089                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
1090                 Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey");
1091                 Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken");
1092         }
1093
1094         [Test]
1095         public void Serialization_WithoutStrongName ()
1096         {
1097                 an = new AssemblyName ();
1098                 an.CodeBase = "http://www.test.com/test.dll";
1099                 an.CultureInfo = CultureInfo.InvariantCulture;
1100                 an.Flags = AssemblyNameFlags.None;
1101                 an.HashAlgorithm = AssemblyHashAlgorithm.SHA1;
1102                 an.KeyPair = null;
1103                 an.Name = "TestAssembly2";
1104                 an.Version = new Version (1, 5, 0, 0);
1105                 an.VersionCompatibility = AssemblyVersionCompatibility.SameMachine;
1106
1107                 MemoryStream ms = new MemoryStream ();
1108                 BinaryFormatter bf = new BinaryFormatter ();
1109                 bf.Serialize (ms, an);
1110
1111                 // reset position of memorystream
1112                 ms.Position = 0;
1113
1114                 // deserialze assembly name
1115                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
1116
1117                 // close the memorystream
1118                 ms.Close ();
1119
1120                 // compare orginal and deserialized assembly name
1121                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
1122                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
1123                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
1124                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
1125                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
1126                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
1127                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
1128                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
1129                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
1130                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
1131                 Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey");
1132                 Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken");
1133         }
1134
1135 #if !TARGET_JVM // Assemblyname.GetObjectData not implemented yet for TARGET_JVM
1136         [Test]
1137         public void GetObjectData_Info_Null ()
1138         {
1139                 an = new AssemblyName ();
1140                 try {
1141                         an.GetObjectData (null, new StreamingContext (StreamingContextStates.All));
1142                         Assert.Fail ("#1");
1143                 } catch (ArgumentNullException ex) {
1144                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1145                         Assert.IsNull (ex.InnerException, "#3");
1146                         Assert.IsNotNull (ex.Message, "#4");
1147                         Assert.IsNotNull (ex.ParamName, "#5");
1148                         Assert.AreEqual ("info", ex.ParamName, "#6");
1149                 }
1150         }
1151 #endif // TARGET_JVM
1152
1153         [Test]
1154         public void Clone_Corlib ()
1155         {
1156                 an = typeof (int).Assembly.GetName ();
1157                 AssemblyName clone = (AssemblyName) an.Clone ();
1158
1159                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
1160                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
1161                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
1162                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
1163                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
1164                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
1165                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
1166                 Assert.AreEqual (an.Name, clone.Name, "Name");
1167 #if NET_2_0
1168                 Assert.AreEqual (an.ProcessorArchitecture, clone.ProcessorArchitecture, "PA");
1169 #endif
1170                 Assert.AreEqual (an.Version, clone.Version, "Version");
1171                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
1172                 Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
1173                 Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
1174                 Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
1175         }
1176
1177         [Test]
1178         public void Clone_Empty ()
1179         {
1180                 an = new AssemblyName ();
1181                 AssemblyName clone = (AssemblyName) an.Clone ();
1182
1183                 Assert.IsNull (clone.CodeBase, "CodeBase");
1184                 Assert.IsNull (clone.CultureInfo, "CultureInfo");
1185                 Assert.IsNull (clone.EscapedCodeBase, "EscapedCodeBase");
1186                 Assert.AreEqual (AssemblyNameFlags.None, clone.Flags, "Flags");
1187 #if NET_2_0
1188                 Assert.AreEqual (String.Empty, clone.FullName, "FullName");
1189 #else
1190                 Assert.IsNull (clone.FullName, "FullName");
1191 #endif
1192                 Assert.AreEqual (AssemblyHashAlgorithm.None, clone.HashAlgorithm, "HashAlgorithm");
1193                 Assert.IsNull (clone.KeyPair, "KeyPair");
1194                 Assert.IsNull (clone.Name, "Name");
1195 #if NET_2_0
1196                 Assert.AreEqual (ProcessorArchitecture.None, clone.ProcessorArchitecture, "PA");
1197 #endif
1198                 Assert.IsNull (clone.Version, "Version");
1199                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1200                         clone.VersionCompatibility, "VersionCompatibility");
1201         }
1202
1203         [Test]
1204         public void Clone_Self ()
1205         {
1206                 an = Assembly.GetExecutingAssembly ().GetName ();
1207                 AssemblyName clone = (AssemblyName) an.Clone ();
1208
1209                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
1210                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
1211                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
1212                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
1213                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
1214                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
1215                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
1216                 Assert.AreEqual (an.Name, clone.Name, "Name");
1217 #if NET_2_0
1218                 //Assert.AreEqual (ProcessorArchitecture.MSIL, clone.ProcessorArchitecture, "PA");
1219 #endif
1220                 Assert.AreEqual (an.Version, clone.Version, "Version");
1221                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
1222                 Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
1223                 Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
1224                 Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
1225         }
1226
1227         [Test]
1228         [ExpectedException (typeof (FileNotFoundException))]
1229         public void GetAssemblyName_AssemblyFile_DoesNotExist ()
1230         {
1231                 AssemblyName.GetAssemblyName (Path.Combine (tempDir, "doesnotexist.dll"));
1232         }
1233
1234         [Test]
1235         [Category ("NotWorking")]
1236         public void GetAssemblyName_AssemblyFile_ReadLock ()
1237         {
1238                 string file = Path.Combine (tempDir, "loadfailure.dll");
1239                 using (FileStream fs = File.Open (file, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None)) {
1240                         try {
1241                                 AssemblyName.GetAssemblyName (file);
1242                                 Assert.Fail ("#1");
1243                         } catch (FileLoadException ex) {
1244                                 // Could not load file or assembly '...' or one
1245                                 // of its dependencies. The process cannot access
1246                                 // the file because it is being used by another
1247                                 // process
1248                                 Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1249                                 Assert.IsNotNull (ex.FileName, "#3");
1250 #if NET_2_0
1251                                 Assert.AreEqual (file, ex.FileName, "#4");
1252 #else
1253                                 Assert.IsTrue (ex.FileName.IndexOf ("loadfailure.dll") != -1, "#4");
1254 #endif
1255                                 Assert.IsNull (ex.InnerException, "#5");
1256                                 Assert.IsNotNull (ex.Message, "#6");
1257                         }
1258                 }
1259                 File.Delete (file);
1260         }
1261
1262         [Test]
1263         public void GetAssemblyName_AssemblyFile_BadImage ()
1264         {
1265                 string file = Path.Combine (tempDir, "badimage.dll");
1266                 using (StreamWriter sw = File.CreateText (file)) {
1267                         sw.WriteLine ("somegarbage");
1268                 }
1269                 try {
1270                         AssemblyName.GetAssemblyName (file);
1271                         Assert.Fail ("#1");
1272                 } catch (BadImageFormatException ex) {
1273                         Assert.AreEqual (typeof (BadImageFormatException), ex.GetType (), "#2");
1274                         Assert.IsNotNull (ex.FileName, "#3");
1275 #if NET_2_0
1276                         Assert.AreEqual (file, ex.FileName, "#4");
1277 #else
1278                         Assert.IsTrue (ex.FileName.IndexOf ("badimage.dll") != -1, "#4");
1279 #endif
1280                         Assert.IsNull (ex.InnerException, "#5");
1281                         Assert.IsNotNull (ex.Message, "#6");
1282                 } finally {
1283                         File.Delete (file);
1284                 }
1285         }
1286
1287         [Test]
1288         public void GetAssemblyName_CodeBase ()
1289         {
1290                 Assembly execAssembly = Assembly.GetExecutingAssembly ();
1291
1292                 AssemblyName aname = AssemblyName.GetAssemblyName (execAssembly.Location);
1293                 Assert.IsNotNull (aname.CodeBase, "#1");
1294                 Assert.AreEqual (execAssembly.CodeBase, aname.CodeBase, "#2");
1295         }
1296
1297         // helpers
1298
1299         private string GetTokenString (byte[] value)
1300         {
1301                 string tokenString = "";
1302                 for (int i = 0; i < value.Length; i++) {
1303                         tokenString += value[i].ToString ("x2");
1304                 }
1305                 return tokenString;
1306         }
1307
1308 #if NET_2_0
1309         [Test] // ctor (String)
1310         public void Constructor1_Name ()
1311         {
1312                 const string assemblyName = "TestAssembly";
1313
1314                 an = new AssemblyName (assemblyName);
1315                 Assert.IsNull (an.CodeBase, "CodeBase");
1316                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1317                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1318                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1319                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1320                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1321                 Assert.IsNull (an.KeyPair, "KeyPair");
1322                 Assert.AreEqual (assemblyName, an.Name, "Name");
1323                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1324                 Assert.IsNull (an.Version, "Version");
1325                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1326                         an.VersionCompatibility, "VersionCompatibility");
1327                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1328                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1329                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1330         }
1331
1332         [Test] // ctor (String)
1333         [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM.
1334         public void Constructor1_Full ()
1335         {
1336                 const string assemblyName = "TestAssembly";
1337                 const string assemblyCulture = "neutral";
1338                 const string assemblyVersion = "1.2.3.4";
1339
1340                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion +
1341                                 ", Culture=" + assemblyCulture + ", PublicKeyToken=" + GetTokenString (pk_token1));
1342                 Assert.IsNull (an.CodeBase, "CodeBase");
1343                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo");
1344                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1345                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1346                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4, Culture=neutral, PublicKeyToken=" +
1347                         GetTokenString (pk_token1), an.FullName, "FullName");
1348                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1349                 Assert.IsNull (an.KeyPair, "KeyPair");
1350                 Assert.AreEqual (assemblyName, an.Name, "Name");
1351                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1352                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1353                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1354                         an.VersionCompatibility, "VersionCompatibility");
1355                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1356                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1357                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1358         }
1359
1360         [Test] // ctor (String)
1361         public void Constructor1_AssemblyName_Empty ()
1362         {
1363                 try {
1364                         new AssemblyName (string.Empty);
1365                         Assert.Fail ("#1");
1366                 } catch (ArgumentException ex) {
1367                         // String cannot have zero length
1368                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1369                         Assert.IsNull (ex.InnerException, "#3");
1370                         Assert.IsNotNull (ex.Message, "#4");
1371                         Assert.IsNull (ex.ParamName, "#5");
1372                 }
1373         }
1374
1375         [Test] // ctor (String)
1376         public void Constructor1_AssemblyName_Invalid ()
1377         {
1378                 const string assemblyName = "TestAssembly";
1379
1380                 try {
1381                         new AssemblyName (assemblyName + ", =1.2.4.5");
1382                         Assert.Fail ("#A1");
1383                 } catch (FileLoadException ex) {
1384                         // The given assembly name or codebase was invalid
1385                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1386                         Assert.IsNull (ex.FileName, "#3");
1387                         Assert.IsNull (ex.InnerException, "#3");
1388                         Assert.IsNotNull (ex.Message, "#4");
1389                 }
1390
1391                 try {
1392                         new AssemblyName (assemblyName + ", OtherAttribute");
1393                         Assert.Fail ("#B1");
1394                 } catch (FileLoadException ex) {
1395                         // The given assembly name or codebase was invalid
1396                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1397                         Assert.IsNull (ex.FileName, "#3");
1398                         Assert.IsNull (ex.InnerException, "#3");
1399                         Assert.IsNotNull (ex.Message, "#4");
1400                 }
1401         }
1402
1403         [Test] // ctor (String)
1404         public void Constructor1_AssemblyName_Null ()
1405         {
1406                 try {
1407                         new AssemblyName (null);
1408                         Assert.Fail ("#1");
1409                 } catch (ArgumentNullException ex) {
1410                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1411                         Assert.IsNull (ex.InnerException, "#3");
1412                         Assert.IsNotNull (ex.Message, "#4");
1413                         Assert.IsNotNull (ex.ParamName, "#5");
1414                         Assert.AreEqual ("assemblyName", ex.ParamName, "#6");
1415                 }
1416         }
1417
1418         [Test] // ctor (String)
1419         public void Constructor1_Culture ()
1420         {
1421                 const string assemblyName = "TestAssembly";
1422                 const string assemblyCulture = "en-US";
1423
1424                 an = new AssemblyName (assemblyName + ", Culture=" + assemblyCulture);
1425                 Assert.IsNull (an.CodeBase, "CodeBase");
1426                 Assert.AreEqual (new CultureInfo (assemblyCulture), an.CultureInfo, "CultureInfo");
1427                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1428                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1429                 Assert.AreEqual ("TestAssembly, Culture=en-US", an.FullName, "FullName");
1430                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1431                 Assert.IsNull (an.KeyPair, "KeyPair");
1432                 Assert.AreEqual (assemblyName, an.Name, "Name");
1433                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1434                 Assert.IsNull (an.Version, "Version");
1435                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1436                         an.VersionCompatibility, "VersionCompatibility");
1437                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1438                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1439                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1440         }
1441
1442         [Test] // ctor (String)
1443         public void Constructor1_Culture_Incomplete ()
1444         {
1445                 const string assemblyName = "TestAssembly";
1446
1447                 try {
1448                         new AssemblyName (assemblyName + ", Culture=");
1449                         Assert.Fail ("#1");
1450                 } catch (FileLoadException ex) {
1451                         // The given assembly name or codebase was invalid
1452                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1453                         Assert.IsNull (ex.FileName, "#3");
1454                         Assert.IsNull (ex.InnerException, "#3");
1455                         Assert.IsNotNull (ex.Message, "#4");
1456                 }
1457         }
1458
1459         [Test] // ctor (String)
1460         public void Constructor1_Culture_NotSupported ()
1461         {
1462                 const string assemblyName = "TestAssembly";
1463
1464                 try {
1465                         new AssemblyName (assemblyName + ", Culture=aa-AA");
1466                         Assert.Fail ("#1");
1467                 } catch (ArgumentException ex) {
1468                         // Culture name 'aa-aa' is not supported
1469                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1470                         Assert.IsNull (ex.InnerException, "#3");
1471                         Assert.IsNotNull (ex.Message, "#4");
1472                         Assert.IsNotNull (ex.ParamName, "#5");
1473                         Assert.AreEqual ("name", ex.ParamName, "#6");
1474                 }
1475         }
1476
1477         [Test] // ctor (String)
1478         [Category ("NotWorking")] // bug #351708
1479         public void Constructor1_ProcessorArchitecture ()
1480         {
1481                 const string assemblyName = "TestAssembly";
1482
1483                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=X86");
1484                 Assert.IsNull (an.CodeBase, "CodeBase");
1485                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1486                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1487                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1488                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1489                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1490                 Assert.IsNull (an.KeyPair, "KeyPair");
1491                 Assert.AreEqual (assemblyName, an.Name, "Name");
1492                 Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA");
1493                 Assert.IsNull (an.Version, "Version");
1494                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1495                         an.VersionCompatibility, "VersionCompatibility");
1496                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1497                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1498                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1499
1500                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=mSiL");
1501                 Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "PA: MSIL");
1502
1503                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=AmD64");
1504                 Assert.AreEqual (ProcessorArchitecture.Amd64, an.ProcessorArchitecture, "PA: Amd64");
1505
1506                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=iA64");
1507                 Assert.AreEqual (ProcessorArchitecture.IA64, an.ProcessorArchitecture, "PA: IA64");
1508         }
1509
1510         [Test] // ctor (String)
1511         [Category ("NotWorking")] // bug #351708
1512         public void Constructor1_ProcessorArchitecture_Incomplete ()
1513         {
1514                 const string assemblyName = "TestAssembly";
1515                 try {
1516                         new AssemblyName (assemblyName + ", ProcessorArchitecture=");
1517                         Assert.Fail ("#1");
1518                 } catch (FileLoadException ex) {
1519                         // The given assembly name or codebase was invalid
1520                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1521                         Assert.IsNull (ex.FileName, "#3");
1522                         Assert.IsNull (ex.InnerException, "#3");
1523                         Assert.IsNotNull (ex.Message, "#4");
1524                 }
1525         }
1526
1527         [Test] // ctor (String)
1528         [Category ("NotWorking")] // bug #351708
1529         public void Constructor1_ProcessorArchitecture_Invalid ()
1530         {
1531                 const string assemblyName = "TestAssembly";
1532                 try {
1533                         new AssemblyName (assemblyName + ", ProcessorArchitecture=XXX");
1534                         Assert.Fail ("#A1");
1535                 } catch (FileLoadException ex) {
1536                         // The given assembly name or codebase was invalid
1537                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1538                         Assert.IsNull (ex.FileName, "#A3");
1539                         Assert.IsNull (ex.InnerException, "#A4");
1540                         Assert.IsNotNull (ex.Message, "#A5");
1541                 }
1542
1543                 try {
1544                         new AssemblyName (assemblyName + ", ProcessorArchitecture=None");
1545                         Assert.Fail ("#B1");
1546                 } catch (FileLoadException ex) {
1547                         // The given assembly name or codebase was invalid
1548                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1549                         Assert.IsNull (ex.FileName, "#B3");
1550                         Assert.IsNull (ex.InnerException, "#B4");
1551                         Assert.IsNotNull (ex.Message, "#B5");
1552                 }
1553         }
1554
1555         [Test] // ctor (String)
1556         [Category ("NotDotNet")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1557         public void Constructor1_PublicKey_Mono ()
1558         {
1559                 const string assemblyName = "TestAssembly";
1560
1561                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1562                 Assert.IsNull (an.CodeBase, "CodeBase");
1563                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1564                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1565                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags");
1566                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1567                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1568                 Assert.IsNull (an.KeyPair, "KeyPair");
1569                 Assert.AreEqual (assemblyName, an.Name, "Name");
1570                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1571                 Assert.IsNull (an.Version, "Version");
1572                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1573                         an.VersionCompatibility, "VersionCompatibility");
1574                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "GetPublicKey");
1575                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1576                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1577         }
1578
1579         [Test]
1580         [Category ("NotWorking")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1581         public void Constructor1_PublicKey_MS ()
1582         {
1583                 const string assemblyName = "TestAssembly";
1584
1585                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1586                 Assert.IsNull (an.CodeBase, "CodeBase");
1587                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1588                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1589                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1590                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1591                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1592                 Assert.IsNull (an.KeyPair, "KeyPair");
1593                 Assert.AreEqual (assemblyName, an.Name, "Name");
1594                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1595                 Assert.IsNull (an.Version, "Version");
1596                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1597                         an.VersionCompatibility, "VersionCompatibility");
1598                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1599                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1600                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1601         }
1602
1603         [Test] // ctor (String)
1604         [Category ("NotWorking")] // bug #351725
1605         public void Constructor1_PublicKey_Ecma ()
1606         {
1607                 const string assemblyName = "TestAssembly";
1608
1609                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey3));
1610                 Assert.IsNull (an.CodeBase, "CodeBase");
1611                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1612                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1613                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1614                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "FullName");
1615                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1616                 Assert.IsNull (an.KeyPair, "KeyPair");
1617                 Assert.AreEqual (assemblyName, an.Name, "Name");
1618                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1619                 Assert.IsNull (an.Version, "Version");
1620                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1621                         an.VersionCompatibility, "VersionCompatibility");
1622                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1623                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "GetPublicKeyToken");
1624                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1625         }
1626
1627         [Test] // ctor (String)
1628         public void Constructor1_PublicKey_Incomplete ()
1629         {
1630                 const string assemblyName = "TestAssembly";
1631
1632                 try {
1633                         new AssemblyName (assemblyName + ", PublicKey=");
1634                         Assert.Fail ("#1");
1635                 } catch (FileLoadException ex) {
1636                         // The given assembly name or codebase was invalid
1637                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1638                         Assert.IsNull (ex.FileName, "#3");
1639                         Assert.IsNull (ex.InnerException, "#3");
1640                         Assert.IsNotNull (ex.Message, "#4");
1641                 }
1642         }
1643
1644         [Test] // ctor (String)
1645         public void Constructor1_PublicKey_Invalid ()
1646         {
1647                 const string assemblyName = "TestAssembly";
1648
1649                 try {
1650                         new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e");
1651                         Assert.Fail ("#A1");
1652                 } catch (FileLoadException ex) {
1653                         // The given assembly name or codebase was invalid
1654                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1655                         Assert.IsNull (ex.FileName, "#A3");
1656                         Assert.IsNull (ex.InnerException, "#A4");
1657                         Assert.IsNotNull (ex.Message, "#A5");
1658                 }
1659
1660                 try {
1661                         new AssemblyName (assemblyName + ", PublicKey=null");
1662                         Assert.Fail ("#B1");
1663                 } catch (FileLoadException ex) {
1664                         // The given assembly name or codebase was invalid
1665                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1666                         Assert.IsNull (ex.FileName, "#B3");
1667                         Assert.IsNull (ex.InnerException, "#B4");
1668                         Assert.IsNotNull (ex.Message, "#B5");
1669                 }
1670         }
1671
1672         [Test] // ctor (String)
1673         [Category ("NotWorking")] // bug #351756
1674         public void Constructor1_PublicKey_KeyPair ()
1675         {
1676                 const string assemblyName = "TestAssembly";
1677
1678                 try {
1679                         new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (keyPair));
1680                         Assert.Fail ("#1");
1681                 } catch (SecurityException ex) {
1682                         // Invalid assembly public key
1683                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#2");
1684                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#3");
1685                         Assert.IsNull (ex.InnerException, "#4");
1686                         Assert.IsNotNull (ex.Message, "#5");
1687                 }
1688         }
1689
1690         [Test] // ctor (String)
1691         public void Constructor1_PublicKeyToken ()
1692         {
1693                 const string assemblyName = "TestAssembly";
1694
1695                 an = new AssemblyName (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1));
1696                 Assert.IsNull (an.CodeBase, "#A:CodeBase");
1697                 Assert.IsNull (an.CultureInfo, "#A:CultureInfo");
1698                 Assert.IsNull (an.EscapedCodeBase, "#A:EscapedCodeBase");
1699                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A:Flags");
1700                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A:FullName");
1701                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#A:HashAlgorithm");
1702                 Assert.IsNull (an.KeyPair, "#A:KeyPair");
1703                 Assert.AreEqual (assemblyName, an.Name, "#A:Name");
1704                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#A:PA");
1705                 Assert.IsNull (an.Version, "#A:Version");
1706                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1707                         an.VersionCompatibility, "#A:VersionCompatibility");
1708                 Assert.IsNull (an.GetPublicKey (), "#A:GetPublicKey");
1709                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A:GetPublicKeyToken");
1710                 Assert.AreEqual (an.FullName, an.ToString (), "#A:ToString");
1711
1712                 an = new AssemblyName (assemblyName + ", PublicKeyToken=null");
1713                 Assert.IsNull (an.CodeBase, "#B:CodeBase");
1714                 Assert.IsNull (an.CultureInfo, "#B:CultureInfo");
1715                 Assert.IsNull (an.EscapedCodeBase, "#B:EscapedCodeBase");
1716                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B:Flags");
1717                 //Assert.AreEqual ("TestAssembly, PublicKeyToken=null", an.FullName, "#B:FullName");
1718                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#B:HashAlgorithm");
1719                 Assert.IsNull (an.KeyPair, "#B:KeyPair");
1720                 Assert.AreEqual (assemblyName, an.Name, "#B:Name");
1721                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#B:PA");
1722                 Assert.IsNull (an.Version, "#B:Version");
1723                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1724                         an.VersionCompatibility, "#B:VersionCompatibility");
1725                 Assert.IsNull (an.GetPublicKey (), "#B:GetPublicKey");
1726                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#B:GetPublicKeyToken");
1727                 Assert.AreEqual (an.FullName, an.ToString (), "#B:ToString");
1728         }
1729
1730         [Test] // ctor (String)
1731         public void Constructor1_PublicKeyToken_Incomplete ()
1732         {
1733                 const string assemblyName = "TestAssembly";
1734
1735                 try {
1736                         new AssemblyName (assemblyName + ", PublicKeyToken=");
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
1747         [Test] // ctor (String)
1748         public void Constructor1_PublicKeyToken_Invalid ()
1749         {
1750                 const string assemblyName = "TestAssembly";
1751
1752                 try {
1753                         new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188");
1754                         Assert.Fail ("#1");
1755                 } catch (FileLoadException ex) {
1756                         // The given assembly name or codebase was invalid
1757                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1758                         Assert.IsNull (ex.FileName, "#3");
1759                         Assert.IsNull (ex.InnerException, "#3");
1760                         Assert.IsNotNull (ex.Message, "#4");
1761                 }
1762         }
1763
1764         [Test] // ctor (String)
1765         public void Constructor1_Retargetable ()
1766         {
1767                 const string assemblyName = "TestAssembly";
1768
1769                 try {
1770                         new AssemblyName (assemblyName + ", Retargetable=Yes");
1771                         Assert.Fail ("#A1");
1772                 } catch (FileLoadException ex) {
1773                         // The given assembly name or codebase was invalid
1774                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1775                         Assert.IsNull (ex.FileName, "#A3");
1776                         Assert.IsNull (ex.InnerException, "#A4");
1777                         Assert.IsNotNull (ex.Message, "#A5");
1778                 }
1779
1780                 try {
1781                         new AssemblyName (assemblyName + ", Retargetable=No");
1782                         Assert.Fail ("#B1");
1783                 } catch (FileLoadException ex) {
1784                         // The given assembly name or codebase was invalid
1785                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1786                         Assert.IsNull (ex.FileName, "#B3");
1787                         Assert.IsNull (ex.InnerException, "#B4");
1788                         Assert.IsNotNull (ex.Message, "#B5");
1789                 }
1790
1791                 try {
1792                         new AssemblyName (assemblyName + ", Version=1.0.0.0, Retargetable=Yes");
1793                         Assert.Fail ("#C1");
1794                 } catch (FileLoadException ex) {
1795                         // The given assembly name or codebase was invalid
1796                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2");
1797                         Assert.IsNull (ex.FileName, "#C3");
1798                         Assert.IsNull (ex.InnerException, "#C4");
1799                         Assert.IsNotNull (ex.Message, "#C5");
1800                 }
1801
1802                 try {
1803                         new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, Retargetable=Yes");
1804                         Assert.Fail ("#D1");
1805                 } catch (FileLoadException ex) {
1806                         // The given assembly name or codebase was invalid
1807                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#D2");
1808                         Assert.IsNull (ex.FileName, "#D3");
1809                         Assert.IsNull (ex.InnerException, "#D4");
1810                         Assert.IsNotNull (ex.Message, "#D5");
1811                 }
1812
1813                 try {
1814                         new AssemblyName (assemblyName + ", Version=1.0.0.0, PublicKeyToken=null, Retargetable=Yes");
1815                         Assert.Fail ("#E1");
1816                 } catch (FileLoadException ex) {
1817                         // The given assembly name or codebase was invalid
1818                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#E2");
1819                         Assert.IsNull (ex.FileName, "#E3");
1820                         Assert.IsNull (ex.InnerException, "#E4");
1821                         Assert.IsNotNull (ex.Message, "#E5");
1822                 }
1823
1824                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=yEs");
1825                 Assert.IsNull (an.CodeBase, "F:CodeBase");
1826                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#F:CultureInfo");
1827                 Assert.IsNull (an.EscapedCodeBase, "#F:EscapedCodeBase");
1828                 Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#F:Flags");
1829                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=Yes", an.FullName, "#F:FullName");
1830                 Assert.IsNull (an.GetPublicKey (), "#F:GetPublicKey");
1831                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#F:GetPublicKeyToken");
1832                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#F:HashAlgorithm");
1833                 Assert.IsNull (an.KeyPair, "#F:KeyPair");
1834                 Assert.AreEqual (assemblyName, an.Name, "#F:Name");
1835                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#F:PA");
1836                 Assert.AreEqual (an.FullName, an.ToString (), "#F:ToString");
1837                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#F:Version");
1838                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1839                         an.VersionCompatibility, "#F:VersionCompatibility");
1840
1841                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=nO");
1842                 Assert.IsNull (an.CodeBase, "G:CodeBase");
1843                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#G:CultureInfo");
1844                 Assert.IsNull (an.EscapedCodeBase, "#G:EscapedCodeBase");
1845                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#G:Flags");
1846                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", an.FullName, "#G:FullName");
1847                 Assert.IsNull (an.GetPublicKey (), "#G:GetPublicKey");
1848                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#G:GetPublicKeyToken");
1849                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#G:HashAlgorithm");
1850                 Assert.IsNull (an.KeyPair, "#G:KeyPair");
1851                 Assert.AreEqual (assemblyName, an.Name, "#G:Name");
1852                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#G:PA");
1853                 Assert.AreEqual (an.FullName, an.ToString (), "#G:ToString");
1854                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#G:Version");
1855                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1856                         an.VersionCompatibility, "#G:VersionCompatibility");
1857
1858                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=yes");
1859                 Assert.IsNull (an.CodeBase, "H:CodeBase");
1860                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#H:CultureInfo");
1861                 Assert.IsNull (an.EscapedCodeBase, "#H:EscapedCodeBase");
1862                 Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#H:Flags");
1863                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=Yes", an.FullName, "#H:FullName");
1864                 Assert.IsNull (an.GetPublicKey (), "#H:GetPublicKey");
1865                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#H:GetPublicKeyToken");
1866                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#H:HashAlgorithm");
1867                 Assert.IsNull (an.KeyPair, "#H:KeyPair");
1868                 Assert.AreEqual (assemblyName, an.Name, "#H:Name");
1869                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#H:PA");
1870                 Assert.AreEqual (an.FullName, an.ToString (), "#H:ToString");
1871                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#H:Version");
1872                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1873                         an.VersionCompatibility, "#H:VersionCompatibility");
1874         }
1875
1876         [Test] // ctor (String)
1877         public void Constructor1_Retargetable_Incomplete ()
1878         {
1879                 const string assemblyName = "TestAssembly";
1880
1881                 try {
1882                         new AssemblyName (assemblyName + ", Retargetable=");
1883                         Assert.Fail ("#1");
1884                 } catch (FileLoadException ex) {
1885                         // The given assembly name or codebase was invalid
1886                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1887                         Assert.IsNull (ex.FileName, "#3");
1888                         Assert.IsNull (ex.InnerException, "#4");
1889                         Assert.IsNotNull (ex.Message, "#5");
1890                 }
1891         }
1892
1893         [Test] // ctor (String)
1894         public void Constructor1_Retargetable_Invalid ()
1895         {
1896                 const string assemblyName = "TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
1897
1898                 try {
1899                         new AssemblyName (assemblyName + ", Retargetable=False");
1900                         Assert.Fail ("#A1");
1901                 } catch (FileLoadException ex) {
1902                         // The given assembly name or codebase was invalid
1903                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1904                         Assert.IsNull (ex.FileName, "#A3");
1905                         Assert.IsNull (ex.InnerException, "#A4");
1906                         Assert.IsNotNull (ex.Message, "#A5");
1907                 }
1908
1909                 try {
1910                         new AssemblyName (assemblyName + ", Retargetable=1");
1911                         Assert.Fail ("#B1");
1912                 } catch (FileLoadException ex) {
1913                         // The given assembly name or codebase was invalid
1914                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1915                         Assert.IsNull (ex.FileName, "#B3");
1916                         Assert.IsNull (ex.InnerException, "#B4");
1917                         Assert.IsNotNull (ex.Message, "#B5");
1918                 }
1919
1920                 try {
1921                         new AssemblyName (assemblyName + ", Retargetable=True");
1922                         Assert.Fail ("#C1");
1923                 } catch (FileLoadException ex) {
1924                         // The given assembly name or codebase was invalid
1925                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2");
1926                         Assert.IsNull (ex.FileName, "#C3");
1927                         Assert.IsNull (ex.InnerException, "#C4");
1928                         Assert.IsNotNull (ex.Message, "#C5");
1929                 }
1930         }
1931
1932         [Test] // ctor (String)
1933         [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM.
1934         public void Constructor1_Version ()
1935         {
1936                 const string assemblyName = "TestAssembly";
1937                 const string assemblyVersion = "1.2.3.4";
1938
1939                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion);
1940                 Assert.IsNull (an.CodeBase, "CodeBase");
1941                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1942                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1943                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1944                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4", an.FullName, "FullName");
1945                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1946                 Assert.IsNull (an.KeyPair, "KeyPair");
1947                 Assert.AreEqual (assemblyName, an.Name, "Name");
1948                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1949                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1950                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1951                         an.VersionCompatibility, "VersionCompatibility");
1952                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1953                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1954                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1955         }
1956
1957
1958         [Test] // ctor (String)
1959         public void Constructor1_Version_Incomplete ()
1960         {
1961                 const string assemblyName = "TestAssembly";
1962
1963                 try {
1964                         new AssemblyName (assemblyName + ", Version=, Culture=neutral");
1965                         Assert.Fail ("#1");
1966                 } catch (FileLoadException ex) {
1967                         // The given assembly name or codebase was invalid
1968                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1969                         Assert.IsNull (ex.FileName, "#3");
1970                         Assert.IsNull (ex.InnerException, "#3");
1971                         Assert.IsNotNull (ex.Message, "#4");
1972                 }
1973         }
1974
1975         [Test] // ctor (String)
1976         public void Constructor1_Version_Invalid ()
1977         {
1978                 const string assemblyName = "TestAssembly";
1979
1980                 try {
1981                         new AssemblyName (assemblyName + ", Version=a.b");
1982                         Assert.Fail ("#1");
1983                 } catch (FileLoadException ex) {
1984                         // The given assembly name or codebase was invalid
1985                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1986                         Assert.IsNull (ex.FileName, "#3");
1987                         Assert.IsNull (ex.InnerException, "#3");
1988                         Assert.IsNotNull (ex.Message, "#4");
1989                 }
1990         }
1991 #endif
1992 }
1993
1994 }