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

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