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

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