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 && !MOBILE
  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 #if !NET_2_0
 102         static byte [] kp_token = { 0xff, 0xef, 0x94, 0x53, 0x67, 0x69, 0xda, 0x06 };
 103 #endif
 104
 105         static byte [] publicKey1 = {
 106                 0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00,
 107                 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
 108                 0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00,
 109                 0x01, 0x00, 0x3d, 0xbd, 0x72, 0x08, 0xc6, 0x2b, 0x0e, 0xa8,
 110                 0xc1, 0xc0, 0x58, 0x07, 0x2b, 0x63, 0x5f, 0x7c, 0x9a, 0xbd,
 111                 0xcb, 0x22, 0xdb, 0x20, 0xb2, 0xa9, 0xda, 0xda, 0xef, 0xe8,
 112                 0x00, 0x64, 0x2f, 0x5d, 0x8d, 0xeb, 0x78, 0x02, 0xf7, 0xa5,
 113                 0x36, 0x77, 0x28, 0xd7, 0x55, 0x8d, 0x14, 0x68, 0xdb, 0xeb,
 114                 0x24, 0x09, 0xd0, 0x2b, 0x13, 0x1b, 0x92, 0x6e, 0x2e, 0x59,
 115                 0x54, 0x4a, 0xac, 0x18, 0xcf, 0xc9, 0x09, 0x02, 0x3f, 0x4f,
 116                 0xa8, 0x3e, 0x94, 0x00, 0x1f, 0xc2, 0xf1, 0x1a, 0x27, 0x47,
 117                 0x7d, 0x10, 0x84, 0xf5, 0x14, 0xb8, 0x61, 0x62, 0x1a, 0x0c,
 118                 0x66, 0xab, 0xd2, 0x4c, 0x4b, 0x9f, 0xc9, 0x0f, 0x3c, 0xd8,
 119                 0x92, 0x0f, 0xf5, 0xff, 0xce, 0xd7, 0x6e, 0x5c, 0x6f, 0xb1,
 120                 0xf5, 0x7d, 0xd3, 0x56, 0xf9, 0x67, 0x27, 0xa4, 0xa5, 0x48,
 121                 0x5b, 0x07, 0x93, 0x44, 0x00, 0x4a, 0xf8, 0xff, 0xa4, 0xcb };
 122
 123         static byte [] pk_token1 = { 0xce, 0x52, 0x76, 0xd8, 0x68, 0x7e, 0Xc6, 0xdc };
 124
 125         static byte [] publicKey2 = {
 126                 0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00,
 127                 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00,
 128                 0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00,
 129                 0x01, 0x00, 0x6d, 0xfd, 0xba, 0xb9, 0x9d, 0x43, 0xf1, 0xef,
 130                 0x33, 0xe2, 0xbd, 0x2d, 0x7c, 0x26, 0xe2, 0x9d, 0x37, 0x4a,
 131                 0xdf, 0xb5, 0x63, 0x12, 0x90, 0x35, 0x90, 0x24, 0x8a, 0xe7,
 132                 0x5a, 0xc5, 0xa3, 0x3a, 0x84, 0xee, 0x9b, 0xd1, 0xac, 0x3a,
 133                 0x59, 0x2b, 0x91, 0x97, 0x83, 0x01, 0x4f, 0x92, 0x01, 0xc6,
 134                 0x3b, 0x96, 0x20, 0x19, 0xeb, 0xdc, 0x2c, 0x6f, 0x1f, 0xbb,
 135                 0x04, 0x9b, 0x62, 0x39, 0xc0, 0xff, 0x58, 0x64, 0x17, 0x48,
 136                 0xc2, 0x5b, 0x94, 0x98, 0x35, 0x50, 0x1f, 0x27, 0xbc, 0xea,
 137                 0x91, 0x92, 0x3f, 0x5c, 0x33, 0x12, 0x17, 0x65, 0x56, 0x3e,
 138                 0x40, 0x44, 0x27, 0x1d, 0xef, 0x0e, 0x72, 0xab, 0xd4, 0xf0,
 139                 0x49, 0xa3, 0x95, 0x1a, 0x61, 0xb4, 0x47, 0x90, 0x20, 0xcc,
 140                 0x50, 0xa4, 0x4d, 0x8b, 0x8a, 0x58, 0x17, 0x70, 0xa4, 0x53,
 141                 0xe4, 0xdc, 0x73, 0x5d, 0x8c, 0x4e, 0xb8, 0xd3, 0xa9, 0xbf };
 142
 143 #if !NET_2_0
 144         static byte [] pk_token2 = { 0x22, 0x7c, 0x9c, 0x2c, 0x3c, 0x00, 0x63, 0xe9 };
 145 #endif
 146
 147         static byte [] publicKey3 = {
 148                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
 149                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 150
 151         static byte [] pk_token3 = { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 };
 152
 153         [SetUp]
 154         public void SetUp ()
 155         {
 156                 try {
 157                         if (Directory.Exists (tempDir))
 158                                 Directory.Delete (tempDir, true);
 159                 }
 160                 catch (Exception) {
 161                 }
 162
 163                 Directory.CreateDirectory (tempDir);
 164
 165 #if !TARGET_JVM // Thread.GetDomain is not supported for TARGET_JVM.
 166                 domain = Thread.GetDomain ();
 167 #endif // TARGET_JVM
 168         }
 169
 170         [TearDown]
 171         public void TearDown ()
 172         {
 173                 try {
 174                         if (Directory.Exists (tempDir))
 175                                 Directory.Delete (tempDir, true);
 176                 }
 177                 catch (Exception) {
 178                         // This can happen on windows when the directory contains
 179                         // files opened by the CLR
 180                 }
 181         }
 182
 183         [Test] // ctor ()
 184         public void Constructor0 ()
 185         {
 186                 an = new AssemblyName ();
 187                 Assert.IsNull (an.CodeBase, "CodeBase");
 188                 Assert.IsNull (an.CultureInfo, "CultureInfo");
 189                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
 190                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
 191 #if NET_2_0
 192                 Assert.AreEqual (String.Empty, an.FullName, "FullName");
 193 #else
 194                 Assert.IsNull (an.FullName, "FullName");
 195 #endif
 196                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
 197                 Assert.IsNull (an.KeyPair, "KeyPair");
 198                 Assert.IsNull (an.Name, "Name");
 199 #if NET_2_0
 200                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
 201 #endif
 202                 Assert.IsNull (an.Version, "Version");
 203                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
 204                         an.VersionCompatibility, "VersionCompatibility");
 205                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
 206                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
 207 #if NET_2_0
 208                 Assert.AreEqual (string.Empty, an.ToString (), "ToString");
 209 #else
 210                 Assert.AreEqual (typeof (AssemblyName).FullName, an.ToString (), "ToString");
 211 #endif
 212         }
 213
 214         [Test]
 215         public void SetPublicKey ()
 216         {
 217                 an = new AssemblyName ();
 218                 Assert.IsNull (an.GetPublicKey (), "#A1");
 219                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A2");
 220                 Assert.IsNull (an.KeyPair, "#A3");
 221                 Assert.IsNull (an.GetPublicKeyToken (), "#A4");
 222
 223                 an.SetPublicKey (publicKey1);
 224
 225                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "#B1");
 226                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#B2");
 227                 Assert.IsNull (an.KeyPair, "#B3");
 228                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B4");
 229                 an.SetPublicKey (keyPair);
 230                 Assert.AreEqual (keyPair, an.GetPublicKey (), "#B5");
 231                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B6");
 232
 233                 an.SetPublicKey ((byte []) null);
 234
 235                 Assert.IsNull (an.GetPublicKey (), "#C1");
 236 #if NET_2_0
 237                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#C2");
 238 #else
 239                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#C2");
 240 #endif
 241                 Assert.IsNull (an.KeyPair, "#C3");
 242                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C4");
 243
 244                 an.SetPublicKey (publicKey1);
 245                 an.SetPublicKeyToken (pk_token1);
 246                 an.SetPublicKey ((byte []) null);
 247
 248                 Assert.IsNull (an.GetPublicKey (), "#D1");
 249 #if NET_2_0
 250                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#D2");
 251 #else
 252                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#D2");
 253 #endif
 254                 Assert.IsNull (an.KeyPair, "#D3");
 255                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#D4");
 256
 257                 an.SetPublicKey ((byte []) null);
 258                 an.SetPublicKeyToken (pk_token1);
 259                 an.SetPublicKey ((byte []) null);
 260
 261                 Assert.IsNull (an.GetPublicKey (), "#E1");
 262 #if NET_2_0
 263                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#E2");
 264 #else
 265                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#E2");
 266 #endif
 267                 Assert.IsNull (an.KeyPair, "#E3");
 268                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#E4");
 269
 270                 an = new AssemblyName ();
 271                 an.SetPublicKey (publicKey1);
 272                 an.SetPublicKey ((byte []) null);
 273                 an.SetPublicKeyToken (pk_token1);
 274                 an.SetPublicKey ((byte []) null);
 275
 276                 Assert.IsNull (an.GetPublicKey (), "#F1");
 277                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#F2");
 278                 Assert.IsNull (an.KeyPair, "#F3");
 279                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#F4");
 280
 281                 an = new AssemblyName ();
 282                 an.SetPublicKey (publicKey1);
 283                 an.SetPublicKey ((byte []) null);
 284                 an.SetPublicKeyToken (pk_token1);
 285
 286                 Assert.IsNull (an.GetPublicKey (), "#G1");
 287 #if NET_2_0
 288                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#G2");
 289 #else
 290                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#G2");
 291 #endif
 292                 Assert.IsNull (an.KeyPair, "#G3");
 293                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#G4");
 294
 295                 an = new AssemblyName ();
 296                 an.SetPublicKey (new byte [0]);
 297
 298                 Assert.IsNotNull (an.GetPublicKey (), "#H1");
 299                 Assert.AreEqual (0, an.GetPublicKey ().Length, "#H2");
 300                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#H3");
 301                 Assert.IsNull (an.KeyPair, "#H4");
 302 #if NET_2_0
 303                 Assert.IsNotNull (an.GetPublicKeyToken (), "#H5");
 304                 Assert.AreEqual (0, an.GetPublicKeyToken ().Length, "#H6");
 305 #else
 306                 Assert.IsNull (an.GetPublicKeyToken (), "#H5");
 307 #endif
 308
 309                 an = new AssemblyName ();
 310                 an.SetPublicKey (publicKey1);
 311                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#I1");
 312                 an.SetPublicKey (publicKey1);
 313                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#I2");
 314
 315                 an = new AssemblyName ();
 316                 an.SetPublicKey ((byte []) null);
 317                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J1");
 318                 an.SetPublicKey ((byte []) null);
 319 #if NET_2_0
 320                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#J2");
 321 #else
 322                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J2");
 323 #endif
 324                 an.SetPublicKey ((byte []) null);
 325                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J3");
 326                 an.SetPublicKey (publicKey1);
 327                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J4");
 328                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "#J5");
 329                 an.SetPublicKey (publicKey2);
 330                 Assert.AreEqual (publicKey2, an.GetPublicKey (), "#J6");
 331         }
 332
 333         [Test]
 334         public void SetPublicKey_PublicKey_Invalid ()
 335         {
 336                 an = new AssemblyName ();
 337                 an.SetPublicKey (new byte [] { 0x0b, 0x0a });
 338                 Assert.AreEqual (new byte [] { 0x0b, 0x0a }, an.GetPublicKey (), "#1");
 339         }
 340
 341         [Test]
 342         public void SetPublicKeyToken ()
 343         {
 344                 an = new AssemblyName ();
 345                 an.SetPublicKeyToken (pk_token1);
 346
 347                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A1");
 348                 Assert.IsNull (an.KeyPair, "#A2");
 349                 Assert.IsNull (an.GetPublicKey (), "#A3");
 350                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A4");
 351
 352                 an.SetPublicKeyToken ((byte []) null);
 353
 354                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B1");
 355                 Assert.IsNull (an.KeyPair, "#B2");
 356                 Assert.IsNull (an.GetPublicKey (), "#B3");
 357                 Assert.IsNull (an.GetPublicKeyToken (), "#B4");
 358
 359                 an.SetPublicKeyToken (new byte [0]);
 360
 361                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#C1");
 362                 Assert.IsNull (an.KeyPair, "#C2");
 363                 Assert.IsNull (an.GetPublicKey (), "#C3");
 364                 Assert.IsNotNull (an.GetPublicKeyToken (), "#C4");
 365                 Assert.AreEqual (0, an.GetPublicKeyToken ().Length, "#C5");
 366         }
 367
 368         [Test]
 369         public void KeyPair ()
 370         {
 371                 an = new AssemblyName ();
 372                 an.Name = "test";
 373                 an.KeyPair = new StrongNameKeyPair (keyPair);
 374
 375                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A1");
 376                 Assert.IsNotNull (an.KeyPair, "#A2");
 377                 Assert.IsNull (an.GetPublicKey (), "#A3");
 378                 Assert.IsNull (an.GetPublicKeyToken (), "#A4");
 379                 Assert.AreEqual ("test", an.FullName, "#A5");
 380
 381                 an.KeyPair = null;
 382
 383                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B1");
 384                 Assert.IsNull (an.KeyPair, "#B2");
 385                 Assert.IsNull (an.GetPublicKey (), "#B3");
 386                 Assert.IsNull (an.GetPublicKeyToken (), "#B4");
 387                 Assert.AreEqual ("test", an.FullName, "#B5");
 388         }
 389
 390         // !!! this assembly MUST NOT use a StrongName !!!
 391         [Test]
 392         public void Self ()
 393         {
 394                 Assembly a = Assembly.GetExecutingAssembly ();
 395                 an = a.GetName ();
 396
 397                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo");
 398                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags");
 399                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1, an.HashAlgorithm, "HashAlgorithm");
 400                 Assert.IsNull (an.KeyPair, "KeyPair");
 401                 Assert.IsNotNull (an.Name, "Name");
 402 #if NET_2_0
 403                 //Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "PA");
 404 #endif
 405                 Assert.AreEqual (new Version (0, 0, 0, 0), an.Version, "Version");
 406                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
 407                         an.VersionCompatibility, "VersionCompatibility");
 408                 Assert.AreEqual (new byte [0], an.GetPublicKey (), "GetPublicKey");
 409                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
 410         }
 411
 412         [Test]
 413         public void Flags_Corlib ()
 414         {
 415                 an = typeof (int).Assembly.GetName ();
 416                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags);
 417         }
 418
 419         [Test]
 420         public void Flags_Self ()
 421         {
 422                 Assembly a = Assembly.GetExecutingAssembly ();
 423                 an = a.GetName ();
 424                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags);
 425         }
 426
 427         [Test]
 428         public void FullName_Corlib ()
 429         {
 430                 an = typeof(int).Assembly.GetName ();
 431                 Assert.IsNotNull (an.FullName, "#1");
 432
 433                 string AssemblyCorlib;
 434 #if MOBILE
 435                 AssemblyCorlib = "mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e";
 436 #elif NET_4_0
 437                 AssemblyCorlib = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 438 #else
 439                 AssemblyCorlib = "mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 440 #endif
 441                 Assert.AreEqual (AssemblyCorlib, an.FullName, "#2");
 442         }
 443
 444         [Test]
 445         public void FullName_Self ()
 446         {
 447                 Assembly a = Assembly.GetExecutingAssembly ();
 448                 an = a.GetName ();
 449
 450                 Assert.IsNotNull (an.FullName, "#1");
 451                 Assert.IsTrue (an.FullName.IndexOf ("Version=0.0.0.0") != -1, "#2");
 452                 Assert.IsTrue (an.FullName.IndexOf ("Culture=neutral") != -1, "#3");
 453                 Assert.IsTrue (an.FullName.IndexOf ("PublicKeyToken=null") != -1, "#4");
 454         }
 455
 456         [Test]
 457         public void FullName_Flags ()
 458         {
 459                 const string assemblyName = "TestAssembly";
 460
 461                 // tests for AssemblyName with only name
 462                 an = new AssemblyName ();
 463 #if NET_2_0
 464                 an.Flags = AssemblyNameFlags.EnableJITcompileOptimizer |
 465                         AssemblyNameFlags.EnableJITcompileTracking |
 466                         AssemblyNameFlags.PublicKey |
 467                         AssemblyNameFlags.Retargetable;
 468 #else
 469                 an.Flags = AssemblyNameFlags.PublicKey |
 470                         AssemblyNameFlags.Retargetable;
 471 #endif
 472                 an.Name = assemblyName;
 473                 Assert.AreEqual (assemblyName + ", Retargetable=Yes", an.FullName, "#1");
 474                 an.Flags = AssemblyNameFlags.None;
 475                 Assert.AreEqual (assemblyName, an.FullName, "#2");
 476         }
 477
 478         [Test]
 479         public void FullName_Name ()
 480         {
 481                 const string assemblyName = "TestAssembly";
 482
 483                 // tests for AssemblyName with only name
 484                 an = new AssemblyName ();
 485                 an.Name = assemblyName;
 486                 Assert.IsNotNull (an.FullName, "FullName2#1");
 487                 Assert.AreEqual (an.Name, an.FullName, "FullName2#2");
 488                 Assert.AreEqual (-1, an.FullName.IndexOf ("Culture="), "FullName2#3");
 489                 Assert.AreEqual (-1, an.FullName.IndexOf ("PublicKeyToken="), "FullName2#4");
 490         }
 491
 492         [Test]
 493         public void FullName_Version ()
 494         {
 495                 const string assemblyName = "TestAssembly";
 496                 const string assemblyVersion = "1.2";
 497
 498                 // tests for AssemblyName with name and version
 499                 an = new AssemblyName ();
 500                 an.Name = assemblyName;
 501                 an.Version = new Version (assemblyVersion);
 502                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion, an.FullName, "FullName3#1");
 503         }
 504
 505         [Test]
 506         public void FullName_Culture ()
 507         {
 508                 const string assemblyName = "TestAssembly";
 509
 510                 // tests for AssemblyName with name and neutral culture
 511                 an = new AssemblyName ();
 512                 an.Name = assemblyName;
 513                 an.CultureInfo = CultureInfo.InvariantCulture;
 514                 Assert.AreEqual (assemblyName + ", Culture=neutral", an.FullName, "#1");
 515                 an.CultureInfo = new CultureInfo ("nl-BE");
 516                 Assert.AreEqual (assemblyName + ", Culture=nl-BE", an.FullName, "#2");
 517                 an.Name = null;
 518 #if NET_2_0
 519                 Assert.AreEqual (string.Empty, an.FullName, "#3");
 520 #else
 521                 Assert.IsNull (an.FullName, "#4");
 522 #endif
 523         }
 524
 525         [Test]
 526         public void FullName_PublicKey ()
 527         {
 528                 const string assemblyName = "TestAssembly";
 529
 530                 // tests for AssemblyName with name and public key
 531                 an = new AssemblyName ();
 532                 an.Name = assemblyName;
 533                 an.SetPublicKey (publicKey1);
 534                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1");
 535                 an.SetPublicKey ((byte []) null);
 536                 Assert.AreEqual (assemblyName, an.FullName, "#A2");
 537                 an.SetPublicKey (new byte [0]);
 538                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3");
 539                 an.Name = null;
 540 #if NET_2_0
 541                 Assert.AreEqual (string.Empty, an.FullName, "#A4");
 542 #else
 543                 Assert.IsNull (an.FullName, "#A4");
 544 #endif
 545
 546                 an = new AssemblyName ();
 547                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 548                 an.Name = assemblyName;
 549                 an.SetPublicKey (publicKey1);
 550                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1");
 551                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 552 #if NET_2_0
 553                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2");
 554 #else
 555                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B2");
 556 #endif
 557                 an.SetPublicKeyToken ((byte []) null);
 558                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B3");
 559                 an.Name = null;
 560 #if NET_2_0
 561                 Assert.AreEqual (string.Empty, an.FullName, "#B4");
 562 #else
 563                 Assert.IsNull (an.FullName, "#B4");
 564 #endif
 565
 566                 an = new AssemblyName ();
 567                 an.HashAlgorithm = AssemblyHashAlgorithm.None;
 568                 an.Name = assemblyName;
 569                 an.SetPublicKey (publicKey1);
 570                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1");
 571                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 572 #if NET_2_0
 573                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#C2");
 574 #else
 575                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C2");
 576 #endif
 577                 an.SetPublicKeyToken ((byte []) null);
 578                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C3");
 579                 an.Name = null;
 580 #if NET_2_0
 581                 Assert.AreEqual (string.Empty, an.FullName, "#C4");
 582 #else
 583                 Assert.IsNull (an.FullName, "#C4");
 584 #endif
 585
 586                 an = new AssemblyName ();
 587                 an.Name = assemblyName;
 588                 an.SetPublicKey (new byte [0]);
 589                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1");
 590                 an.Name = null;
 591 #if NET_2_0
 592                 Assert.AreEqual (string.Empty, an.FullName, "#D2");
 593 #else
 594                 Assert.IsNull (an.FullName, "#D2");
 595 #endif
 596                 an.SetPublicKey (publicKey3);
 597 #if NET_2_0
 598                 Assert.AreEqual (string.Empty, an.FullName, "#D3");
 599 #else
 600                 Assert.IsNull (an.FullName, "#D3");
 601 #endif
 602                 an.Name = assemblyName;
 603                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "#D4");
 604         }
 605
 606         [Test]
 607         public void FullName_PublicKey_KeyPair ()
 608         {
 609                 const string assemblyName = "TestAssembly";
 610
 611                 // tests for AssemblyName with name and public key
 612                 an = new AssemblyName ();
 613                 an.Name = assemblyName;
 614                 an.SetPublicKey (keyPair);
 615 #if NET_2_0
 616                 try {
 617                         Assert.Fail ("#A1: " + an.FullName);
 618                 } catch (SecurityException ex) {
 619                         // Invalid assembly public key
 620                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#A2");
 621                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#A3");
 622                         Assert.IsNull (ex.InnerException, "#A4");
 623                         Assert.IsNotNull (ex.Message, "#A5");
 624                 }
 625 #else
 626                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#A1");
 627 #endif
 628
 629                 an.SetPublicKeyToken (new byte [0]);
 630 #if NET_2_0
 631                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#B1");
 632 #else
 633                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#B1");
 634 #endif
 635
 636                 an.SetPublicKeyToken ((byte []) null);
 637 #if NET_2_0
 638                 try {
 639                         Assert.Fail ("#C1: " + an.FullName);
 640                 } catch (SecurityException ex) {
 641                         // Invalid assembly public key
 642                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#C2");
 643                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#C3");
 644                         Assert.IsNull (ex.InnerException, "#C4");
 645                         Assert.IsNotNull (ex.Message, "#C5");
 646                 }
 647 #else
 648                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#C1");
 649 #endif
 650
 651                 an.SetPublicKeyToken (new byte [0]);
 652 #if NET_2_0
 653                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1");
 654 #else
 655                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (kp_token), an.FullName, "#D1");
 656 #endif
 657                 an.SetPublicKey (publicKey1);
 658 #if NET_2_0
 659                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2");
 660 #else
 661                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D2");
 662 #endif
 663                 an.SetPublicKeyToken ((byte []) null);
 664                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3");
 665         }
 666
 667         [Test]
 668         public void FullName_PublicKeyToken ()
 669         {
 670                 const string assemblyName = "TestAssembly";
 671
 672                 an = new AssemblyName ();
 673                 an.Name = assemblyName;
 674                 an.SetPublicKeyToken (pk_token1);
 675                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1");
 676                 an.SetPublicKeyToken ((byte []) null);
 677                 Assert.AreEqual (assemblyName, an.FullName, "#A2");
 678                 an.SetPublicKeyToken (new byte [0]);
 679                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3");
 680                 an.SetPublicKeyToken (pk_token1);
 681                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A4");
 682                 an.Name = null;
 683 #if NET_2_0
 684                 Assert.AreEqual (string.Empty, an.FullName, "#A5");
 685 #else
 686                 Assert.IsNull (an.FullName, "#A5");
 687 #endif
 688
 689                 an = new AssemblyName ();
 690                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 691                 an.Name = assemblyName;
 692                 an.SetPublicKeyToken (pk_token1);
 693                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1");
 694                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 695                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2");
 696                 an.SetPublicKeyToken ((byte []) null);
 697                 Assert.AreEqual (assemblyName, an.FullName, "#B3");
 698                 an.Name = null;
 699 #if NET_2_0
 700                 Assert.AreEqual (string.Empty, an.FullName, "#B4");
 701 #else
 702                 Assert.IsNull (an.FullName, "#B4");
 703 #endif
 704
 705                 an = new AssemblyName ();
 706                 an.Name = assemblyName;
 707                 an.SetPublicKey (publicKey1);
 708                 an.SetPublicKeyToken (pk_token1);
 709                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1");
 710                 an.SetPublicKey ((byte []) null);
 711 #if NET_2_0
 712                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C2");
 713 #else
 714                 Assert.AreEqual (assemblyName, an.FullName, "#C2");
 715 #endif
 716                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C3");
 717                 an.SetPublicKey (new byte [0]);
 718 #if NET_2_0
 719                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C4");
 720 #else
 721                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#C4");
 722 #endif
 723                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C5");
 724
 725                 an = new AssemblyName ();
 726                 an.Name = assemblyName;
 727                 an.SetPublicKey (publicKey1);
 728                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D1");
 729                 an.SetPublicKey (new byte [0]);
 730                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2");
 731                 an.SetPublicKeyToken (pk_token1);
 732 #if NET_2_0
 733                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3");
 734 #else
 735                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D3");
 736 #endif
 737                 an.SetPublicKey ((byte []) null);
 738 #if NET_2_0
 739                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D4");
 740 #else
 741                 Assert.AreEqual (assemblyName, an.FullName, "#D4");
 742 #endif
 743         }
 744
 745         [Test]
 746         public void FullName_VersionCulture ()
 747         {
 748                 const string assemblyName = "TestAssembly";
 749                 const string assemblyVersion = "1.2";
 750
 751                 // tests for AssemblyName with name, version and neutral culture
 752                 an = new AssemblyName ();
 753                 an.Name = assemblyName;
 754                 an.Version = new Version (assemblyVersion);
 755                 an.CultureInfo = CultureInfo.InvariantCulture;
 756                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 757                         + ", Culture=neutral", an.FullName, "#1");
 758                 an.CultureInfo = new CultureInfo ("en-US");
 759                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 760                         + ", Culture=en-US", an.FullName, "#2");
 761                 an.CultureInfo = new CultureInfo ("en");
 762                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 763                         + ", Culture=en", an.FullName, "#3");
 764         }
 765
 766         [Test]
 767         public void FullName_VersionPublicKey ()
 768         {
 769                 const string assemblyName = "TestAssembly";
 770                 const string assemblyVersion = "1.2";
 771
 772                 // tests for AssemblyName with name, version and public key
 773                 an = new AssemblyName ();
 774                 an.Name = assemblyName;
 775                 an.Version = new Version (assemblyVersion);
 776                 an.SetPublicKey (publicKey1);
 777                 an.SetPublicKeyToken (pk_token1);
 778                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 779                         + ", PublicKeyToken=" + GetTokenString (pk_token1),
 780                         an.FullName, "#1");
 781         }
 782
 783         [Test]
 784         public void FullName_CulturePublicKey ()
 785         {
 786                 const string assemblyName = "TestAssembly";
 787
 788                 // tests for AssemblyName with name, culture and public key
 789                 an = new AssemblyName ();
 790                 an.Name = assemblyName;
 791                 an.CultureInfo = CultureInfo.InvariantCulture;
 792                 an.SetPublicKey (publicKey1);
 793                 an.SetPublicKeyToken (pk_token1);
 794                 Assert.AreEqual (assemblyName + ", Culture=neutral"
 795                         + ", PublicKeyToken=" + GetTokenString (pk_token1),
 796                         an.FullName, "#1");
 797         }
 798
 799         [Test]
 800         public void GetPublicKeyToken ()
 801         {
 802                 const string assemblyName = "TestAssembly";
 803
 804                 an = new AssemblyName ();
 805                 an.SetPublicKey (publicKey1);
 806                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A1");
 807                 an.SetPublicKey (publicKey2);
 808                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A2");
 809                 an.SetPublicKeyToken (new byte [] { 0x0a });
 810                 Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A3");
 811                 an.SetPublicKey (publicKey1);
 812                 Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A4");
 813                 an.SetPublicKeyToken (new byte [0]);
 814                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A5");
 815                 an.Name = assemblyName;
 816                 an.SetPublicKey (publicKey2);
 817                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A6");
 818 #if NET_2_0
 819                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A7");
 820 #else
 821                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token2), an.FullName, "#A7");
 822 #endif
 823
 824                 an = new AssemblyName ();
 825                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 826                 an.SetPublicKey (publicKey1);
 827                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B1");
 828
 829                 an = new AssemblyName ();
 830                 an.HashAlgorithm = AssemblyHashAlgorithm.None;
 831                 an.SetPublicKey (publicKey1);
 832                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C1");
 833
 834                 an = new AssemblyName ();
 835                 an.SetPublicKeyToken (new byte [0]);
 836                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#D1");
 837                 an.SetPublicKeyToken (new byte [] { 0x0b, 0xff });
 838                 Assert.AreEqual (new byte [] { 0x0b, 0xff }, an.GetPublicKeyToken (), "#D2");
 839                 an.SetPublicKeyToken ((byte []) null);
 840                 Assert.IsNull (an.GetPublicKeyToken (), "#D3");
 841
 842                 an = new AssemblyName ();
 843                 an.SetPublicKey (keyPair);
 844 #if NET_2_0
 845                 try {
 846                         an.GetPublicKeyToken ();
 847                         Assert.Fail ("#E1");
 848                 } catch (SecurityException ex) {
 849                         // Invalid assembly public key
 850                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#E2");
 851                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#E3");
 852                         Assert.IsNull (ex.InnerException, "#E4");
 853                         Assert.IsNotNull (ex.Message, "#E5");
 854                 }
 855 #else
 856                 Assert.AreEqual (kp_token, an.GetPublicKeyToken (), "#E1");
 857 #endif
 858         }
 859
 860         [Test]
 861         public void GetPublicKeyToken_Corlib ()
 862         {
 863                 an = typeof (int).Assembly.GetName ();
 864                 Assert.IsNotNull (an.GetPublicKeyToken (), "#1");
 865                 Assert.IsTrue (an.GetPublicKeyToken ().Length > 0, "#2");
 866         }
 867
 868         [Test]
 869         public void GetPublicGetToken_Ecma ()
 870         {
 871                 const string assemblyName = "TestAssembly";
 872
 873                 an = new AssemblyName ();
 874                 an.Name = assemblyName;
 875                 an.SetPublicKey (publicKey3);
 876                 Assert.IsNotNull (an.GetPublicKeyToken (), "#1");
 877                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "#2");
 878         }
 879
 880         [Test]
 881         public void GetPublicKeyToken_Self ()
 882         {
 883                 Assembly a = Assembly.GetExecutingAssembly ();
 884                 an = a.GetName ();
 885 #if NET_2_0
 886                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken ());
 887 #else
 888                 Assert.IsNull (an.GetPublicKeyToken ());
 889 #endif
 890         }
 891
 892         static int nameIndex = 0;
 893
 894         private AssemblyName GenAssemblyName ()
 895         {
 896                 AssemblyName assemblyName = new AssemblyName();
 897                 assemblyName.Name = "MonoTests.System.Reflection.AssemblyNameTest" + (nameIndex ++);
 898                 return assemblyName;
 899         }
 900
 901 #if !TARGET_JVM && !MOBILE // Reflection.Emit is not supported for TARGET_JVM.
 902         private Assembly GenerateAssembly (AssemblyName name)
 903         {
 904                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 905                         name,
 906                         AssemblyBuilderAccess.RunAndSave,
 907                         tempDir);
 908                 ab.DefineDynamicModule ("def_module");
 909                 ab.Save (name.Name + ".dll");
 910
 911                 return Assembly.LoadFrom (Path.Combine (tempDir, name.Name + ".dll"));
 912         }
 913
 914         private AssemblyBuilder GenerateDynamicAssembly (AssemblyName name)
 915         {
 916                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 917                                 name,
 918                                 AssemblyBuilderAccess.Run);
 919
 920                 return ab;
 921         }
 922
 923         [Test]
 924         public void TestCultureInfo ()
 925         {
 926                 AssemblyName name;
 927                 Assembly a;
 928                 CultureInfo culture;
 929
 930                 name = GenAssemblyName ();
 931                 name.CultureInfo = CultureInfo.CreateSpecificCulture ("ar-DZ");
 932                 a = GenerateAssembly (name);
 933                 culture = a.GetName ().CultureInfo;
 934                 Assert.IsFalse (culture.IsNeutralCulture, "#A1");
 935                 Assert.IsFalse (culture.IsReadOnly, "#A2");
 936                 Assert.AreEqual (5121, culture.LCID, "#A3");
 937                 Assert.AreEqual ("ar-DZ", culture.Name, "#A4");
 938                 Assert.IsTrue (culture.UseUserOverride, "#A5");
 939
 940                 name = GenAssemblyName ();
 941                 name.CultureInfo = new CultureInfo ("en");
 942                 a = GenerateAssembly (name);
 943                 culture = a.GetName ().CultureInfo;
 944                 Assert.IsTrue (culture.IsNeutralCulture, "#B1");
 945                 Assert.IsFalse (culture.IsReadOnly, "#B2");
 946                 Assert.AreEqual (9, culture.LCID, "#B3");
 947                 Assert.AreEqual ("en", culture.Name, "#B4");
 948                 Assert.IsTrue (culture.UseUserOverride, "#B5");
 949
 950                 name = GenAssemblyName ();
 951                 name.CultureInfo = CultureInfo.InvariantCulture;
 952                 a = GenerateAssembly (name);
 953                 culture = a.GetName ().CultureInfo;
 954                 Assert.IsFalse (culture.IsNeutralCulture, "#C1");
 955 #if NET_2_0
 956                 Assert.IsFalse (culture.IsReadOnly, "#C2");
 957 #else
 958                 Assert.IsTrue (culture.IsReadOnly, "#C2");
 959 #endif
 960                 Assert.AreEqual (127, culture.LCID, "#C3");
 961                 Assert.AreEqual (string.Empty, culture.Name, "#C4");
 962                 Assert.IsFalse (culture.UseUserOverride, "#C5");
 963
 964                 a = typeof (int).Assembly;
 965                 name = a.GetName ();
 966                 culture = name.CultureInfo;
 967                 Assert.IsFalse (culture.IsNeutralCulture, "#D1");
 968 #if NET_2_0
 969                 Assert.IsFalse (culture.IsReadOnly, "#D2");
 970 #else
 971                 Assert.IsTrue (culture.IsReadOnly, "#D2");
 972 #endif
 973                 Assert.AreEqual (127, culture.LCID, "#D3");
 974                 Assert.AreEqual (string.Empty, culture.Name, "#D4");
 975                 Assert.IsFalse (culture.UseUserOverride, "#D5");
 976
 977                 a = Assembly.GetExecutingAssembly ();
 978                 name = a.GetName ();
 979                 culture = name.CultureInfo;
 980                 Assert.IsFalse (culture.IsNeutralCulture, "#E1");
 981 #if NET_2_0
 982                 Assert.IsFalse (culture.IsReadOnly, "#E2");
 983 #else
 984                 Assert.IsTrue (culture.IsReadOnly, "#E2");
 985 #endif
 986                 Assert.AreEqual (127, culture.LCID, "#E3");
 987                 Assert.AreEqual (string.Empty, culture.Name, "#E4");
 988                 Assert.IsFalse (culture.UseUserOverride, "#E5");
 989
 990                 AssemblyName [] names = a.GetReferencedAssemblies ();
 991                 foreach (AssemblyName an in names) {
 992                         culture = an.CultureInfo;
 993                         Assert.IsFalse (culture.IsNeutralCulture, "#F1:" + an.Name);
 994                         Assert.IsFalse (culture.IsReadOnly, "#F2:" + an.Name);
 995                         Assert.AreEqual (127, culture.LCID, "#F3:" + an.Name);
 996                         Assert.AreEqual (string.Empty, culture.Name, "#F4:" + an.Name);
 997 #if NET_2_0
 998                         Assert.IsFalse (culture.UseUserOverride, "#F5:" + an.Name);
 999 #else
1000                         Assert.IsTrue (culture.UseUserOverride, "#F5:" + an.Name);
1001 #endif
1002                 }
1003         }
1004
1005         [Test]
1006         public void Version ()
1007         {
1008                 AssemblyName name = GenAssemblyName ();
1009                 name.Version = new Version (1, 2, 3, 4);
1010
1011                 Assembly a = GenerateAssembly (name);
1012                 Assert.AreEqual ("1.2.3.4", a.GetName ().Version.ToString (), "1.2.3.4 normal");
1013
1014                 name = GenAssemblyName ();
1015                 name.Version = new Version (1, 2, 3);
1016
1017                 a = GenerateAssembly (name);
1018                 Assert.AreEqual ("1.2.3.0", a.GetName ().Version.ToString (), "1.2.3.0 normal");
1019
1020                 name = GenAssemblyName ();
1021                 name.Version = new Version (1, 2);
1022
1023                 a = GenerateAssembly (name);
1024                 Assert.AreEqual ("1.2.0.0", a.GetName ().Version.ToString (), "1.2.0.0 normal");
1025         }
1026
1027         [Test]
1028         [Category ("NotWorking")]
1029         public void Version_Dynamic ()
1030         {
1031                 AssemblyName name = GenAssemblyName ();
1032                 name.Version = new Version (1, 2, 3, 4);
1033
1034                 AssemblyBuilder ab = GenerateDynamicAssembly (name);
1035                 Assert.AreEqual ("1.2.3.4", ab.GetName ().Version.ToString (), "1.2.3.4 dynamic");
1036
1037                 name = GenAssemblyName ();
1038                 name.Version = new Version (1, 2, 3);
1039
1040                 ab = GenerateDynamicAssembly (name);
1041 #if NET_2_0
1042                 Assert.AreEqual ("1.2.3.0", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
1043 #else
1044                 Assert.AreEqual ("1.2.3.65535", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
1045 #endif
1046
1047                 name = GenAssemblyName ();
1048                 name.Version = new Version (1, 2);
1049
1050                 ab = GenerateDynamicAssembly (name);
1051 #if NET_2_0
1052                 Assert.AreEqual ("1.2.0.0", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
1053 #else
1054                 Assert.AreEqual ("1.2.65535.65535", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
1055 #endif
1056         }
1057 #endif // TARGET_JVM
1058
1059         [Test]
1060         public void HashAlgorithm ()
1061         {
1062                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1,
1063                         typeof (int).Assembly.GetName ().HashAlgorithm);
1064         }
1065
1066         [Test]
1067         public void Serialization ()
1068         {
1069                 an = new AssemblyName ();
1070                 an.CodeBase = "http://www.test.com/test.dll";
1071                 an.CultureInfo = CultureInfo.InvariantCulture;
1072                 an.Flags = AssemblyNameFlags.PublicKey;
1073                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
1074                 an.KeyPair = new StrongNameKeyPair (publicKey1);
1075                 an.Name = "TestAssembly";
1076                 an.Version = new Version (1, 5);
1077                 an.VersionCompatibility = AssemblyVersionCompatibility.SameProcess;
1078
1079                 MemoryStream ms = new MemoryStream ();
1080                 BinaryFormatter bf = new BinaryFormatter ();
1081                 bf.Serialize (ms, an);
1082
1083                 // reset position of memorystream
1084                 ms.Position = 0;
1085
1086                 // deserialze assembly name
1087                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
1088
1089                 // close the memorystream
1090                 ms.Close ();
1091
1092                 // compare orginal and deserialized assembly name
1093                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
1094                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
1095                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
1096                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
1097                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
1098                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
1099                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
1100                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
1101                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
1102                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
1103                 Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey");
1104                 Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken");
1105         }
1106
1107         [Test]
1108         public void Serialization_WithoutStrongName ()
1109         {
1110                 an = new AssemblyName ();
1111                 an.CodeBase = "http://www.test.com/test.dll";
1112                 an.CultureInfo = CultureInfo.InvariantCulture;
1113                 an.Flags = AssemblyNameFlags.None;
1114                 an.HashAlgorithm = AssemblyHashAlgorithm.SHA1;
1115                 an.KeyPair = null;
1116                 an.Name = "TestAssembly2";
1117                 an.Version = new Version (1, 5, 0, 0);
1118                 an.VersionCompatibility = AssemblyVersionCompatibility.SameMachine;
1119
1120                 MemoryStream ms = new MemoryStream ();
1121                 BinaryFormatter bf = new BinaryFormatter ();
1122                 bf.Serialize (ms, an);
1123
1124                 // reset position of memorystream
1125                 ms.Position = 0;
1126
1127                 // deserialze assembly name
1128                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
1129
1130                 // close the memorystream
1131                 ms.Close ();
1132
1133                 // compare orginal and deserialized assembly name
1134                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
1135                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
1136                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
1137                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
1138                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
1139                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
1140                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
1141                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
1142                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
1143                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
1144                 Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey");
1145                 Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken");
1146         }
1147
1148 #if !TARGET_JVM // Assemblyname.GetObjectData not implemented yet for TARGET_JVM
1149         [Test]
1150         public void GetObjectData_Info_Null ()
1151         {
1152                 an = new AssemblyName ();
1153                 try {
1154                         an.GetObjectData (null, new StreamingContext (StreamingContextStates.All));
1155                         Assert.Fail ("#1");
1156                 } catch (ArgumentNullException ex) {
1157                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1158                         Assert.IsNull (ex.InnerException, "#3");
1159                         Assert.IsNotNull (ex.Message, "#4");
1160                         Assert.IsNotNull (ex.ParamName, "#5");
1161                         Assert.AreEqual ("info", ex.ParamName, "#6");
1162                 }
1163         }
1164 #endif // TARGET_JVM
1165
1166         [Test]
1167         public void Clone_Corlib ()
1168         {
1169                 an = typeof (int).Assembly.GetName ();
1170                 AssemblyName clone = (AssemblyName) an.Clone ();
1171
1172                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
1173                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
1174                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
1175                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
1176                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
1177                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
1178                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
1179                 Assert.AreEqual (an.Name, clone.Name, "Name");
1180 #if NET_2_0
1181                 Assert.AreEqual (an.ProcessorArchitecture, clone.ProcessorArchitecture, "PA");
1182 #endif
1183                 Assert.AreEqual (an.Version, clone.Version, "Version");
1184                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
1185                 Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
1186                 Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
1187                 Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
1188         }
1189
1190         [Test]
1191         public void Clone_Empty ()
1192         {
1193                 an = new AssemblyName ();
1194                 AssemblyName clone = (AssemblyName) an.Clone ();
1195
1196                 Assert.IsNull (clone.CodeBase, "CodeBase");
1197                 Assert.IsNull (clone.CultureInfo, "CultureInfo");
1198                 Assert.IsNull (clone.EscapedCodeBase, "EscapedCodeBase");
1199                 Assert.AreEqual (AssemblyNameFlags.None, clone.Flags, "Flags");
1200 #if NET_2_0
1201                 Assert.AreEqual (String.Empty, clone.FullName, "FullName");
1202 #else
1203                 Assert.IsNull (clone.FullName, "FullName");
1204 #endif
1205                 Assert.AreEqual (AssemblyHashAlgorithm.None, clone.HashAlgorithm, "HashAlgorithm");
1206                 Assert.IsNull (clone.KeyPair, "KeyPair");
1207                 Assert.IsNull (clone.Name, "Name");
1208 #if NET_2_0
1209                 Assert.AreEqual (ProcessorArchitecture.None, clone.ProcessorArchitecture, "PA");
1210 #endif
1211                 Assert.IsNull (clone.Version, "Version");
1212                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1213                         clone.VersionCompatibility, "VersionCompatibility");
1214         }
1215
1216         [Test]
1217         public void Clone_Self ()
1218         {
1219                 an = Assembly.GetExecutingAssembly ().GetName ();
1220                 AssemblyName clone = (AssemblyName) an.Clone ();
1221
1222                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
1223                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
1224                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
1225                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
1226                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
1227                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
1228                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
1229                 Assert.AreEqual (an.Name, clone.Name, "Name");
1230 #if NET_2_0
1231                 //Assert.AreEqual (ProcessorArchitecture.MSIL, clone.ProcessorArchitecture, "PA");
1232 #endif
1233                 Assert.AreEqual (an.Version, clone.Version, "Version");
1234                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
1235                 Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
1236                 Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
1237                 Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
1238         }
1239
1240         [Test]
1241         [ExpectedException (typeof (FileNotFoundException))]
1242         public void GetAssemblyName_AssemblyFile_DoesNotExist ()
1243         {
1244                 AssemblyName.GetAssemblyName (Path.Combine (tempDir, "doesnotexist.dll"));
1245         }
1246
1247         [Test]
1248         [Category ("NotWorking")]
1249         public void GetAssemblyName_AssemblyFile_ReadLock ()
1250         {
1251                 string file = Path.Combine (tempDir, "loadfailure.dll");
1252                 using (FileStream fs = File.Open (file, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None)) {
1253                         try {
1254                                 AssemblyName.GetAssemblyName (file);
1255                                 Assert.Fail ("#1");
1256                         } catch (FileLoadException ex) {
1257                                 // Could not load file or assembly '...' or one
1258                                 // of its dependencies. The process cannot access
1259                                 // the file because it is being used by another
1260                                 // process
1261                                 Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1262                                 Assert.IsNotNull (ex.FileName, "#3");
1263 #if NET_2_0
1264                                 Assert.AreEqual (file, ex.FileName, "#4");
1265 #else
1266                                 Assert.IsTrue (ex.FileName.IndexOf ("loadfailure.dll") != -1, "#4");
1267 #endif
1268                                 Assert.IsNull (ex.InnerException, "#5");
1269                                 Assert.IsNotNull (ex.Message, "#6");
1270                         }
1271                 }
1272                 File.Delete (file);
1273         }
1274
1275         [Test]
1276         public void GetAssemblyName_AssemblyFile_BadImage ()
1277         {
1278                 string file = Path.Combine (tempDir, "badimage.dll");
1279                 using (StreamWriter sw = File.CreateText (file)) {
1280                         sw.WriteLine ("somegarbage");
1281                 }
1282                 try {
1283                         AssemblyName.GetAssemblyName (file);
1284                         Assert.Fail ("#1");
1285                 } catch (BadImageFormatException ex) {
1286                         Assert.AreEqual (typeof (BadImageFormatException), ex.GetType (), "#2");
1287                         Assert.IsNotNull (ex.FileName, "#3");
1288 #if NET_2_0
1289                         Assert.AreEqual (file, ex.FileName, "#4");
1290 #else
1291                         Assert.IsTrue (ex.FileName.IndexOf ("badimage.dll") != -1, "#4");
1292 #endif
1293                         Assert.IsNull (ex.InnerException, "#5");
1294                         Assert.IsNotNull (ex.Message, "#6");
1295                 } finally {
1296                         File.Delete (file);
1297                 }
1298         }
1299
1300         [Test]
1301         public void GetAssemblyName_CodeBase ()
1302         {
1303                 Assembly execAssembly = Assembly.GetExecutingAssembly ();
1304
1305                 AssemblyName aname = AssemblyName.GetAssemblyName (execAssembly.Location);
1306                 Assert.IsNotNull (aname.CodeBase, "#1");
1307                 Assert.AreEqual (execAssembly.CodeBase, aname.CodeBase, "#2");
1308         }
1309
1310         // helpers
1311
1312         private string GetTokenString (byte[] value)
1313         {
1314                 string tokenString = "";
1315                 for (int i = 0; i < value.Length; i++) {
1316                         tokenString += value[i].ToString ("x2");
1317                 }
1318                 return tokenString;
1319         }
1320
1321 #if NET_2_0
1322         [Test] // ctor (String)
1323         public void Constructor1_Name ()
1324         {
1325                 const string assemblyName = "TestAssembly";
1326
1327                 an = new AssemblyName (assemblyName);
1328                 Assert.IsNull (an.CodeBase, "CodeBase");
1329                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1330                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1331                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1332                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1333                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1334                 Assert.IsNull (an.KeyPair, "KeyPair");
1335                 Assert.AreEqual (assemblyName, an.Name, "Name");
1336                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1337                 Assert.IsNull (an.Version, "Version");
1338                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1339                         an.VersionCompatibility, "VersionCompatibility");
1340                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1341                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1342                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1343         }
1344
1345         [Test] // ctor (String)
1346         [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM.
1347         public void Constructor1_Full ()
1348         {
1349                 const string assemblyName = "TestAssembly";
1350                 const string assemblyCulture = "neutral";
1351                 const string assemblyVersion = "1.2.3.4";
1352
1353                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion +
1354                                 ", Culture=" + assemblyCulture + ", PublicKeyToken=" + GetTokenString (pk_token1) + ",ProcessorArchitecture=X86");
1355                 Assert.IsNull (an.CodeBase, "CodeBase");
1356                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo");
1357                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1358                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1359                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4, Culture=neutral, PublicKeyToken=" +
1360                         GetTokenString (pk_token1), an.FullName, "FullName");
1361                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1362                 Assert.IsNull (an.KeyPair, "KeyPair");
1363                 Assert.AreEqual (assemblyName, an.Name, "Name");
1364                 Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA");
1365                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1366                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1367                         an.VersionCompatibility, "VersionCompatibility");
1368                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1369                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1370                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1371         }
1372
1373         [Test] // ctor (String)
1374         public void Constructor1_AssemblyName_Empty ()
1375         {
1376                 try {
1377                         new AssemblyName (string.Empty);
1378                         Assert.Fail ("#1");
1379                 } catch (ArgumentException ex) {
1380                         // String cannot have zero length
1381                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1382                         Assert.IsNull (ex.InnerException, "#3");
1383                         Assert.IsNotNull (ex.Message, "#4");
1384                         Assert.IsNull (ex.ParamName, "#5");
1385                 }
1386         }
1387
1388         [Test] // ctor (String)
1389         public void Constructor1_AssemblyName_Invalid ()
1390         {
1391                 const string assemblyName = "TestAssembly";
1392
1393                 try {
1394                         new AssemblyName (assemblyName + ", =1.2.4.5");
1395                         Assert.Fail ("#A1");
1396                 } catch (FileLoadException ex) {
1397                         // The given assembly name or codebase was invalid
1398                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1399                         Assert.IsNull (ex.FileName, "#3");
1400                         Assert.IsNull (ex.InnerException, "#3");
1401                         Assert.IsNotNull (ex.Message, "#4");
1402                 }
1403
1404                 try {
1405                         new AssemblyName (assemblyName + ", OtherAttribute");
1406                         Assert.Fail ("#B1");
1407                 } catch (FileLoadException ex) {
1408                         // The given assembly name or codebase was invalid
1409                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1410                         Assert.IsNull (ex.FileName, "#3");
1411                         Assert.IsNull (ex.InnerException, "#3");
1412                         Assert.IsNotNull (ex.Message, "#4");
1413                 }
1414         }
1415
1416         [Test] // ctor (String)
1417         public void Constructor1_AssemblyName_Null ()
1418         {
1419                 try {
1420                         new AssemblyName (null);
1421                         Assert.Fail ("#1");
1422                 } catch (ArgumentNullException ex) {
1423                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1424                         Assert.IsNull (ex.InnerException, "#3");
1425                         Assert.IsNotNull (ex.Message, "#4");
1426                         Assert.IsNotNull (ex.ParamName, "#5");
1427                         Assert.AreEqual ("assemblyName", ex.ParamName, "#6");
1428                 }
1429         }
1430
1431         [Test] // ctor (String)
1432         public void Constructor1_Culture ()
1433         {
1434                 const string assemblyName = "TestAssembly";
1435                 const string assemblyCulture = "en-US";
1436
1437                 an = new AssemblyName (assemblyName + ", Culture=" + assemblyCulture);
1438                 Assert.IsNull (an.CodeBase, "CodeBase");
1439                 Assert.AreEqual (new CultureInfo (assemblyCulture), an.CultureInfo, "CultureInfo");
1440                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1441                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1442                 Assert.AreEqual ("TestAssembly, Culture=en-US", an.FullName, "FullName");
1443                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1444                 Assert.IsNull (an.KeyPair, "KeyPair");
1445                 Assert.AreEqual (assemblyName, an.Name, "Name");
1446                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1447                 Assert.IsNull (an.Version, "Version");
1448                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1449                         an.VersionCompatibility, "VersionCompatibility");
1450                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1451                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1452                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1453         }
1454
1455         [Test] // ctor (String)
1456         public void Constructor1_Culture_Incomplete ()
1457         {
1458                 const string assemblyName = "TestAssembly";
1459
1460                 try {
1461                         new AssemblyName (assemblyName + ", Culture=");
1462                         Assert.Fail ("#1");
1463                 } catch (FileLoadException ex) {
1464                         // The given assembly name or codebase was invalid
1465                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1466                         Assert.IsNull (ex.FileName, "#3");
1467                         Assert.IsNull (ex.InnerException, "#3");
1468                         Assert.IsNotNull (ex.Message, "#4");
1469                 }
1470         }
1471
1472         [Test] // ctor (String)
1473         public void Constructor1_Culture_NotSupported ()
1474         {
1475                 const string assemblyName = "TestAssembly";
1476
1477                 try {
1478                         new AssemblyName (assemblyName + ", Culture=aa-AA");
1479                         Assert.Fail ("#1");
1480 #if NET_4_0
1481                 } catch (CultureNotFoundException ex) {
1482                 }
1483 #else
1484                 } catch (ArgumentException ex) {
1485                         // Culture name 'aa-aa' is not supported
1486                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1487                         Assert.IsNull (ex.InnerException, "#3");
1488                         Assert.IsNotNull (ex.Message, "#4");
1489                         Assert.IsNotNull (ex.ParamName, "#5");
1490                         Assert.AreEqual ("name", ex.ParamName, "#6");
1491                 }
1492 #endif
1493         }
1494
1495         [Test] // ctor (String)
1496         [Category ("NotWorking")] // bug #351708
1497         public void Constructor1_ProcessorArchitecture ()
1498         {
1499                 const string assemblyName = "TestAssembly";
1500
1501                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=X86");
1502                 Assert.IsNull (an.CodeBase, "CodeBase");
1503                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1504                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1505                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1506                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1507                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1508                 Assert.IsNull (an.KeyPair, "KeyPair");
1509                 Assert.AreEqual (assemblyName, an.Name, "Name");
1510                 Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA");
1511                 Assert.IsNull (an.Version, "Version");
1512                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1513                         an.VersionCompatibility, "VersionCompatibility");
1514                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1515                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1516                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1517
1518                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=mSiL");
1519                 Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "PA: MSIL");
1520
1521                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=AmD64");
1522                 Assert.AreEqual (ProcessorArchitecture.Amd64, an.ProcessorArchitecture, "PA: Amd64");
1523
1524                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=iA64");
1525                 Assert.AreEqual (ProcessorArchitecture.IA64, an.ProcessorArchitecture, "PA: IA64");
1526         }
1527
1528         [Test] // ctor (String)
1529         [Category ("NotWorking")] // bug #351708
1530         public void Constructor1_ProcessorArchitecture_Incomplete ()
1531         {
1532                 const string assemblyName = "TestAssembly";
1533                 try {
1534                         new AssemblyName (assemblyName + ", ProcessorArchitecture=");
1535                         Assert.Fail ("#1");
1536                 } catch (FileLoadException ex) {
1537                         // The given assembly name or codebase was invalid
1538                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1539                         Assert.IsNull (ex.FileName, "#3");
1540                         Assert.IsNull (ex.InnerException, "#3");
1541                         Assert.IsNotNull (ex.Message, "#4");
1542                 }
1543         }
1544
1545         [Test] // ctor (String)
1546         [Category ("NotWorking")] // bug #351708
1547         public void Constructor1_ProcessorArchitecture_Invalid ()
1548         {
1549                 const string assemblyName = "TestAssembly";
1550                 try {
1551                         new AssemblyName (assemblyName + ", ProcessorArchitecture=XXX");
1552                         Assert.Fail ("#A1");
1553                 } catch (FileLoadException ex) {
1554                         // The given assembly name or codebase was invalid
1555                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1556                         Assert.IsNull (ex.FileName, "#A3");
1557                         Assert.IsNull (ex.InnerException, "#A4");
1558                         Assert.IsNotNull (ex.Message, "#A5");
1559                 }
1560
1561                 try {
1562                         new AssemblyName (assemblyName + ", ProcessorArchitecture=None");
1563                         Assert.Fail ("#B1");
1564                 } catch (FileLoadException ex) {
1565                         // The given assembly name or codebase was invalid
1566                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1567                         Assert.IsNull (ex.FileName, "#B3");
1568                         Assert.IsNull (ex.InnerException, "#B4");
1569                         Assert.IsNotNull (ex.Message, "#B5");
1570                 }
1571         }
1572
1573         [Test] // ctor (String)
1574         [Category ("NotDotNet")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1575         public void Constructor1_PublicKey_Mono ()
1576         {
1577                 const string assemblyName = "TestAssembly";
1578
1579                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1580                 Assert.IsNull (an.CodeBase, "CodeBase");
1581                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1582                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1583                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags");
1584                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1585                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1586                 Assert.IsNull (an.KeyPair, "KeyPair");
1587                 Assert.AreEqual (assemblyName, an.Name, "Name");
1588                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1589                 Assert.IsNull (an.Version, "Version");
1590                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1591                         an.VersionCompatibility, "VersionCompatibility");
1592                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "GetPublicKey");
1593                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1594                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1595         }
1596
1597         [Test]
1598         [Category ("NotWorking")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1599         public void Constructor1_PublicKey_MS ()
1600         {
1601                 const string assemblyName = "TestAssembly";
1602
1603                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1604                 Assert.IsNull (an.CodeBase, "CodeBase");
1605                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1606                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1607                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1608                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1609                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1610                 Assert.IsNull (an.KeyPair, "KeyPair");
1611                 Assert.AreEqual (assemblyName, an.Name, "Name");
1612                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1613                 Assert.IsNull (an.Version, "Version");
1614                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1615                         an.VersionCompatibility, "VersionCompatibility");
1616                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1617                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1618                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1619         }
1620
1621         [Test] // ctor (String)
1622         [Category ("NotWorking")] // bug #351725
1623         public void Constructor1_PublicKey_Ecma ()
1624         {
1625                 const string assemblyName = "TestAssembly";
1626
1627                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey3));
1628                 Assert.IsNull (an.CodeBase, "CodeBase");
1629                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1630                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1631                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1632                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "FullName");
1633                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1634                 Assert.IsNull (an.KeyPair, "KeyPair");
1635                 Assert.AreEqual (assemblyName, an.Name, "Name");
1636                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1637                 Assert.IsNull (an.Version, "Version");
1638                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1639                         an.VersionCompatibility, "VersionCompatibility");
1640                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1641                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "GetPublicKeyToken");
1642                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1643         }
1644
1645         [Test] // ctor (String)
1646         public void Constructor1_PublicKey_Incomplete ()
1647         {
1648                 const string assemblyName = "TestAssembly";
1649
1650                 try {
1651                         new AssemblyName (assemblyName + ", PublicKey=");
1652                         Assert.Fail ("#1");
1653                 } catch (FileLoadException ex) {
1654                         // The given assembly name or codebase was invalid
1655                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1656                         Assert.IsNull (ex.FileName, "#3");
1657                         Assert.IsNull (ex.InnerException, "#3");
1658                         Assert.IsNotNull (ex.Message, "#4");
1659                 }
1660         }
1661
1662         [Test] // ctor (String)
1663         public void Constructor1_PublicKey_Invalid ()
1664         {
1665                 const string assemblyName = "TestAssembly";
1666
1667                 try {
1668                         new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e");
1669                         Assert.Fail ("#A1");
1670                 } catch (FileLoadException ex) {
1671                         // The given assembly name or codebase was invalid
1672                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1673                         Assert.IsNull (ex.FileName, "#A3");
1674                         Assert.IsNull (ex.InnerException, "#A4");
1675                         Assert.IsNotNull (ex.Message, "#A5");
1676                 }
1677
1678                 try {
1679                         new AssemblyName (assemblyName + ", PublicKey=null");
1680                         Assert.Fail ("#B1");
1681                 } catch (FileLoadException ex) {
1682                         // The given assembly name or codebase was invalid
1683                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1684                         Assert.IsNull (ex.FileName, "#B3");
1685                         Assert.IsNull (ex.InnerException, "#B4");
1686                         Assert.IsNotNull (ex.Message, "#B5");
1687                 }
1688         }
1689
1690         [Test] // ctor (String)
1691         [Category ("NotWorking")] // bug #351756
1692         public void Constructor1_PublicKey_KeyPair ()
1693         {
1694                 const string assemblyName = "TestAssembly";
1695
1696                 try {
1697                         new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (keyPair));
1698                         Assert.Fail ("#1");
1699                 } catch (SecurityException ex) {
1700                         // Invalid assembly public key
1701                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#2");
1702                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#3");
1703                         Assert.IsNull (ex.InnerException, "#4");
1704                         Assert.IsNotNull (ex.Message, "#5");
1705                 }
1706         }
1707
1708         [Test] // ctor (String)
1709         public void Constructor1_PublicKeyToken ()
1710         {
1711                 const string assemblyName = "TestAssembly";
1712
1713                 an = new AssemblyName (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1));
1714                 Assert.IsNull (an.CodeBase, "#A:CodeBase");
1715                 Assert.IsNull (an.CultureInfo, "#A:CultureInfo");
1716                 Assert.IsNull (an.EscapedCodeBase, "#A:EscapedCodeBase");
1717                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A:Flags");
1718                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A:FullName");
1719                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#A:HashAlgorithm");
1720                 Assert.IsNull (an.KeyPair, "#A:KeyPair");
1721                 Assert.AreEqual (assemblyName, an.Name, "#A:Name");
1722                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#A:PA");
1723                 Assert.IsNull (an.Version, "#A:Version");
1724                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1725                         an.VersionCompatibility, "#A:VersionCompatibility");
1726                 Assert.IsNull (an.GetPublicKey (), "#A:GetPublicKey");
1727                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A:GetPublicKeyToken");
1728                 Assert.AreEqual (an.FullName, an.ToString (), "#A:ToString");
1729
1730                 an = new AssemblyName (assemblyName + ", PublicKeyToken=null");
1731                 Assert.IsNull (an.CodeBase, "#B:CodeBase");
1732                 Assert.IsNull (an.CultureInfo, "#B:CultureInfo");
1733                 Assert.IsNull (an.EscapedCodeBase, "#B:EscapedCodeBase");
1734                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B:Flags");
1735                 //Assert.AreEqual ("TestAssembly, PublicKeyToken=null", an.FullName, "#B:FullName");
1736                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#B:HashAlgorithm");
1737                 Assert.IsNull (an.KeyPair, "#B:KeyPair");
1738                 Assert.AreEqual (assemblyName, an.Name, "#B:Name");
1739                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#B:PA");
1740                 Assert.IsNull (an.Version, "#B:Version");
1741                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1742                         an.VersionCompatibility, "#B:VersionCompatibility");
1743                 Assert.IsNull (an.GetPublicKey (), "#B:GetPublicKey");
1744                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#B:GetPublicKeyToken");
1745                 Assert.AreEqual (an.FullName, an.ToString (), "#B:ToString");
1746         }
1747
1748         [Test] // ctor (String)
1749         public void Constructor1_PublicKeyToken_Incomplete ()
1750         {
1751                 const string assemblyName = "TestAssembly";
1752
1753                 try {
1754                         new AssemblyName (assemblyName + ", PublicKeyToken=");
1755                         Assert.Fail ("#1");
1756                 } catch (FileLoadException ex) {
1757                         // The given assembly name or codebase was invalid
1758                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1759                         Assert.IsNull (ex.FileName, "#3");
1760                         Assert.IsNull (ex.InnerException, "#3");
1761                         Assert.IsNotNull (ex.Message, "#4");
1762                 }
1763         }
1764
1765         [Test] // ctor (String)
1766         public void Constructor1_PublicKeyToken_Invalid ()
1767         {
1768                 const string assemblyName = "TestAssembly";
1769
1770                 try {
1771                         new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188");
1772                         Assert.Fail ("#1");
1773                 } catch (FileLoadException ex) {
1774                         // The given assembly name or codebase was invalid
1775                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1776                         Assert.IsNull (ex.FileName, "#3");
1777                         Assert.IsNull (ex.InnerException, "#3");
1778                         Assert.IsNotNull (ex.Message, "#4");
1779                 }
1780         }
1781
1782         [Test] // ctor (String)
1783         public void Constructor1_Retargetable ()
1784         {
1785                 const string assemblyName = "TestAssembly";
1786
1787                 try {
1788                         new AssemblyName (assemblyName + ", Retargetable=Yes");
1789                         Assert.Fail ("#A1");
1790                 } catch (FileLoadException ex) {
1791                         // The given assembly name or codebase was invalid
1792                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1793                         Assert.IsNull (ex.FileName, "#A3");
1794                         Assert.IsNull (ex.InnerException, "#A4");
1795                         Assert.IsNotNull (ex.Message, "#A5");
1796                 }
1797
1798                 try {
1799                         new AssemblyName (assemblyName + ", Retargetable=No");
1800                         Assert.Fail ("#B1");
1801                 } catch (FileLoadException ex) {
1802                         // The given assembly name or codebase was invalid
1803                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1804                         Assert.IsNull (ex.FileName, "#B3");
1805                         Assert.IsNull (ex.InnerException, "#B4");
1806                         Assert.IsNotNull (ex.Message, "#B5");
1807                 }
1808
1809                 try {
1810                         new AssemblyName (assemblyName + ", Version=1.0.0.0, Retargetable=Yes");
1811                         Assert.Fail ("#C1");
1812                 } catch (FileLoadException ex) {
1813                         // The given assembly name or codebase was invalid
1814                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2");
1815                         Assert.IsNull (ex.FileName, "#C3");
1816                         Assert.IsNull (ex.InnerException, "#C4");
1817                         Assert.IsNotNull (ex.Message, "#C5");
1818                 }
1819
1820                 try {
1821                         new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, Retargetable=Yes");
1822                         Assert.Fail ("#D1");
1823                 } catch (FileLoadException ex) {
1824                         // The given assembly name or codebase was invalid
1825                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#D2");
1826                         Assert.IsNull (ex.FileName, "#D3");
1827                         Assert.IsNull (ex.InnerException, "#D4");
1828                         Assert.IsNotNull (ex.Message, "#D5");
1829                 }
1830
1831                 try {
1832                         new AssemblyName (assemblyName + ", Version=1.0.0.0, PublicKeyToken=null, Retargetable=Yes");
1833                         Assert.Fail ("#E1");
1834                 } catch (FileLoadException ex) {
1835                         // The given assembly name or codebase was invalid
1836                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#E2");
1837                         Assert.IsNull (ex.FileName, "#E3");
1838                         Assert.IsNull (ex.InnerException, "#E4");
1839                         Assert.IsNotNull (ex.Message, "#E5");
1840                 }
1841
1842                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=yEs");
1843                 Assert.IsNull (an.CodeBase, "F:CodeBase");
1844                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#F:CultureInfo");
1845                 Assert.IsNull (an.EscapedCodeBase, "#F:EscapedCodeBase");
1846                 Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#F:Flags");
1847                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=Yes", an.FullName, "#F:FullName");
1848                 Assert.IsNull (an.GetPublicKey (), "#F:GetPublicKey");
1849                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#F:GetPublicKeyToken");
1850                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#F:HashAlgorithm");
1851                 Assert.IsNull (an.KeyPair, "#F:KeyPair");
1852                 Assert.AreEqual (assemblyName, an.Name, "#F:Name");
1853                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#F:PA");
1854                 Assert.AreEqual (an.FullName, an.ToString (), "#F:ToString");
1855                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#F:Version");
1856                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1857                         an.VersionCompatibility, "#F:VersionCompatibility");
1858
1859                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=nO");
1860                 Assert.IsNull (an.CodeBase, "G:CodeBase");
1861                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#G:CultureInfo");
1862                 Assert.IsNull (an.EscapedCodeBase, "#G:EscapedCodeBase");
1863                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#G:Flags");
1864                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", an.FullName, "#G:FullName");
1865                 Assert.IsNull (an.GetPublicKey (), "#G:GetPublicKey");
1866                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#G:GetPublicKeyToken");
1867                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#G:HashAlgorithm");
1868                 Assert.IsNull (an.KeyPair, "#G:KeyPair");
1869                 Assert.AreEqual (assemblyName, an.Name, "#G:Name");
1870                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#G:PA");
1871                 Assert.AreEqual (an.FullName, an.ToString (), "#G:ToString");
1872                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#G:Version");
1873                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1874                         an.VersionCompatibility, "#G:VersionCompatibility");
1875
1876                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=yes");
1877                 Assert.IsNull (an.CodeBase, "H:CodeBase");
1878                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#H:CultureInfo");
1879                 Assert.IsNull (an.EscapedCodeBase, "#H:EscapedCodeBase");
1880                 Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#H:Flags");
1881                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=Yes", an.FullName, "#H:FullName");
1882                 Assert.IsNull (an.GetPublicKey (), "#H:GetPublicKey");
1883                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#H:GetPublicKeyToken");
1884                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#H:HashAlgorithm");
1885                 Assert.IsNull (an.KeyPair, "#H:KeyPair");
1886                 Assert.AreEqual (assemblyName, an.Name, "#H:Name");
1887                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#H:PA");
1888                 Assert.AreEqual (an.FullName, an.ToString (), "#H:ToString");
1889                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#H:Version");
1890                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1891                         an.VersionCompatibility, "#H:VersionCompatibility");
1892         }
1893
1894         [Test] // ctor (String)
1895         public void Constructor1_Retargetable_Incomplete ()
1896         {
1897                 const string assemblyName = "TestAssembly";
1898
1899                 try {
1900                         new AssemblyName (assemblyName + ", Retargetable=");
1901                         Assert.Fail ("#1");
1902                 } catch (FileLoadException ex) {
1903                         // The given assembly name or codebase was invalid
1904                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1905                         Assert.IsNull (ex.FileName, "#3");
1906                         Assert.IsNull (ex.InnerException, "#4");
1907                         Assert.IsNotNull (ex.Message, "#5");
1908                 }
1909         }
1910
1911         [Test] // ctor (String)
1912         public void Constructor1_Retargetable_Invalid ()
1913         {
1914                 const string assemblyName = "TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
1915
1916                 try {
1917                         new AssemblyName (assemblyName + ", Retargetable=False");
1918                         Assert.Fail ("#A1");
1919                 } catch (FileLoadException ex) {
1920                         // The given assembly name or codebase was invalid
1921                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1922                         Assert.IsNull (ex.FileName, "#A3");
1923                         Assert.IsNull (ex.InnerException, "#A4");
1924                         Assert.IsNotNull (ex.Message, "#A5");
1925                 }
1926
1927                 try {
1928                         new AssemblyName (assemblyName + ", Retargetable=1");
1929                         Assert.Fail ("#B1");
1930                 } catch (FileLoadException ex) {
1931                         // The given assembly name or codebase was invalid
1932                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1933                         Assert.IsNull (ex.FileName, "#B3");
1934                         Assert.IsNull (ex.InnerException, "#B4");
1935                         Assert.IsNotNull (ex.Message, "#B5");
1936                 }
1937
1938                 try {
1939                         new AssemblyName (assemblyName + ", Retargetable=True");
1940                         Assert.Fail ("#C1");
1941                 } catch (FileLoadException ex) {
1942                         // The given assembly name or codebase was invalid
1943                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2");
1944                         Assert.IsNull (ex.FileName, "#C3");
1945                         Assert.IsNull (ex.InnerException, "#C4");
1946                         Assert.IsNotNull (ex.Message, "#C5");
1947                 }
1948         }
1949
1950         [Test] // ctor (String)
1951         [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM.
1952         public void Constructor1_Version ()
1953         {
1954                 const string assemblyName = "TestAssembly";
1955                 const string assemblyVersion = "1.2.3.4";
1956
1957                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion);
1958                 Assert.IsNull (an.CodeBase, "CodeBase");
1959                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1960                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1961                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1962                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4", an.FullName, "FullName");
1963                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1964                 Assert.IsNull (an.KeyPair, "KeyPair");
1965                 Assert.AreEqual (assemblyName, an.Name, "Name");
1966                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1967                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1968                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1969                         an.VersionCompatibility, "VersionCompatibility");
1970                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1971                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1972                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1973         }
1974
1975
1976         [Test] // ctor (String)
1977         public void Constructor1_Version_Incomplete ()
1978         {
1979                 const string assemblyName = "TestAssembly";
1980
1981                 try {
1982                         new AssemblyName (assemblyName + ", Version=, Culture=neutral");
1983                         Assert.Fail ("#1");
1984                 } catch (FileLoadException ex) {
1985                         // The given assembly name or codebase was invalid
1986                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1987                         Assert.IsNull (ex.FileName, "#3");
1988                         Assert.IsNull (ex.InnerException, "#3");
1989                         Assert.IsNotNull (ex.Message, "#4");
1990                 }
1991         }
1992
1993         [Test] // ctor (String)
1994         public void Constructor1_Version_Invalid ()
1995         {
1996                 const string assemblyName = "TestAssembly";
1997
1998                 try {
1999                         new AssemblyName (assemblyName + ", Version=a.b");
2000                         Assert.Fail ("#1");
2001                 } catch (FileLoadException ex) {
2002                         // The given assembly name or codebase was invalid
2003                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
2004                         Assert.IsNull (ex.FileName, "#3");
2005                         Assert.IsNull (ex.InnerException, "#3");
2006                         Assert.IsNotNull (ex.Message, "#4");
2007                 }
2008         }
2009
2010         [Test (Description="Xamarin bug #99 - whitespaces in key=value")]
2011         public void WhiteSpaceInKeyValue ()
2012         {
2013                 string nameWithSpaces = String.Format ("MySql.Data.Tests, PublicKey      = \t  {0},  Culture   =\tneutral, Version=\t1.2.3.4", GetTokenString (publicKey1));
2014                 string fullName = "MySql.Data.Tests, Version=1.2.3.4, Culture=neutral, PublicKeyToken=ce5276d8687ec6dc";
2015                 var an = new AssemblyName (nameWithSpaces);
2016
2017                 Assert.AreEqual (fullName, an.FullName);
2018         }
2019 #endif
2020 }
2021
2022 }