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

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