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