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         [Category ("StaticLinkedAotNotWorking")] // Can't find .dll files when bundled in .exe
1115         public void GetAssemblyName_CodeBase ()
1116         {
1117                 Assembly execAssembly = Assembly.GetExecutingAssembly ();
1118
1119                 AssemblyName aname = AssemblyName.GetAssemblyName (execAssembly.Location);
1120                 Assert.IsNotNull (aname.CodeBase, "#1");
1121                 Assert.AreEqual (execAssembly.CodeBase, aname.CodeBase, "#2");
1122         }
1123
1124         // helpers
1125
1126         private string GetTokenString (byte[] value)
1127         {
1128                 string tokenString = "";
1129                 for (int i = 0; i < value.Length; i++) {
1130                         tokenString += value[i].ToString ("x2");
1131                 }
1132                 return tokenString;
1133         }
1134
1135         [Test] // ctor (String)
1136         public void Constructor1_Name ()
1137         {
1138                 const string assemblyName = "TestAssembly";
1139
1140                 an = new AssemblyName (assemblyName);
1141                 Assert.IsNull (an.CodeBase, "CodeBase");
1142                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1143                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1144                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1145                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1146                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1147                 Assert.IsNull (an.KeyPair, "KeyPair");
1148                 Assert.AreEqual (assemblyName, an.Name, "Name");
1149                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1150                 Assert.IsNull (an.Version, "Version");
1151                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1152                         an.VersionCompatibility, "VersionCompatibility");
1153                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1154                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1155                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1156                 Assert.IsNull (an.CultureName, "CultureName");
1157                 Assert.AreEqual (AssemblyContentType.Default, an.ContentType, "ContentType");
1158         }
1159
1160         [Test] // ctor (String)
1161         public void Constructor1_Full ()
1162         {
1163                 const string assemblyName = "TestAssembly";
1164                 const string assemblyCulture = "neutral";
1165                 const string assemblyVersion = "1.2.3.4";
1166
1167                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion +
1168                                 ", Culture=" + assemblyCulture + ", PublicKeyToken=" + GetTokenString (pk_token1) + ",ProcessorArchitecture=X86");
1169                 Assert.IsNull (an.CodeBase, "CodeBase");
1170                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo");
1171                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1172                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1173                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4, Culture=neutral, PublicKeyToken=" +
1174                         GetTokenString (pk_token1), an.FullName, "FullName");
1175                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1176                 Assert.IsNull (an.KeyPair, "KeyPair");
1177                 Assert.AreEqual (assemblyName, an.Name, "Name");
1178                 Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA");
1179                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1180                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1181                         an.VersionCompatibility, "VersionCompatibility");
1182                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1183                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1184                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1185         }
1186
1187         [Test] // ctor (String)
1188         public void Constructor1_AssemblyName_Empty ()
1189         {
1190                 try {
1191                         new AssemblyName (string.Empty);
1192                         Assert.Fail ("#1");
1193                 } catch (ArgumentException ex) {
1194                         // String cannot have zero length
1195                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1196                         Assert.IsNull (ex.InnerException, "#3");
1197                         Assert.IsNotNull (ex.Message, "#4");
1198                         Assert.IsNull (ex.ParamName, "#5");
1199                 }
1200         }
1201
1202         [Test] // ctor (String)
1203         public void Constructor1_AssemblyName_Invalid ()
1204         {
1205                 const string assemblyName = "TestAssembly";
1206
1207                 try {
1208                         new AssemblyName (assemblyName + ", =1.2.4.5");
1209                         Assert.Fail ("#A1");
1210                 } catch (FileLoadException ex) {
1211                         // The given assembly name or codebase was invalid
1212                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1213                         Assert.IsNull (ex.FileName, "#3");
1214                         Assert.IsNull (ex.InnerException, "#3");
1215                         Assert.IsNotNull (ex.Message, "#4");
1216                 }
1217
1218                 try {
1219                         new AssemblyName (assemblyName + ", OtherAttribute");
1220                         Assert.Fail ("#B1");
1221                 } catch (FileLoadException ex) {
1222                         // The given assembly name or codebase was invalid
1223                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1224                         Assert.IsNull (ex.FileName, "#3");
1225                         Assert.IsNull (ex.InnerException, "#3");
1226                         Assert.IsNotNull (ex.Message, "#4");
1227                 }
1228         }
1229
1230         [Test] // ctor (String)
1231         public void Constructor1_AssemblyName_Null ()
1232         {
1233                 try {
1234                         new AssemblyName (null);
1235                         Assert.Fail ("#1");
1236                 } catch (ArgumentNullException ex) {
1237                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1238                         Assert.IsNull (ex.InnerException, "#3");
1239                         Assert.IsNotNull (ex.Message, "#4");
1240                         Assert.IsNotNull (ex.ParamName, "#5");
1241                         Assert.AreEqual ("assemblyName", ex.ParamName, "#6");
1242                 }
1243         }
1244
1245         [Test] // ctor (String)
1246         public void Constructor1_Culture ()
1247         {
1248                 const string assemblyName = "TestAssembly";
1249                 const string assemblyCulture = "en-US";
1250
1251                 an = new AssemblyName (assemblyName + ", Culture=" + assemblyCulture);
1252                 Assert.IsNull (an.CodeBase, "CodeBase");
1253                 Assert.AreEqual (new CultureInfo (assemblyCulture), an.CultureInfo, "CultureInfo");
1254                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1255                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1256                 Assert.AreEqual ("TestAssembly, Culture=en-US", an.FullName, "FullName");
1257                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1258                 Assert.IsNull (an.KeyPair, "KeyPair");
1259                 Assert.AreEqual (assemblyName, an.Name, "Name");
1260                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1261                 Assert.IsNull (an.Version, "Version");
1262                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1263                         an.VersionCompatibility, "VersionCompatibility");
1264                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1265                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1266                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1267         }
1268
1269         [Test] // ctor (String)
1270         public void Constructor1_Culture_Incomplete ()
1271         {
1272                 const string assemblyName = "TestAssembly";
1273
1274                 try {
1275                         new AssemblyName (assemblyName + ", Culture=");
1276                         Assert.Fail ("#1");
1277                 } catch (FileLoadException ex) {
1278                         // The given assembly name or codebase was invalid
1279                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1280                         Assert.IsNull (ex.FileName, "#3");
1281                         Assert.IsNull (ex.InnerException, "#3");
1282                         Assert.IsNotNull (ex.Message, "#4");
1283                 }
1284         }
1285
1286         [Test] // ctor (String)
1287         public void Constructor1_Culture_NotSupported ()
1288         {
1289                 const string assemblyName = "TestAssembly";
1290
1291                 try {
1292                         new AssemblyName (assemblyName + ", Culture=aa-AA");
1293                         Assert.Fail ("#1");
1294                 } catch (CultureNotFoundException ex) {
1295                 }
1296         }
1297
1298         [Test] // ctor (String)
1299         public void Constructor1_ProcessorArchitecture ()
1300         {
1301                 const string assemblyName = "TestAssembly";
1302
1303                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=X86");
1304                 Assert.IsNull (an.CodeBase, "CodeBase");
1305                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1306                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1307                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1308                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1309                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1310                 Assert.IsNull (an.KeyPair, "KeyPair");
1311                 Assert.AreEqual (assemblyName, an.Name, "Name");
1312                 Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA");
1313                 Assert.IsNull (an.Version, "Version");
1314                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1315                         an.VersionCompatibility, "VersionCompatibility");
1316                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1317                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1318                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1319
1320                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=mSiL");
1321                 Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "PA: MSIL");
1322
1323                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=AmD64");
1324                 Assert.AreEqual (ProcessorArchitecture.Amd64, an.ProcessorArchitecture, "PA: Amd64");
1325
1326                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=iA64");
1327                 Assert.AreEqual (ProcessorArchitecture.IA64, an.ProcessorArchitecture, "PA: IA64");
1328         }
1329
1330         [Test] // ctor (String)
1331         public void Constructor1_ProcessorArchitecture_Incomplete ()
1332         {
1333                 const string assemblyName = "TestAssembly";
1334                 try {
1335                         new AssemblyName (assemblyName + ", ProcessorArchitecture=");
1336                         Assert.Fail ("#1");
1337                 } catch (FileLoadException ex) {
1338                         // The given assembly name or codebase was invalid
1339                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1340                         Assert.IsNull (ex.FileName, "#3");
1341                         Assert.IsNull (ex.InnerException, "#3");
1342                         Assert.IsNotNull (ex.Message, "#4");
1343                 }
1344         }
1345
1346         [Test] // ctor (String)
1347         public void Constructor1_ProcessorArchitecture_Invalid ()
1348         {
1349                 const string assemblyName = "TestAssembly";
1350                 try {
1351                         new AssemblyName (assemblyName + ", ProcessorArchitecture=XXX");
1352                         Assert.Fail ("#A1");
1353                 } catch (FileLoadException ex) {
1354                         // The given assembly name or codebase was invalid
1355                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1356                         Assert.IsNull (ex.FileName, "#A3");
1357                         Assert.IsNull (ex.InnerException, "#A4");
1358                         Assert.IsNotNull (ex.Message, "#A5");
1359                 }
1360
1361                 try {
1362                         new AssemblyName (assemblyName + ", ProcessorArchitecture=None");
1363                         Assert.Fail ("#B1");
1364                 } catch (FileLoadException ex) {
1365                         // The given assembly name or codebase was invalid
1366                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1367                         Assert.IsNull (ex.FileName, "#B3");
1368                         Assert.IsNull (ex.InnerException, "#B4");
1369                         Assert.IsNotNull (ex.Message, "#B5");
1370                 }
1371         }
1372
1373         [Test] // ctor (String)
1374         [Category ("NotDotNet")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1375         public void Constructor1_PublicKey_Mono ()
1376         {
1377                 const string assemblyName = "TestAssembly";
1378
1379                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1380                 Assert.IsNull (an.CodeBase, "CodeBase");
1381                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1382                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1383                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags");
1384                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1385                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1386                 Assert.IsNull (an.KeyPair, "KeyPair");
1387                 Assert.AreEqual (assemblyName, an.Name, "Name");
1388                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1389                 Assert.IsNull (an.Version, "Version");
1390                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1391                         an.VersionCompatibility, "VersionCompatibility");
1392                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "GetPublicKey");
1393                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1394                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1395         }
1396
1397         [Test]
1398         [Category ("NotWorking")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1399         public void Constructor1_PublicKey_MS ()
1400         {
1401                 const string assemblyName = "TestAssembly";
1402
1403                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1404                 Assert.IsNull (an.CodeBase, "CodeBase");
1405                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1406                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1407                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1408                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1409                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1410                 Assert.IsNull (an.KeyPair, "KeyPair");
1411                 Assert.AreEqual (assemblyName, an.Name, "Name");
1412                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1413                 Assert.IsNull (an.Version, "Version");
1414                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1415                         an.VersionCompatibility, "VersionCompatibility");
1416                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1417                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1418                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1419         }
1420
1421         [Test] // ctor (String)
1422         [Category ("NotWorking")] // bug #351725
1423         public void Constructor1_PublicKey_Ecma ()
1424         {
1425                 const string assemblyName = "TestAssembly";
1426
1427                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey3));
1428                 Assert.IsNull (an.CodeBase, "CodeBase");
1429                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1430                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1431                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1432                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "FullName");
1433                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1434                 Assert.IsNull (an.KeyPair, "KeyPair");
1435                 Assert.AreEqual (assemblyName, an.Name, "Name");
1436                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1437                 Assert.IsNull (an.Version, "Version");
1438                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1439                         an.VersionCompatibility, "VersionCompatibility");
1440                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1441                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "GetPublicKeyToken");
1442                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1443         }
1444
1445         [Test] // ctor (String)
1446         public void Constructor1_PublicKey_Incomplete ()
1447         {
1448                 const string assemblyName = "TestAssembly";
1449
1450                 try {
1451                         new AssemblyName (assemblyName + ", PublicKey=");
1452                         Assert.Fail ("#1");
1453                 } catch (FileLoadException ex) {
1454                         // The given assembly name or codebase was invalid
1455                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1456                         Assert.IsNull (ex.FileName, "#3");
1457                         Assert.IsNull (ex.InnerException, "#3");
1458                         Assert.IsNotNull (ex.Message, "#4");
1459                 }
1460         }
1461
1462         [Test] // ctor (String)
1463         public void Constructor1_PublicKey_Invalid ()
1464         {
1465                 const string assemblyName = "TestAssembly";
1466
1467                 try {
1468                         new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e");
1469                         Assert.Fail ("#A1");
1470                 } catch (FileLoadException ex) {
1471                         // The given assembly name or codebase was invalid
1472                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1473                         Assert.IsNull (ex.FileName, "#A3");
1474                         Assert.IsNull (ex.InnerException, "#A4");
1475                         Assert.IsNotNull (ex.Message, "#A5");
1476                 }
1477
1478                 try {
1479                         new AssemblyName (assemblyName + ", PublicKey=null");
1480                         Assert.Fail ("#B1");
1481                 } catch (FileLoadException ex) {
1482                         // The given assembly name or codebase was invalid
1483                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1484                         Assert.IsNull (ex.FileName, "#B3");
1485                         Assert.IsNull (ex.InnerException, "#B4");
1486                         Assert.IsNotNull (ex.Message, "#B5");
1487                 }
1488         }
1489
1490         [Test] // ctor (String)
1491         [Category ("NotWorking")] // bug #351756
1492         public void Constructor1_PublicKey_KeyPair ()
1493         {
1494                 const string assemblyName = "TestAssembly";
1495
1496                 try {
1497                         new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (keyPair));
1498                         Assert.Fail ("#1");
1499                 } catch (SecurityException ex) {
1500                         // Invalid assembly public key
1501                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#2");
1502                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#3");
1503                         Assert.IsNull (ex.InnerException, "#4");
1504                         Assert.IsNotNull (ex.Message, "#5");
1505                 }
1506         }
1507
1508         [Test] // ctor (String)
1509         public void Constructor1_PublicKeyToken ()
1510         {
1511                 const string assemblyName = "TestAssembly";
1512
1513                 an = new AssemblyName (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1));
1514                 Assert.IsNull (an.CodeBase, "#A:CodeBase");
1515                 Assert.IsNull (an.CultureInfo, "#A:CultureInfo");
1516                 Assert.IsNull (an.EscapedCodeBase, "#A:EscapedCodeBase");
1517                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A:Flags");
1518                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A:FullName");
1519                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#A:HashAlgorithm");
1520                 Assert.IsNull (an.KeyPair, "#A:KeyPair");
1521                 Assert.AreEqual (assemblyName, an.Name, "#A:Name");
1522                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#A:PA");
1523                 Assert.IsNull (an.Version, "#A:Version");
1524                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1525                         an.VersionCompatibility, "#A:VersionCompatibility");
1526                 Assert.IsNull (an.GetPublicKey (), "#A:GetPublicKey");
1527                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A:GetPublicKeyToken");
1528                 Assert.AreEqual (an.FullName, an.ToString (), "#A:ToString");
1529
1530                 an = new AssemblyName (assemblyName + ", PublicKeyToken=null");
1531                 Assert.IsNull (an.CodeBase, "#B:CodeBase");
1532                 Assert.IsNull (an.CultureInfo, "#B:CultureInfo");
1533                 Assert.IsNull (an.EscapedCodeBase, "#B:EscapedCodeBase");
1534                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B:Flags");
1535                 //Assert.AreEqual ("TestAssembly, PublicKeyToken=null", an.FullName, "#B:FullName");
1536                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#B:HashAlgorithm");
1537                 Assert.IsNull (an.KeyPair, "#B:KeyPair");
1538                 Assert.AreEqual (assemblyName, an.Name, "#B:Name");
1539                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#B:PA");
1540                 Assert.IsNull (an.Version, "#B:Version");
1541                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1542                         an.VersionCompatibility, "#B:VersionCompatibility");
1543                 Assert.IsNull (an.GetPublicKey (), "#B:GetPublicKey");
1544                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#B:GetPublicKeyToken");
1545                 Assert.AreEqual (an.FullName, an.ToString (), "#B:ToString");
1546         }
1547
1548         [Test] // ctor (String)
1549         public void Constructor1_PublicKeyToken_Incomplete ()
1550         {
1551                 const string assemblyName = "TestAssembly";
1552
1553                 try {
1554                         new AssemblyName (assemblyName + ", PublicKeyToken=");
1555                         Assert.Fail ("#1");
1556                 } catch (FileLoadException ex) {
1557                         // The given assembly name or codebase was invalid
1558                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1559                         Assert.IsNull (ex.FileName, "#3");
1560                         Assert.IsNull (ex.InnerException, "#3");
1561                         Assert.IsNotNull (ex.Message, "#4");
1562                 }
1563         }
1564
1565         [Test] // ctor (String)
1566         public void Constructor1_PublicKeyToken_Invalid ()
1567         {
1568                 const string assemblyName = "TestAssembly";
1569
1570                 try {
1571                         new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188");
1572                         Assert.Fail ("#1");
1573                 } catch (FileLoadException ex) {
1574                         // The given assembly name or codebase was invalid
1575                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1576                         Assert.IsNull (ex.FileName, "#3");
1577                         Assert.IsNull (ex.InnerException, "#3");
1578                         Assert.IsNotNull (ex.Message, "#4");
1579                 }
1580         }
1581
1582         [Test] // ctor (String)
1583         public void Constructor1_Retargetable ()
1584         {
1585                 const string assemblyName = "TestAssembly";
1586
1587                 try {
1588                         new AssemblyName (assemblyName + ", Retargetable=Yes");
1589                         Assert.Fail ("#A1");
1590                 } catch (FileLoadException ex) {
1591                         // The given assembly name or codebase was invalid
1592                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1593                         Assert.IsNull (ex.FileName, "#A3");
1594                         Assert.IsNull (ex.InnerException, "#A4");
1595                         Assert.IsNotNull (ex.Message, "#A5");
1596                 }
1597
1598                 try {
1599                         new AssemblyName (assemblyName + ", Retargetable=No");
1600                         Assert.Fail ("#B1");
1601                 } catch (FileLoadException ex) {
1602                         // The given assembly name or codebase was invalid
1603                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1604                         Assert.IsNull (ex.FileName, "#B3");
1605                         Assert.IsNull (ex.InnerException, "#B4");
1606                         Assert.IsNotNull (ex.Message, "#B5");
1607                 }
1608
1609                 try {
1610                         new AssemblyName (assemblyName + ", Version=1.0.0.0, Retargetable=Yes");
1611                         Assert.Fail ("#C1");
1612                 } catch (FileLoadException ex) {
1613                         // The given assembly name or codebase was invalid
1614                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2");
1615                         Assert.IsNull (ex.FileName, "#C3");
1616                         Assert.IsNull (ex.InnerException, "#C4");
1617                         Assert.IsNotNull (ex.Message, "#C5");
1618                 }
1619
1620                 try {
1621                         new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, Retargetable=Yes");
1622                         Assert.Fail ("#D1");
1623                 } catch (FileLoadException ex) {
1624                         // The given assembly name or codebase was invalid
1625                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#D2");
1626                         Assert.IsNull (ex.FileName, "#D3");
1627                         Assert.IsNull (ex.InnerException, "#D4");
1628                         Assert.IsNotNull (ex.Message, "#D5");
1629                 }
1630
1631                 try {
1632                         new AssemblyName (assemblyName + ", Version=1.0.0.0, PublicKeyToken=null, Retargetable=Yes");
1633                         Assert.Fail ("#E1");
1634                 } catch (FileLoadException ex) {
1635                         // The given assembly name or codebase was invalid
1636                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#E2");
1637                         Assert.IsNull (ex.FileName, "#E3");
1638                         Assert.IsNull (ex.InnerException, "#E4");
1639                         Assert.IsNotNull (ex.Message, "#E5");
1640                 }
1641
1642                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=yEs");
1643                 Assert.IsNull (an.CodeBase, "F:CodeBase");
1644                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#F:CultureInfo");
1645                 Assert.IsNull (an.EscapedCodeBase, "#F:EscapedCodeBase");
1646                 Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#F:Flags");
1647                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=Yes", an.FullName, "#F:FullName");
1648                 Assert.IsNull (an.GetPublicKey (), "#F:GetPublicKey");
1649                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#F:GetPublicKeyToken");
1650                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#F:HashAlgorithm");
1651                 Assert.IsNull (an.KeyPair, "#F:KeyPair");
1652                 Assert.AreEqual (assemblyName, an.Name, "#F:Name");
1653                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#F:PA");
1654                 Assert.AreEqual (an.FullName, an.ToString (), "#F:ToString");
1655                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#F:Version");
1656                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1657                         an.VersionCompatibility, "#F:VersionCompatibility");
1658
1659                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=nO");
1660                 Assert.IsNull (an.CodeBase, "G:CodeBase");
1661                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#G:CultureInfo");
1662                 Assert.IsNull (an.EscapedCodeBase, "#G:EscapedCodeBase");
1663                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#G:Flags");
1664                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", an.FullName, "#G:FullName");
1665                 Assert.IsNull (an.GetPublicKey (), "#G:GetPublicKey");
1666                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#G:GetPublicKeyToken");
1667                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#G:HashAlgorithm");
1668                 Assert.IsNull (an.KeyPair, "#G:KeyPair");
1669                 Assert.AreEqual (assemblyName, an.Name, "#G:Name");
1670                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#G:PA");
1671                 Assert.AreEqual (an.FullName, an.ToString (), "#G:ToString");
1672                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#G:Version");
1673                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1674                         an.VersionCompatibility, "#G:VersionCompatibility");
1675
1676                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=yes");
1677                 Assert.IsNull (an.CodeBase, "H:CodeBase");
1678                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#H:CultureInfo");
1679                 Assert.IsNull (an.EscapedCodeBase, "#H:EscapedCodeBase");
1680                 Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#H:Flags");
1681                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=Yes", an.FullName, "#H:FullName");
1682                 Assert.IsNull (an.GetPublicKey (), "#H:GetPublicKey");
1683                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#H:GetPublicKeyToken");
1684                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#H:HashAlgorithm");
1685                 Assert.IsNull (an.KeyPair, "#H:KeyPair");
1686                 Assert.AreEqual (assemblyName, an.Name, "#H:Name");
1687                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#H:PA");
1688                 Assert.AreEqual (an.FullName, an.ToString (), "#H:ToString");
1689                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#H:Version");
1690                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1691                         an.VersionCompatibility, "#H:VersionCompatibility");
1692         }
1693
1694         [Test] // ctor (String)
1695         public void Constructor1_Retargetable_Incomplete ()
1696         {
1697                 const string assemblyName = "TestAssembly";
1698
1699                 try {
1700                         new AssemblyName (assemblyName + ", Retargetable=");
1701                         Assert.Fail ("#1");
1702                 } catch (FileLoadException ex) {
1703                         // The given assembly name or codebase was invalid
1704                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1705                         Assert.IsNull (ex.FileName, "#3");
1706                         Assert.IsNull (ex.InnerException, "#4");
1707                         Assert.IsNotNull (ex.Message, "#5");
1708                 }
1709         }
1710
1711         [Test] // ctor (String)
1712         public void Constructor1_Retargetable_Invalid ()
1713         {
1714                 const string assemblyName = "TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
1715
1716                 try {
1717                         new AssemblyName (assemblyName + ", Retargetable=False");
1718                         Assert.Fail ("#A1");
1719                 } catch (FileLoadException ex) {
1720                         // The given assembly name or codebase was invalid
1721                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1722                         Assert.IsNull (ex.FileName, "#A3");
1723                         Assert.IsNull (ex.InnerException, "#A4");
1724                         Assert.IsNotNull (ex.Message, "#A5");
1725                 }
1726
1727                 try {
1728                         new AssemblyName (assemblyName + ", Retargetable=1");
1729                         Assert.Fail ("#B1");
1730                 } catch (FileLoadException ex) {
1731                         // The given assembly name or codebase was invalid
1732                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1733                         Assert.IsNull (ex.FileName, "#B3");
1734                         Assert.IsNull (ex.InnerException, "#B4");
1735                         Assert.IsNotNull (ex.Message, "#B5");
1736                 }
1737
1738                 try {
1739                         new AssemblyName (assemblyName + ", Retargetable=True");
1740                         Assert.Fail ("#C1");
1741                 } catch (FileLoadException ex) {
1742                         // The given assembly name or codebase was invalid
1743                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2");
1744                         Assert.IsNull (ex.FileName, "#C3");
1745                         Assert.IsNull (ex.InnerException, "#C4");
1746                         Assert.IsNotNull (ex.Message, "#C5");
1747                 }
1748         }
1749
1750         [Test] // ctor (String)
1751         public void Constructor1_Version ()
1752         {
1753                 const string assemblyName = "TestAssembly";
1754                 const string assemblyVersion = "1.2.3.4";
1755
1756                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion);
1757                 Assert.IsNull (an.CodeBase, "CodeBase");
1758                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1759                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1760                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1761                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4", an.FullName, "FullName");
1762                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1763                 Assert.IsNull (an.KeyPair, "KeyPair");
1764                 Assert.AreEqual (assemblyName, an.Name, "Name");
1765                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1766                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1767                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1768                         an.VersionCompatibility, "VersionCompatibility");
1769                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1770                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1771                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1772         }
1773
1774
1775         [Test] // ctor (String)
1776         public void Constructor1_Version_Incomplete ()
1777         {
1778                 const string assemblyName = "TestAssembly";
1779
1780                 try {
1781                         new AssemblyName (assemblyName + ", Version=, Culture=neutral");
1782                         Assert.Fail ("#1");
1783                 } catch (FileLoadException ex) {
1784                         // The given assembly name or codebase was invalid
1785                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1786                         Assert.IsNull (ex.FileName, "#3");
1787                         Assert.IsNull (ex.InnerException, "#3");
1788                         Assert.IsNotNull (ex.Message, "#4");
1789                 }
1790         }
1791
1792         [Test] // ctor (String)
1793         public void Constructor1_Version_Invalid ()
1794         {
1795                 const string assemblyName = "TestAssembly";
1796
1797                 try {
1798                         new AssemblyName (assemblyName + ", Version=a.b");
1799                         Assert.Fail ("#1");
1800                 } catch (FileLoadException ex) {
1801                         // The given assembly name or codebase was invalid
1802                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1803                         Assert.IsNull (ex.FileName, "#3");
1804                         Assert.IsNull (ex.InnerException, "#3");
1805                         Assert.IsNotNull (ex.Message, "#4");
1806                 }
1807         }
1808
1809         [Test] // ctor (String)
1810         public void Constructor1_Quoted ()
1811         {
1812                 AssemblyName an;
1813
1814                 an = new AssemblyName ("'System', Version=\"10.0.0.0\", Culture='Neutral', PublicKeyToken='b67a5c561934e089', Retargetable='Yes', ProcessorArchitecture='AMD64'");
1815                 Assert.AreEqual ("System, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b67a5c561934e089, Retargetable=Yes", an.ToString ());
1816                 Assert.AreEqual (ProcessorArchitecture.Amd64, an.ProcessorArchitecture, "Amd64");
1817         }
1818
1819         [Test] // ctor (String)
1820         public void Constructor1_Quoted_Invalid ()
1821         {
1822                 AssemblyName an;
1823
1824                 try {
1825                         an = new AssemblyName ("System, Version=\"10.0.0.0'");
1826                         Assert.Fail ("#1");
1827                 } catch (FileLoadException) {
1828                 }
1829         }
1830
1831         [Test (Description="Xamarin bug #99 - whitespaces in key=value")]
1832         public void WhiteSpaceInKeyValue ()
1833         {
1834                 string nameWithSpaces = String.Format ("MySql.Data.Tests, PublicKey      = \t  {0},  Culture   =\tneutral, Version=\t1.2.3.4", GetTokenString (publicKey1));
1835                 string fullName = "MySql.Data.Tests, Version=1.2.3.4, Culture=neutral, PublicKeyToken=ce5276d8687ec6dc";
1836                 var an = new AssemblyName (nameWithSpaces);
1837
1838                 Assert.AreEqual (fullName, an.FullName);
1839         }
1840
1841         [Test]
1842         public void ReferenceMatchesDefinition_Compares_Only_SimpleName ()
1843         {
1844                 var an1 = new AssemblyName ("TestDll, Version=1.0.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089");
1845                 var an2 = new AssemblyName ("TestDll, Version=2.0.0.2001, Culture=en-US, PublicKeyToken=ab7a5c561934e089");
1846
1847                 var an3 = new AssemblyName ("TestDll");
1848                 var an4 = new AssemblyName ("tesTDlL");
1849
1850                 var an5 = new AssemblyName ("TestDll");
1851                 var an6 = new AssemblyName ("TestDll2");
1852
1853                 Assert.IsTrue (AssemblyName.ReferenceMatchesDefinition (an1, an2));
1854                 Assert.IsTrue (AssemblyName.ReferenceMatchesDefinition (an3, an4));
1855                 Assert.IsFalse (AssemblyName.ReferenceMatchesDefinition (an5, an6));
1856         }
1857
1858         [Test]
1859         public void CultureNameInvariant ()
1860         {
1861                 var an = new AssemblyName ("TestDll");
1862                 an.CultureInfo = new CultureInfo (CultureInfo.InvariantCulture.LCID);
1863
1864                 Assert.AreEqual ("", an.CultureName);
1865         }
1866
1867         [Test]
1868         public void TestDecodingEcmaKey ()
1869         {
1870         var x = new AssemblyName( "System, PublicKey=00000000000000000400000000000000" );
1871                 Assert.IsNull (x.GetPublicKey (), "#1");
1872                 Assert.IsNotNull (x.GetPublicKeyToken (), "#2");
1873
1874                 var t = x.GetPublicKeyToken ();
1875                 Assert.AreEqual (8, t.Length, "#3");
1876
1877                 Assert.AreEqual (0xB7, t [0], "#4.0");
1878                 Assert.AreEqual (0x7A, t [1], "#4.1");
1879                 Assert.AreEqual (0x5C, t [2], "#4.2");
1880                 Assert.AreEqual (0x56, t [3], "#4.3");
1881                 Assert.AreEqual (0x19, t [4], "#4.4");
1882                 Assert.AreEqual (0x34, t [5], "#4.5");
1883                 Assert.AreEqual (0xE0, t [6], "#4.6");
1884                 Assert.AreEqual (0x89, t [7], "#4.7");
1885         }
1886 }
1887
1888 }