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 #elif NET_4_0
 389                 AssemblyCorlib = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 390 #else
 391                 AssemblyCorlib = "mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 392 #endif
 393                 Assert.AreEqual (AssemblyCorlib, an.FullName, "#2");
 394         }
 395
 396         [Test]
 397         public void FullName_Self ()
 398         {
 399                 Assembly a = Assembly.GetExecutingAssembly ();
 400                 an = a.GetName ();
 401
 402                 Assert.IsNotNull (an.FullName, "#1");
 403                 Assert.IsTrue (an.FullName.IndexOf ("Version=0.0.0.0") != -1, "#2");
 404                 Assert.IsTrue (an.FullName.IndexOf ("Culture=neutral") != -1, "#3");
 405                 Assert.IsTrue (an.FullName.IndexOf ("PublicKeyToken=null") != -1, "#4");
 406         }
 407
 408         [Test]
 409         public void FullName_Flags ()
 410         {
 411                 const string assemblyName = "TestAssembly";
 412
 413                 // tests for AssemblyName with only name
 414                 an = new AssemblyName ();
 415                 an.Flags = AssemblyNameFlags.EnableJITcompileOptimizer |
 416                         AssemblyNameFlags.EnableJITcompileTracking |
 417                         AssemblyNameFlags.PublicKey |
 418                         AssemblyNameFlags.Retargetable;
 419                 an.Name = assemblyName;
 420                 Assert.AreEqual (assemblyName + ", Retargetable=Yes", an.FullName, "#1");
 421                 an.Flags = AssemblyNameFlags.None;
 422                 Assert.AreEqual (assemblyName, an.FullName, "#2");
 423         }
 424
 425         [Test]
 426         public void FullName_Name ()
 427         {
 428                 const string assemblyName = "TestAssembly";
 429
 430                 // tests for AssemblyName with only name
 431                 an = new AssemblyName ();
 432                 an.Name = assemblyName;
 433                 Assert.IsNotNull (an.FullName, "FullName2#1");
 434                 Assert.AreEqual (an.Name, an.FullName, "FullName2#2");
 435                 Assert.AreEqual (-1, an.FullName.IndexOf ("Culture="), "FullName2#3");
 436                 Assert.AreEqual (-1, an.FullName.IndexOf ("PublicKeyToken="), "FullName2#4");
 437         }
 438
 439         [Test]
 440         public void FullName_Version ()
 441         {
 442                 const string assemblyName = "TestAssembly";
 443                 const string assemblyVersion = "1.2";
 444
 445                 // tests for AssemblyName with name and version
 446                 an = new AssemblyName ();
 447                 an.Name = assemblyName;
 448                 an.Version = new Version (assemblyVersion);
 449                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion, an.FullName, "FullName3#1");
 450         }
 451
 452         [Test]
 453         public void FullName_Culture ()
 454         {
 455                 const string assemblyName = "TestAssembly";
 456
 457                 // tests for AssemblyName with name and neutral culture
 458                 an = new AssemblyName ();
 459                 an.Name = assemblyName;
 460                 an.CultureInfo = CultureInfo.InvariantCulture;
 461                 Assert.AreEqual (assemblyName + ", Culture=neutral", an.FullName, "#1");
 462                 an.CultureInfo = new CultureInfo ("nl-BE");
 463                 Assert.AreEqual (assemblyName + ", Culture=nl-BE", an.FullName, "#2");
 464                 an.Name = null;
 465                 Assert.AreEqual (string.Empty, an.FullName, "#3");
 466         }
 467
 468         [Test]
 469         public void FullName_PublicKey ()
 470         {
 471                 const string assemblyName = "TestAssembly";
 472
 473                 // tests for AssemblyName with name and public key
 474                 an = new AssemblyName ();
 475                 an.Name = assemblyName;
 476                 an.SetPublicKey (publicKey1);
 477                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1");
 478                 an.SetPublicKey ((byte []) null);
 479                 Assert.AreEqual (assemblyName, an.FullName, "#A2");
 480                 an.SetPublicKey (new byte [0]);
 481                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3");
 482                 an.Name = null;
 483                 Assert.AreEqual (string.Empty, an.FullName, "#A4");
 484
 485                 an = new AssemblyName ();
 486                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 487                 an.Name = assemblyName;
 488                 an.SetPublicKey (publicKey1);
 489                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1");
 490                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 491                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2");
 492                 an.SetPublicKeyToken ((byte []) null);
 493                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B3");
 494                 an.Name = null;
 495                 Assert.AreEqual (string.Empty, an.FullName, "#B4");
 496
 497                 an = new AssemblyName ();
 498                 an.HashAlgorithm = AssemblyHashAlgorithm.None;
 499                 an.Name = assemblyName;
 500                 an.SetPublicKey (publicKey1);
 501                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1");
 502                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 503                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#C2");
 504                 an.SetPublicKeyToken ((byte []) null);
 505                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C3");
 506                 an.Name = null;
 507                 Assert.AreEqual (string.Empty, an.FullName, "#C4");
 508
 509                 an = new AssemblyName ();
 510                 an.Name = assemblyName;
 511                 an.SetPublicKey (new byte [0]);
 512                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1");
 513                 an.Name = null;
 514                 Assert.AreEqual (string.Empty, an.FullName, "#D2");
 515                 an.SetPublicKey (publicKey3);
 516                 Assert.AreEqual (string.Empty, an.FullName, "#D3");
 517                 an.Name = assemblyName;
 518                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "#D4");
 519         }
 520
 521         [Test]
 522         public void FullName_PublicKey_KeyPair ()
 523         {
 524                 const string assemblyName = "TestAssembly";
 525
 526                 // tests for AssemblyName with name and public key
 527                 an = new AssemblyName ();
 528                 an.Name = assemblyName;
 529                 an.SetPublicKey (keyPair);
 530                 try {
 531                         Assert.Fail ("#A1: " + an.FullName);
 532                 } catch (SecurityException ex) {
 533                         // Invalid assembly public key
 534                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#A2");
 535                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#A3");
 536                         Assert.IsNull (ex.InnerException, "#A4");
 537                         Assert.IsNotNull (ex.Message, "#A5");
 538                 }
 539
 540                 an.SetPublicKeyToken (new byte [0]);
 541                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#B1");
 542
 543                 an.SetPublicKeyToken ((byte []) null);
 544                 try {
 545                         Assert.Fail ("#C1: " + an.FullName);
 546                 } catch (SecurityException ex) {
 547                         // Invalid assembly public key
 548                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#C2");
 549                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#C3");
 550                         Assert.IsNull (ex.InnerException, "#C4");
 551                         Assert.IsNotNull (ex.Message, "#C5");
 552                 }
 553
 554                 an.SetPublicKeyToken (new byte [0]);
 555                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1");
 556                 an.SetPublicKey (publicKey1);
 557                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2");
 558                 an.SetPublicKeyToken ((byte []) null);
 559                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3");
 560         }
 561
 562         [Test]
 563         public void FullName_PublicKeyToken ()
 564         {
 565                 const string assemblyName = "TestAssembly";
 566
 567                 an = new AssemblyName ();
 568                 an.Name = assemblyName;
 569                 an.SetPublicKeyToken (pk_token1);
 570                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1");
 571                 an.SetPublicKeyToken ((byte []) null);
 572                 Assert.AreEqual (assemblyName, an.FullName, "#A2");
 573                 an.SetPublicKeyToken (new byte [0]);
 574                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3");
 575                 an.SetPublicKeyToken (pk_token1);
 576                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A4");
 577                 an.Name = null;
 578                 Assert.AreEqual (string.Empty, an.FullName, "#A5");
 579
 580                 an = new AssemblyName ();
 581                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 582                 an.Name = assemblyName;
 583                 an.SetPublicKeyToken (pk_token1);
 584                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1");
 585                 an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 });
 586                 Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2");
 587                 an.SetPublicKeyToken ((byte []) null);
 588                 Assert.AreEqual (assemblyName, an.FullName, "#B3");
 589                 an.Name = null;
 590                 Assert.AreEqual (string.Empty, an.FullName, "#B4");
 591
 592                 an = new AssemblyName ();
 593                 an.Name = assemblyName;
 594                 an.SetPublicKey (publicKey1);
 595                 an.SetPublicKeyToken (pk_token1);
 596                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1");
 597                 an.SetPublicKey ((byte []) null);
 598                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C2");
 599                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C3");
 600                 an.SetPublicKey (new byte [0]);
 601                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C4");
 602                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C5");
 603
 604                 an = new AssemblyName ();
 605                 an.Name = assemblyName;
 606                 an.SetPublicKey (publicKey1);
 607                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D1");
 608                 an.SetPublicKey (new byte [0]);
 609                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2");
 610                 an.SetPublicKeyToken (pk_token1);
 611                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3");
 612                 an.SetPublicKey ((byte []) null);
 613                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D4");
 614         }
 615
 616         [Test]
 617         public void FullName_VersionCulture ()
 618         {
 619                 const string assemblyName = "TestAssembly";
 620                 const string assemblyVersion = "1.2";
 621
 622                 // tests for AssemblyName with name, version and neutral culture
 623                 an = new AssemblyName ();
 624                 an.Name = assemblyName;
 625                 an.Version = new Version (assemblyVersion);
 626                 an.CultureInfo = CultureInfo.InvariantCulture;
 627                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 628                         + ", Culture=neutral", an.FullName, "#1");
 629                 an.CultureInfo = new CultureInfo ("en-US");
 630                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 631                         + ", Culture=en-US", an.FullName, "#2");
 632                 an.CultureInfo = new CultureInfo ("en");
 633                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 634                         + ", Culture=en", an.FullName, "#3");
 635         }
 636
 637         [Test]
 638         public void FullName_VersionPublicKey ()
 639         {
 640                 const string assemblyName = "TestAssembly";
 641                 const string assemblyVersion = "1.2";
 642
 643                 // tests for AssemblyName with name, version and public key
 644                 an = new AssemblyName ();
 645                 an.Name = assemblyName;
 646                 an.Version = new Version (assemblyVersion);
 647                 an.SetPublicKey (publicKey1);
 648                 an.SetPublicKeyToken (pk_token1);
 649                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 650                         + ", PublicKeyToken=" + GetTokenString (pk_token1),
 651                         an.FullName, "#1");
 652         }
 653
 654         [Test]
 655         public void FullName_CulturePublicKey ()
 656         {
 657                 const string assemblyName = "TestAssembly";
 658
 659                 // tests for AssemblyName with name, culture and public key
 660                 an = new AssemblyName ();
 661                 an.Name = assemblyName;
 662                 an.CultureInfo = CultureInfo.InvariantCulture;
 663                 an.SetPublicKey (publicKey1);
 664                 an.SetPublicKeyToken (pk_token1);
 665                 Assert.AreEqual (assemblyName + ", Culture=neutral"
 666                         + ", PublicKeyToken=" + GetTokenString (pk_token1),
 667                         an.FullName, "#1");
 668         }
 669
 670         [Test]
 671         public void GetPublicKeyToken ()
 672         {
 673                 const string assemblyName = "TestAssembly";
 674
 675                 an = new AssemblyName ();
 676                 an.SetPublicKey (publicKey1);
 677                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A1");
 678                 an.SetPublicKey (publicKey2);
 679                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A2");
 680                 an.SetPublicKeyToken (new byte [] { 0x0a });
 681                 Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A3");
 682                 an.SetPublicKey (publicKey1);
 683                 Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A4");
 684                 an.SetPublicKeyToken (new byte [0]);
 685                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A5");
 686                 an.Name = assemblyName;
 687                 an.SetPublicKey (publicKey2);
 688                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A6");
 689                 Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A7");
 690
 691                 an = new AssemblyName ();
 692                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 693                 an.SetPublicKey (publicKey1);
 694                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B1");
 695
 696                 an = new AssemblyName ();
 697                 an.HashAlgorithm = AssemblyHashAlgorithm.None;
 698                 an.SetPublicKey (publicKey1);
 699                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C1");
 700
 701                 an = new AssemblyName ();
 702                 an.SetPublicKeyToken (new byte [0]);
 703                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#D1");
 704                 an.SetPublicKeyToken (new byte [] { 0x0b, 0xff });
 705                 Assert.AreEqual (new byte [] { 0x0b, 0xff }, an.GetPublicKeyToken (), "#D2");
 706                 an.SetPublicKeyToken ((byte []) null);
 707                 Assert.IsNull (an.GetPublicKeyToken (), "#D3");
 708
 709                 an = new AssemblyName ();
 710                 an.SetPublicKey (keyPair);
 711                 try {
 712                         an.GetPublicKeyToken ();
 713                         Assert.Fail ("#E1");
 714                 } catch (SecurityException ex) {
 715                         // Invalid assembly public key
 716                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#E2");
 717                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#E3");
 718                         Assert.IsNull (ex.InnerException, "#E4");
 719                         Assert.IsNotNull (ex.Message, "#E5");
 720                 }
 721         }
 722
 723         [Test]
 724         public void GetPublicKeyToken_Corlib ()
 725         {
 726                 an = typeof (int).Assembly.GetName ();
 727                 Assert.IsNotNull (an.GetPublicKeyToken (), "#1");
 728                 Assert.IsTrue (an.GetPublicKeyToken ().Length > 0, "#2");
 729         }
 730
 731         [Test]
 732         public void GetPublicGetToken_Ecma ()
 733         {
 734                 const string assemblyName = "TestAssembly";
 735
 736                 an = new AssemblyName ();
 737                 an.Name = assemblyName;
 738                 an.SetPublicKey (publicKey3);
 739                 Assert.IsNotNull (an.GetPublicKeyToken (), "#1");
 740                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "#2");
 741         }
 742
 743         [Test]
 744         public void GetPublicKeyToken_Self ()
 745         {
 746                 Assembly a = Assembly.GetExecutingAssembly ();
 747                 an = a.GetName ();
 748                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken ());
 749         }
 750
 751         static int nameIndex = 0;
 752
 753         private AssemblyName GenAssemblyName ()
 754         {
 755                 AssemblyName assemblyName = new AssemblyName();
 756                 assemblyName.Name = "MonoTests.System.Reflection.AssemblyNameTest" + (nameIndex ++);
 757                 return assemblyName;
 758         }
 759
 760 #if !MOBILE
 761         private Assembly GenerateAssembly (AssemblyName name)
 762         {
 763                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 764                         name,
 765                         AssemblyBuilderAccess.RunAndSave,
 766                         tempDir);
 767                 ab.DefineDynamicModule ("def_module");
 768                 ab.Save (name.Name + ".dll");
 769
 770                 return Assembly.LoadFrom (Path.Combine (tempDir, name.Name + ".dll"));
 771         }
 772
 773         private AssemblyBuilder GenerateDynamicAssembly (AssemblyName name)
 774         {
 775                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 776                                 name,
 777                                 AssemblyBuilderAccess.Run);
 778
 779                 return ab;
 780         }
 781
 782         [Test]
 783         public void TestCultureInfo ()
 784         {
 785                 AssemblyName name;
 786                 Assembly a;
 787                 CultureInfo culture;
 788
 789                 name = GenAssemblyName ();
 790                 name.CultureInfo = CultureInfo.CreateSpecificCulture ("ar-DZ");
 791                 a = GenerateAssembly (name);
 792                 culture = a.GetName ().CultureInfo;
 793                 Assert.IsFalse (culture.IsNeutralCulture, "#A1");
 794                 Assert.IsFalse (culture.IsReadOnly, "#A2");
 795                 Assert.AreEqual (5121, culture.LCID, "#A3");
 796                 Assert.AreEqual ("ar-DZ", culture.Name, "#A4");
 797                 Assert.IsTrue (culture.UseUserOverride, "#A5");
 798
 799                 name = GenAssemblyName ();
 800                 name.CultureInfo = new CultureInfo ("en");
 801                 a = GenerateAssembly (name);
 802                 culture = a.GetName ().CultureInfo;
 803                 Assert.IsTrue (culture.IsNeutralCulture, "#B1");
 804                 Assert.IsFalse (culture.IsReadOnly, "#B2");
 805                 Assert.AreEqual (9, culture.LCID, "#B3");
 806                 Assert.AreEqual ("en", culture.Name, "#B4");
 807                 Assert.IsTrue (culture.UseUserOverride, "#B5");
 808
 809                 name = GenAssemblyName ();
 810                 name.CultureInfo = CultureInfo.InvariantCulture;
 811                 a = GenerateAssembly (name);
 812                 culture = a.GetName ().CultureInfo;
 813                 Assert.IsFalse (culture.IsNeutralCulture, "#C1");
 814                 Assert.IsFalse (culture.IsReadOnly, "#C2");
 815                 Assert.AreEqual (127, culture.LCID, "#C3");
 816                 Assert.AreEqual (string.Empty, culture.Name, "#C4");
 817                 Assert.IsFalse (culture.UseUserOverride, "#C5");
 818
 819                 a = typeof (int).Assembly;
 820                 name = a.GetName ();
 821                 culture = name.CultureInfo;
 822                 Assert.IsFalse (culture.IsNeutralCulture, "#D1");
 823                 Assert.IsFalse (culture.IsReadOnly, "#D2");
 824                 Assert.AreEqual (127, culture.LCID, "#D3");
 825                 Assert.AreEqual (string.Empty, culture.Name, "#D4");
 826                 Assert.IsFalse (culture.UseUserOverride, "#D5");
 827
 828                 a = Assembly.GetExecutingAssembly ();
 829                 name = a.GetName ();
 830                 culture = name.CultureInfo;
 831                 Assert.IsFalse (culture.IsNeutralCulture, "#E1");
 832                 Assert.IsFalse (culture.IsReadOnly, "#E2");
 833                 Assert.AreEqual (127, culture.LCID, "#E3");
 834                 Assert.AreEqual (string.Empty, culture.Name, "#E4");
 835                 Assert.IsFalse (culture.UseUserOverride, "#E5");
 836
 837                 AssemblyName [] names = a.GetReferencedAssemblies ();
 838                 foreach (AssemblyName an in names) {
 839                         culture = an.CultureInfo;
 840                         Assert.IsFalse (culture.IsNeutralCulture, "#F1:" + an.Name);
 841                         Assert.IsFalse (culture.IsReadOnly, "#F2:" + an.Name);
 842                         Assert.AreEqual (127, culture.LCID, "#F3:" + an.Name);
 843                         Assert.AreEqual (string.Empty, culture.Name, "#F4:" + an.Name);
 844                         Assert.IsFalse (culture.UseUserOverride, "#F5:" + an.Name);
 845                 }
 846         }
 847
 848         [Test]
 849         public void Version ()
 850         {
 851                 AssemblyName name = GenAssemblyName ();
 852                 name.Version = new Version (1, 2, 3, 4);
 853
 854                 Assembly a = GenerateAssembly (name);
 855                 Assert.AreEqual ("1.2.3.4", a.GetName ().Version.ToString (), "1.2.3.4 normal");
 856
 857                 name = GenAssemblyName ();
 858                 name.Version = new Version (1, 2, 3);
 859
 860                 a = GenerateAssembly (name);
 861                 Assert.AreEqual ("1.2.3.0", a.GetName ().Version.ToString (), "1.2.3.0 normal");
 862
 863                 name = GenAssemblyName ();
 864                 name.Version = new Version (1, 2);
 865
 866                 a = GenerateAssembly (name);
 867                 Assert.AreEqual ("1.2.0.0", a.GetName ().Version.ToString (), "1.2.0.0 normal");
 868         }
 869
 870         [Test]
 871         public void Version_Dynamic ()
 872         {
 873                 AssemblyName name = GenAssemblyName ();
 874                 name.Version = new Version (1, 2, 3, 4);
 875
 876                 AssemblyBuilder ab = GenerateDynamicAssembly (name);
 877                 Assert.AreEqual ("1.2.3.4", ab.GetName ().Version.ToString (), "1.2.3.4 dynamic");
 878
 879                 name = GenAssemblyName ();
 880                 name.Version = new Version (1, 2, 3);
 881
 882                 ab = GenerateDynamicAssembly (name);
 883                 Assert.AreEqual ("1.2.3.0", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
 884
 885                 name = GenAssemblyName ();
 886                 name.Version = new Version (1, 2);
 887
 888                 ab = GenerateDynamicAssembly (name);
 889                 Assert.AreEqual ("1.2.0.0", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
 890         }
 891 #endif
 892
 893         [Test]
 894         public void HashAlgorithm ()
 895         {
 896                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1,
 897                         typeof (int).Assembly.GetName ().HashAlgorithm);
 898         }
 899
 900         [Test]
 901         public void Serialization ()
 902         {
 903                 an = new AssemblyName ();
 904                 an.CodeBase = "http://www.test.com/test.dll";
 905                 an.CultureInfo = CultureInfo.InvariantCulture;
 906                 an.Flags = AssemblyNameFlags.PublicKey;
 907                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 908                 an.KeyPair = new StrongNameKeyPair (publicKey1);
 909                 an.Name = "TestAssembly";
 910                 an.Version = new Version (1, 5);
 911                 an.VersionCompatibility = AssemblyVersionCompatibility.SameProcess;
 912
 913                 MemoryStream ms = new MemoryStream ();
 914                 BinaryFormatter bf = new BinaryFormatter ();
 915                 bf.Serialize (ms, an);
 916
 917                 // reset position of memorystream
 918                 ms.Position = 0;
 919
 920                 // deserialze assembly name
 921                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
 922
 923                 // close the memorystream
 924                 ms.Close ();
 925
 926                 // compare orginal and deserialized assembly name
 927                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
 928                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
 929                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
 930                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
 931                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
 932                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
 933                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
 934                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
 935                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
 936                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
 937                 Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey");
 938                 Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken");
 939         }
 940
 941         [Test]
 942         public void Serialization_WithoutStrongName ()
 943         {
 944                 an = new AssemblyName ();
 945                 an.CodeBase = "http://www.test.com/test.dll";
 946                 an.CultureInfo = CultureInfo.InvariantCulture;
 947                 an.Flags = AssemblyNameFlags.None;
 948                 an.HashAlgorithm = AssemblyHashAlgorithm.SHA1;
 949                 an.KeyPair = null;
 950                 an.Name = "TestAssembly2";
 951                 an.Version = new Version (1, 5, 0, 0);
 952                 an.VersionCompatibility = AssemblyVersionCompatibility.SameMachine;
 953
 954                 MemoryStream ms = new MemoryStream ();
 955                 BinaryFormatter bf = new BinaryFormatter ();
 956                 bf.Serialize (ms, an);
 957
 958                 // reset position of memorystream
 959                 ms.Position = 0;
 960
 961                 // deserialze assembly name
 962                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
 963
 964                 // close the memorystream
 965                 ms.Close ();
 966
 967                 // compare orginal and deserialized assembly name
 968                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
 969                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
 970                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
 971                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
 972                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
 973                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
 974                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
 975                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
 976                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
 977                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
 978                 Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey");
 979                 Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken");
 980         }
 981
 982         [Test]
 983         public void GetObjectData_Info_Null ()
 984         {
 985                 an = new AssemblyName ();
 986                 try {
 987                         an.GetObjectData (null, new StreamingContext (StreamingContextStates.All));
 988                         Assert.Fail ("#1");
 989                 } catch (ArgumentNullException ex) {
 990                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 991                         Assert.IsNull (ex.InnerException, "#3");
 992                         Assert.IsNotNull (ex.Message, "#4");
 993                         Assert.IsNotNull (ex.ParamName, "#5");
 994                         Assert.AreEqual ("info", ex.ParamName, "#6");
 995                 }
 996         }
 997
 998         [Test]
 999         public void Clone_Corlib ()
1000         {
1001                 an = typeof (int).Assembly.GetName ();
1002                 AssemblyName clone = (AssemblyName) an.Clone ();
1003
1004                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
1005                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
1006                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
1007                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
1008                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
1009                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
1010                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
1011                 Assert.AreEqual (an.Name, clone.Name, "Name");
1012                 //Assert.AreEqual (an.ProcessorArchitecture, clone.ProcessorArchitecture, "PA");
1013                 Assert.AreEqual (an.Version, clone.Version, "Version");
1014                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
1015                 Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
1016                 Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
1017                 Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
1018         }
1019
1020         [Test]
1021         public void Clone_Empty ()
1022         {
1023                 an = new AssemblyName ();
1024                 AssemblyName clone = (AssemblyName) an.Clone ();
1025
1026                 Assert.IsNull (clone.CodeBase, "CodeBase");
1027                 Assert.IsNull (clone.CultureInfo, "CultureInfo");
1028                 Assert.IsNull (clone.EscapedCodeBase, "EscapedCodeBase");
1029                 Assert.AreEqual (AssemblyNameFlags.None, clone.Flags, "Flags");
1030                 Assert.AreEqual (String.Empty, clone.FullName, "FullName");
1031                 Assert.AreEqual (AssemblyHashAlgorithm.None, clone.HashAlgorithm, "HashAlgorithm");
1032                 Assert.IsNull (clone.KeyPair, "KeyPair");
1033                 Assert.IsNull (clone.Name, "Name");
1034                 Assert.AreEqual (ProcessorArchitecture.None, clone.ProcessorArchitecture, "PA");
1035                 Assert.IsNull (clone.Version, "Version");
1036                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1037                         clone.VersionCompatibility, "VersionCompatibility");
1038         }
1039
1040         [Test]
1041         public void Clone_Self ()
1042         {
1043                 an = Assembly.GetExecutingAssembly ().GetName ();
1044                 AssemblyName clone = (AssemblyName) an.Clone ();
1045
1046                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
1047                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
1048                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
1049                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
1050                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
1051                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
1052                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
1053                 Assert.AreEqual (an.Name, clone.Name, "Name");
1054                 Assert.AreEqual (an.ProcessorArchitecture, clone.ProcessorArchitecture, "PA");
1055                 Assert.AreEqual (an.Version, clone.Version, "Version");
1056                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
1057                 Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
1058                 Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
1059                 Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
1060         }
1061
1062         [Test]
1063         [ExpectedException (typeof (FileNotFoundException))]
1064         public void GetAssemblyName_AssemblyFile_DoesNotExist ()
1065         {
1066                 AssemblyName.GetAssemblyName (Path.Combine (tempDir, "doesnotexist.dll"));
1067         }
1068
1069         [Test]
1070         [Category ("NotWorking")]
1071         public void GetAssemblyName_AssemblyFile_ReadLock ()
1072         {
1073                 string file = Path.Combine (tempDir, "loadfailure.dll");
1074                 using (FileStream fs = File.Open (file, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None)) {
1075                         try {
1076                                 AssemblyName.GetAssemblyName (file);
1077                                 Assert.Fail ("#1");
1078                         } catch (FileLoadException ex) {
1079                                 // Could not load file or assembly '...' or one
1080                                 // of its dependencies. The process cannot access
1081                                 // the file because it is being used by another
1082                                 // process
1083                                 Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1084                                 Assert.IsNotNull (ex.FileName, "#3");
1085                                 Assert.AreEqual (file, ex.FileName, "#4");
1086                                 Assert.IsNull (ex.InnerException, "#5");
1087                                 Assert.IsNotNull (ex.Message, "#6");
1088                         }
1089                 }
1090                 File.Delete (file);
1091         }
1092
1093         [Test]
1094         public void GetAssemblyName_AssemblyFile_BadImage ()
1095         {
1096                 string file = Path.Combine (tempDir, "badimage.dll");
1097                 using (StreamWriter sw = File.CreateText (file)) {
1098                         sw.WriteLine ("somegarbage");
1099                 }
1100                 try {
1101                         AssemblyName.GetAssemblyName (file);
1102                         Assert.Fail ("#1");
1103                 } catch (BadImageFormatException ex) {
1104                         Assert.AreEqual (typeof (BadImageFormatException), ex.GetType (), "#2");
1105                         Assert.IsNotNull (ex.FileName, "#3");
1106                         Assert.AreEqual (file, ex.FileName, "#4");
1107                         Assert.IsNull (ex.InnerException, "#5");
1108                         Assert.IsNotNull (ex.Message, "#6");
1109                 } finally {
1110                         File.Delete (file);
1111                 }
1112         }
1113
1114         [Test]
1115         [Category ("AndroidNotWorking")] // Accessing assemblies by asm.Location is not supported
1116         public void GetAssemblyName_CodeBase ()
1117         {
1118                 Assembly execAssembly = Assembly.GetExecutingAssembly ();
1119
1120                 AssemblyName aname = AssemblyName.GetAssemblyName (execAssembly.Location);
1121                 Assert.IsNotNull (aname.CodeBase, "#1");
1122                 Assert.AreEqual (execAssembly.CodeBase, aname.CodeBase, "#2");
1123         }
1124
1125         // helpers
1126
1127         private string GetTokenString (byte[] value)
1128         {
1129                 string tokenString = "";
1130                 for (int i = 0; i < value.Length; i++) {
1131                         tokenString += value[i].ToString ("x2");
1132                 }
1133                 return tokenString;
1134         }
1135
1136         [Test] // ctor (String)
1137         public void Constructor1_Name ()
1138         {
1139                 const string assemblyName = "TestAssembly";
1140
1141                 an = new AssemblyName (assemblyName);
1142                 Assert.IsNull (an.CodeBase, "CodeBase");
1143                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1144                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1145                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1146                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1147                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1148                 Assert.IsNull (an.KeyPair, "KeyPair");
1149                 Assert.AreEqual (assemblyName, an.Name, "Name");
1150                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1151                 Assert.IsNull (an.Version, "Version");
1152                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1153                         an.VersionCompatibility, "VersionCompatibility");
1154                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1155                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1156                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1157 #if NET_4_5
1158                 Assert.IsNull (an.CultureName, "CultureName");
1159                 Assert.AreEqual (AssemblyContentType.Default, an.ContentType, "ContentType");
1160 #endif
1161         }
1162
1163         [Test] // ctor (String)
1164         public void Constructor1_Full ()
1165         {
1166                 const string assemblyName = "TestAssembly";
1167                 const string assemblyCulture = "neutral";
1168                 const string assemblyVersion = "1.2.3.4";
1169
1170                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion +
1171                                 ", Culture=" + assemblyCulture + ", PublicKeyToken=" + GetTokenString (pk_token1) + ",ProcessorArchitecture=X86");
1172                 Assert.IsNull (an.CodeBase, "CodeBase");
1173                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo");
1174                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1175                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1176                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4, Culture=neutral, PublicKeyToken=" +
1177                         GetTokenString (pk_token1), an.FullName, "FullName");
1178                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1179                 Assert.IsNull (an.KeyPair, "KeyPair");
1180                 Assert.AreEqual (assemblyName, an.Name, "Name");
1181                 Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA");
1182                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1183                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1184                         an.VersionCompatibility, "VersionCompatibility");
1185                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1186                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1187                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1188         }
1189
1190         [Test] // ctor (String)
1191         public void Constructor1_AssemblyName_Empty ()
1192         {
1193                 try {
1194                         new AssemblyName (string.Empty);
1195                         Assert.Fail ("#1");
1196                 } catch (ArgumentException ex) {
1197                         // String cannot have zero length
1198                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1199                         Assert.IsNull (ex.InnerException, "#3");
1200                         Assert.IsNotNull (ex.Message, "#4");
1201                         Assert.IsNull (ex.ParamName, "#5");
1202                 }
1203         }
1204
1205         [Test] // ctor (String)
1206         public void Constructor1_AssemblyName_Invalid ()
1207         {
1208                 const string assemblyName = "TestAssembly";
1209
1210                 try {
1211                         new AssemblyName (assemblyName + ", =1.2.4.5");
1212                         Assert.Fail ("#A1");
1213                 } catch (FileLoadException ex) {
1214                         // The given assembly name or codebase was invalid
1215                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1216                         Assert.IsNull (ex.FileName, "#3");
1217                         Assert.IsNull (ex.InnerException, "#3");
1218                         Assert.IsNotNull (ex.Message, "#4");
1219                 }
1220
1221                 try {
1222                         new AssemblyName (assemblyName + ", OtherAttribute");
1223                         Assert.Fail ("#B1");
1224                 } catch (FileLoadException ex) {
1225                         // The given assembly name or codebase was invalid
1226                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1227                         Assert.IsNull (ex.FileName, "#3");
1228                         Assert.IsNull (ex.InnerException, "#3");
1229                         Assert.IsNotNull (ex.Message, "#4");
1230                 }
1231         }
1232
1233         [Test] // ctor (String)
1234         public void Constructor1_AssemblyName_Null ()
1235         {
1236                 try {
1237                         new AssemblyName (null);
1238                         Assert.Fail ("#1");
1239                 } catch (ArgumentNullException ex) {
1240                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1241                         Assert.IsNull (ex.InnerException, "#3");
1242                         Assert.IsNotNull (ex.Message, "#4");
1243                         Assert.IsNotNull (ex.ParamName, "#5");
1244                         Assert.AreEqual ("assemblyName", ex.ParamName, "#6");
1245                 }
1246         }
1247
1248         [Test] // ctor (String)
1249         public void Constructor1_Culture ()
1250         {
1251                 const string assemblyName = "TestAssembly";
1252                 const string assemblyCulture = "en-US";
1253
1254                 an = new AssemblyName (assemblyName + ", Culture=" + assemblyCulture);
1255                 Assert.IsNull (an.CodeBase, "CodeBase");
1256                 Assert.AreEqual (new CultureInfo (assemblyCulture), an.CultureInfo, "CultureInfo");
1257                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1258                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1259                 Assert.AreEqual ("TestAssembly, Culture=en-US", an.FullName, "FullName");
1260                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1261                 Assert.IsNull (an.KeyPair, "KeyPair");
1262                 Assert.AreEqual (assemblyName, an.Name, "Name");
1263                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1264                 Assert.IsNull (an.Version, "Version");
1265                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1266                         an.VersionCompatibility, "VersionCompatibility");
1267                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1268                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1269                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1270         }
1271
1272         [Test] // ctor (String)
1273         public void Constructor1_Culture_Incomplete ()
1274         {
1275                 const string assemblyName = "TestAssembly";
1276
1277                 try {
1278                         new AssemblyName (assemblyName + ", Culture=");
1279                         Assert.Fail ("#1");
1280                 } catch (FileLoadException ex) {
1281                         // The given assembly name or codebase was invalid
1282                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1283                         Assert.IsNull (ex.FileName, "#3");
1284                         Assert.IsNull (ex.InnerException, "#3");
1285                         Assert.IsNotNull (ex.Message, "#4");
1286                 }
1287         }
1288
1289         [Test] // ctor (String)
1290         public void Constructor1_Culture_NotSupported ()
1291         {
1292                 const string assemblyName = "TestAssembly";
1293
1294                 try {
1295                         new AssemblyName (assemblyName + ", Culture=aa-AA");
1296                         Assert.Fail ("#1");
1297 #if NET_4_0
1298                 } catch (CultureNotFoundException ex) {
1299                 }
1300 #else
1301                 } catch (ArgumentException ex) {
1302                         // Culture name 'aa-aa' is not supported
1303                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1304                         Assert.IsNull (ex.InnerException, "#3");
1305                         Assert.IsNotNull (ex.Message, "#4");
1306                         Assert.IsNotNull (ex.ParamName, "#5");
1307                         Assert.AreEqual ("name", ex.ParamName, "#6");
1308                 }
1309 #endif
1310         }
1311
1312         [Test] // ctor (String)
1313         public void Constructor1_ProcessorArchitecture ()
1314         {
1315                 const string assemblyName = "TestAssembly";
1316
1317                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=X86");
1318                 Assert.IsNull (an.CodeBase, "CodeBase");
1319                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1320                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1321                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1322                 Assert.AreEqual ("TestAssembly", an.FullName, "FullName");
1323                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1324                 Assert.IsNull (an.KeyPair, "KeyPair");
1325                 Assert.AreEqual (assemblyName, an.Name, "Name");
1326                 Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA");
1327                 Assert.IsNull (an.Version, "Version");
1328                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1329                         an.VersionCompatibility, "VersionCompatibility");
1330                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1331                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1332                 Assert.AreEqual ("TestAssembly", an.ToString (), "ToString");
1333
1334                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=mSiL");
1335                 Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "PA: MSIL");
1336
1337                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=AmD64");
1338                 Assert.AreEqual (ProcessorArchitecture.Amd64, an.ProcessorArchitecture, "PA: Amd64");
1339
1340                 an = new AssemblyName (assemblyName + ", ProcessorArchitecture=iA64");
1341                 Assert.AreEqual (ProcessorArchitecture.IA64, an.ProcessorArchitecture, "PA: IA64");
1342         }
1343
1344         [Test] // ctor (String)
1345         public void Constructor1_ProcessorArchitecture_Incomplete ()
1346         {
1347                 const string assemblyName = "TestAssembly";
1348                 try {
1349                         new AssemblyName (assemblyName + ", ProcessorArchitecture=");
1350                         Assert.Fail ("#1");
1351                 } catch (FileLoadException ex) {
1352                         // The given assembly name or codebase was invalid
1353                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1354                         Assert.IsNull (ex.FileName, "#3");
1355                         Assert.IsNull (ex.InnerException, "#3");
1356                         Assert.IsNotNull (ex.Message, "#4");
1357                 }
1358         }
1359
1360         [Test] // ctor (String)
1361         public void Constructor1_ProcessorArchitecture_Invalid ()
1362         {
1363                 const string assemblyName = "TestAssembly";
1364                 try {
1365                         new AssemblyName (assemblyName + ", ProcessorArchitecture=XXX");
1366                         Assert.Fail ("#A1");
1367                 } catch (FileLoadException ex) {
1368                         // The given assembly name or codebase was invalid
1369                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1370                         Assert.IsNull (ex.FileName, "#A3");
1371                         Assert.IsNull (ex.InnerException, "#A4");
1372                         Assert.IsNotNull (ex.Message, "#A5");
1373                 }
1374
1375                 try {
1376                         new AssemblyName (assemblyName + ", ProcessorArchitecture=None");
1377                         Assert.Fail ("#B1");
1378                 } catch (FileLoadException ex) {
1379                         // The given assembly name or codebase was invalid
1380                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1381                         Assert.IsNull (ex.FileName, "#B3");
1382                         Assert.IsNull (ex.InnerException, "#B4");
1383                         Assert.IsNotNull (ex.Message, "#B5");
1384                 }
1385         }
1386
1387         [Test] // ctor (String)
1388         [Category ("NotDotNet")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1389         public void Constructor1_PublicKey_Mono ()
1390         {
1391                 const string assemblyName = "TestAssembly";
1392
1393                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1394                 Assert.IsNull (an.CodeBase, "CodeBase");
1395                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1396                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1397                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags");
1398                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1399                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1400                 Assert.IsNull (an.KeyPair, "KeyPair");
1401                 Assert.AreEqual (assemblyName, an.Name, "Name");
1402                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1403                 Assert.IsNull (an.Version, "Version");
1404                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1405                         an.VersionCompatibility, "VersionCompatibility");
1406                 Assert.AreEqual (publicKey1, an.GetPublicKey (), "GetPublicKey");
1407                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1408                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1409         }
1410
1411         [Test]
1412         [Category ("NotWorking")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088
1413         public void Constructor1_PublicKey_MS ()
1414         {
1415                 const string assemblyName = "TestAssembly";
1416
1417                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1));
1418                 Assert.IsNull (an.CodeBase, "CodeBase");
1419                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1420                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1421                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1422                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName");
1423                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1424                 Assert.IsNull (an.KeyPair, "KeyPair");
1425                 Assert.AreEqual (assemblyName, an.Name, "Name");
1426                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1427                 Assert.IsNull (an.Version, "Version");
1428                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1429                         an.VersionCompatibility, "VersionCompatibility");
1430                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1431                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken");
1432                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1433         }
1434
1435         [Test] // ctor (String)
1436         [Category ("NotWorking")] // bug #351725
1437         public void Constructor1_PublicKey_Ecma ()
1438         {
1439                 const string assemblyName = "TestAssembly";
1440
1441                 an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey3));
1442                 Assert.IsNull (an.CodeBase, "CodeBase");
1443                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1444                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1445                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1446                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "FullName");
1447                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1448                 Assert.IsNull (an.KeyPair, "KeyPair");
1449                 Assert.AreEqual (assemblyName, an.Name, "Name");
1450                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1451                 Assert.IsNull (an.Version, "Version");
1452                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1453                         an.VersionCompatibility, "VersionCompatibility");
1454                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1455                 Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "GetPublicKeyToken");
1456                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1457         }
1458
1459         [Test] // ctor (String)
1460         public void Constructor1_PublicKey_Incomplete ()
1461         {
1462                 const string assemblyName = "TestAssembly";
1463
1464                 try {
1465                         new AssemblyName (assemblyName + ", PublicKey=");
1466                         Assert.Fail ("#1");
1467                 } catch (FileLoadException ex) {
1468                         // The given assembly name or codebase was invalid
1469                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1470                         Assert.IsNull (ex.FileName, "#3");
1471                         Assert.IsNull (ex.InnerException, "#3");
1472                         Assert.IsNotNull (ex.Message, "#4");
1473                 }
1474         }
1475
1476         [Test] // ctor (String)
1477         public void Constructor1_PublicKey_Invalid ()
1478         {
1479                 const string assemblyName = "TestAssembly";
1480
1481                 try {
1482                         new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e");
1483                         Assert.Fail ("#A1");
1484                 } catch (FileLoadException ex) {
1485                         // The given assembly name or codebase was invalid
1486                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1487                         Assert.IsNull (ex.FileName, "#A3");
1488                         Assert.IsNull (ex.InnerException, "#A4");
1489                         Assert.IsNotNull (ex.Message, "#A5");
1490                 }
1491
1492                 try {
1493                         new AssemblyName (assemblyName + ", PublicKey=null");
1494                         Assert.Fail ("#B1");
1495                 } catch (FileLoadException ex) {
1496                         // The given assembly name or codebase was invalid
1497                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1498                         Assert.IsNull (ex.FileName, "#B3");
1499                         Assert.IsNull (ex.InnerException, "#B4");
1500                         Assert.IsNotNull (ex.Message, "#B5");
1501                 }
1502         }
1503
1504         [Test] // ctor (String)
1505         [Category ("NotWorking")] // bug #351756
1506         public void Constructor1_PublicKey_KeyPair ()
1507         {
1508                 const string assemblyName = "TestAssembly";
1509
1510                 try {
1511                         new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (keyPair));
1512                         Assert.Fail ("#1");
1513                 } catch (SecurityException ex) {
1514                         // Invalid assembly public key
1515                         Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#2");
1516                         Assert.AreEqual ((SecurityAction) 0, ex.Action, "#3");
1517                         Assert.IsNull (ex.InnerException, "#4");
1518                         Assert.IsNotNull (ex.Message, "#5");
1519                 }
1520         }
1521
1522         [Test] // ctor (String)
1523         public void Constructor1_PublicKeyToken ()
1524         {
1525                 const string assemblyName = "TestAssembly";
1526
1527                 an = new AssemblyName (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1));
1528                 Assert.IsNull (an.CodeBase, "#A:CodeBase");
1529                 Assert.IsNull (an.CultureInfo, "#A:CultureInfo");
1530                 Assert.IsNull (an.EscapedCodeBase, "#A:EscapedCodeBase");
1531                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A:Flags");
1532                 Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A:FullName");
1533                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#A:HashAlgorithm");
1534                 Assert.IsNull (an.KeyPair, "#A:KeyPair");
1535                 Assert.AreEqual (assemblyName, an.Name, "#A:Name");
1536                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#A:PA");
1537                 Assert.IsNull (an.Version, "#A:Version");
1538                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1539                         an.VersionCompatibility, "#A:VersionCompatibility");
1540                 Assert.IsNull (an.GetPublicKey (), "#A:GetPublicKey");
1541                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A:GetPublicKeyToken");
1542                 Assert.AreEqual (an.FullName, an.ToString (), "#A:ToString");
1543
1544                 an = new AssemblyName (assemblyName + ", PublicKeyToken=null");
1545                 Assert.IsNull (an.CodeBase, "#B:CodeBase");
1546                 Assert.IsNull (an.CultureInfo, "#B:CultureInfo");
1547                 Assert.IsNull (an.EscapedCodeBase, "#B:EscapedCodeBase");
1548                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B:Flags");
1549                 //Assert.AreEqual ("TestAssembly, PublicKeyToken=null", an.FullName, "#B:FullName");
1550                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#B:HashAlgorithm");
1551                 Assert.IsNull (an.KeyPair, "#B:KeyPair");
1552                 Assert.AreEqual (assemblyName, an.Name, "#B:Name");
1553                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#B:PA");
1554                 Assert.IsNull (an.Version, "#B:Version");
1555                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1556                         an.VersionCompatibility, "#B:VersionCompatibility");
1557                 Assert.IsNull (an.GetPublicKey (), "#B:GetPublicKey");
1558                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#B:GetPublicKeyToken");
1559                 Assert.AreEqual (an.FullName, an.ToString (), "#B:ToString");
1560         }
1561
1562         [Test] // ctor (String)
1563         public void Constructor1_PublicKeyToken_Incomplete ()
1564         {
1565                 const string assemblyName = "TestAssembly";
1566
1567                 try {
1568                         new AssemblyName (assemblyName + ", PublicKeyToken=");
1569                         Assert.Fail ("#1");
1570                 } catch (FileLoadException ex) {
1571                         // The given assembly name or codebase was invalid
1572                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1573                         Assert.IsNull (ex.FileName, "#3");
1574                         Assert.IsNull (ex.InnerException, "#3");
1575                         Assert.IsNotNull (ex.Message, "#4");
1576                 }
1577         }
1578
1579         [Test] // ctor (String)
1580         public void Constructor1_PublicKeyToken_Invalid ()
1581         {
1582                 const string assemblyName = "TestAssembly";
1583
1584                 try {
1585                         new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188");
1586                         Assert.Fail ("#1");
1587                 } catch (FileLoadException ex) {
1588                         // The given assembly name or codebase was invalid
1589                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1590                         Assert.IsNull (ex.FileName, "#3");
1591                         Assert.IsNull (ex.InnerException, "#3");
1592                         Assert.IsNotNull (ex.Message, "#4");
1593                 }
1594         }
1595
1596         [Test] // ctor (String)
1597         public void Constructor1_Retargetable ()
1598         {
1599                 const string assemblyName = "TestAssembly";
1600
1601                 try {
1602                         new AssemblyName (assemblyName + ", Retargetable=Yes");
1603                         Assert.Fail ("#A1");
1604                 } catch (FileLoadException ex) {
1605                         // The given assembly name or codebase was invalid
1606                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1607                         Assert.IsNull (ex.FileName, "#A3");
1608                         Assert.IsNull (ex.InnerException, "#A4");
1609                         Assert.IsNotNull (ex.Message, "#A5");
1610                 }
1611
1612                 try {
1613                         new AssemblyName (assemblyName + ", Retargetable=No");
1614                         Assert.Fail ("#B1");
1615                 } catch (FileLoadException ex) {
1616                         // The given assembly name or codebase was invalid
1617                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1618                         Assert.IsNull (ex.FileName, "#B3");
1619                         Assert.IsNull (ex.InnerException, "#B4");
1620                         Assert.IsNotNull (ex.Message, "#B5");
1621                 }
1622
1623                 try {
1624                         new AssemblyName (assemblyName + ", Version=1.0.0.0, Retargetable=Yes");
1625                         Assert.Fail ("#C1");
1626                 } catch (FileLoadException ex) {
1627                         // The given assembly name or codebase was invalid
1628                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2");
1629                         Assert.IsNull (ex.FileName, "#C3");
1630                         Assert.IsNull (ex.InnerException, "#C4");
1631                         Assert.IsNotNull (ex.Message, "#C5");
1632                 }
1633
1634                 try {
1635                         new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, Retargetable=Yes");
1636                         Assert.Fail ("#D1");
1637                 } catch (FileLoadException ex) {
1638                         // The given assembly name or codebase was invalid
1639                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#D2");
1640                         Assert.IsNull (ex.FileName, "#D3");
1641                         Assert.IsNull (ex.InnerException, "#D4");
1642                         Assert.IsNotNull (ex.Message, "#D5");
1643                 }
1644
1645                 try {
1646                         new AssemblyName (assemblyName + ", Version=1.0.0.0, PublicKeyToken=null, Retargetable=Yes");
1647                         Assert.Fail ("#E1");
1648                 } catch (FileLoadException ex) {
1649                         // The given assembly name or codebase was invalid
1650                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#E2");
1651                         Assert.IsNull (ex.FileName, "#E3");
1652                         Assert.IsNull (ex.InnerException, "#E4");
1653                         Assert.IsNotNull (ex.Message, "#E5");
1654                 }
1655
1656                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=yEs");
1657                 Assert.IsNull (an.CodeBase, "F:CodeBase");
1658                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#F:CultureInfo");
1659                 Assert.IsNull (an.EscapedCodeBase, "#F:EscapedCodeBase");
1660                 Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#F:Flags");
1661                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=Yes", an.FullName, "#F:FullName");
1662                 Assert.IsNull (an.GetPublicKey (), "#F:GetPublicKey");
1663                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#F:GetPublicKeyToken");
1664                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#F:HashAlgorithm");
1665                 Assert.IsNull (an.KeyPair, "#F:KeyPair");
1666                 Assert.AreEqual (assemblyName, an.Name, "#F:Name");
1667                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#F:PA");
1668                 Assert.AreEqual (an.FullName, an.ToString (), "#F:ToString");
1669                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#F:Version");
1670                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1671                         an.VersionCompatibility, "#F:VersionCompatibility");
1672
1673                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=nO");
1674                 Assert.IsNull (an.CodeBase, "G:CodeBase");
1675                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#G:CultureInfo");
1676                 Assert.IsNull (an.EscapedCodeBase, "#G:EscapedCodeBase");
1677                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#G:Flags");
1678                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", an.FullName, "#G:FullName");
1679                 Assert.IsNull (an.GetPublicKey (), "#G:GetPublicKey");
1680                 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#G:GetPublicKeyToken");
1681                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#G:HashAlgorithm");
1682                 Assert.IsNull (an.KeyPair, "#G:KeyPair");
1683                 Assert.AreEqual (assemblyName, an.Name, "#G:Name");
1684                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#G:PA");
1685                 Assert.AreEqual (an.FullName, an.ToString (), "#G:ToString");
1686                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#G:Version");
1687                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1688                         an.VersionCompatibility, "#G:VersionCompatibility");
1689
1690                 an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=yes");
1691                 Assert.IsNull (an.CodeBase, "H:CodeBase");
1692                 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#H:CultureInfo");
1693                 Assert.IsNull (an.EscapedCodeBase, "#H:EscapedCodeBase");
1694                 Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#H:Flags");
1695                 Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=Yes", an.FullName, "#H:FullName");
1696                 Assert.IsNull (an.GetPublicKey (), "#H:GetPublicKey");
1697                 Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#H:GetPublicKeyToken");
1698                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#H:HashAlgorithm");
1699                 Assert.IsNull (an.KeyPair, "#H:KeyPair");
1700                 Assert.AreEqual (assemblyName, an.Name, "#H:Name");
1701                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#H:PA");
1702                 Assert.AreEqual (an.FullName, an.ToString (), "#H:ToString");
1703                 Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#H:Version");
1704                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1705                         an.VersionCompatibility, "#H:VersionCompatibility");
1706         }
1707
1708         [Test] // ctor (String)
1709         public void Constructor1_Retargetable_Incomplete ()
1710         {
1711                 const string assemblyName = "TestAssembly";
1712
1713                 try {
1714                         new AssemblyName (assemblyName + ", Retargetable=");
1715                         Assert.Fail ("#1");
1716                 } catch (FileLoadException ex) {
1717                         // The given assembly name or codebase was invalid
1718                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1719                         Assert.IsNull (ex.FileName, "#3");
1720                         Assert.IsNull (ex.InnerException, "#4");
1721                         Assert.IsNotNull (ex.Message, "#5");
1722                 }
1723         }
1724
1725         [Test] // ctor (String)
1726         public void Constructor1_Retargetable_Invalid ()
1727         {
1728                 const string assemblyName = "TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
1729
1730                 try {
1731                         new AssemblyName (assemblyName + ", Retargetable=False");
1732                         Assert.Fail ("#A1");
1733                 } catch (FileLoadException ex) {
1734                         // The given assembly name or codebase was invalid
1735                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2");
1736                         Assert.IsNull (ex.FileName, "#A3");
1737                         Assert.IsNull (ex.InnerException, "#A4");
1738                         Assert.IsNotNull (ex.Message, "#A5");
1739                 }
1740
1741                 try {
1742                         new AssemblyName (assemblyName + ", Retargetable=1");
1743                         Assert.Fail ("#B1");
1744                 } catch (FileLoadException ex) {
1745                         // The given assembly name or codebase was invalid
1746                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2");
1747                         Assert.IsNull (ex.FileName, "#B3");
1748                         Assert.IsNull (ex.InnerException, "#B4");
1749                         Assert.IsNotNull (ex.Message, "#B5");
1750                 }
1751
1752                 try {
1753                         new AssemblyName (assemblyName + ", Retargetable=True");
1754                         Assert.Fail ("#C1");
1755                 } catch (FileLoadException ex) {
1756                         // The given assembly name or codebase was invalid
1757                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2");
1758                         Assert.IsNull (ex.FileName, "#C3");
1759                         Assert.IsNull (ex.InnerException, "#C4");
1760                         Assert.IsNotNull (ex.Message, "#C5");
1761                 }
1762         }
1763
1764         [Test] // ctor (String)
1765         public void Constructor1_Version ()
1766         {
1767                 const string assemblyName = "TestAssembly";
1768                 const string assemblyVersion = "1.2.3.4";
1769
1770                 an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion);
1771                 Assert.IsNull (an.CodeBase, "CodeBase");
1772                 Assert.IsNull (an.CultureInfo, "CultureInfo");
1773                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
1774                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
1775                 Assert.AreEqual ("TestAssembly, Version=1.2.3.4", an.FullName, "FullName");
1776                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
1777                 Assert.IsNull (an.KeyPair, "KeyPair");
1778                 Assert.AreEqual (assemblyName, an.Name, "Name");
1779                 Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA");
1780                 Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version");
1781                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
1782                         an.VersionCompatibility, "VersionCompatibility");
1783                 Assert.IsNull (an.GetPublicKey (), "GetPublicKey");
1784                 Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken");
1785                 Assert.AreEqual (an.FullName, an.ToString (), "ToString");
1786         }
1787
1788
1789         [Test] // ctor (String)
1790         public void Constructor1_Version_Incomplete ()
1791         {
1792                 const string assemblyName = "TestAssembly";
1793
1794                 try {
1795                         new AssemblyName (assemblyName + ", Version=, Culture=neutral");
1796                         Assert.Fail ("#1");
1797                 } catch (FileLoadException ex) {
1798                         // The given assembly name or codebase was invalid
1799                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1800                         Assert.IsNull (ex.FileName, "#3");
1801                         Assert.IsNull (ex.InnerException, "#3");
1802                         Assert.IsNotNull (ex.Message, "#4");
1803                 }
1804         }
1805
1806         [Test] // ctor (String)
1807         public void Constructor1_Version_Invalid ()
1808         {
1809                 const string assemblyName = "TestAssembly";
1810
1811                 try {
1812                         new AssemblyName (assemblyName + ", Version=a.b");
1813                         Assert.Fail ("#1");
1814                 } catch (FileLoadException ex) {
1815                         // The given assembly name or codebase was invalid
1816                         Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2");
1817                         Assert.IsNull (ex.FileName, "#3");
1818                         Assert.IsNull (ex.InnerException, "#3");
1819                         Assert.IsNotNull (ex.Message, "#4");
1820                 }
1821         }
1822
1823         [Test (Description="Xamarin bug #99 - whitespaces in key=value")]
1824         public void WhiteSpaceInKeyValue ()
1825         {
1826                 string nameWithSpaces = String.Format ("MySql.Data.Tests, PublicKey      = \t  {0},  Culture   =\tneutral, Version=\t1.2.3.4", GetTokenString (publicKey1));
1827                 string fullName = "MySql.Data.Tests, Version=1.2.3.4, Culture=neutral, PublicKeyToken=ce5276d8687ec6dc";
1828                 var an = new AssemblyName (nameWithSpaces);
1829
1830                 Assert.AreEqual (fullName, an.FullName);
1831         }
1832
1833         [Test]
1834         public void ReferenceMatchesDefinition_Compares_Only_SimpleName ()
1835         {
1836                 var an1 = new AssemblyName ("TestDll, Version=1.0.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089");
1837                 var an2 = new AssemblyName ("TestDll, Version=2.0.0.2001, Culture=en-US, PublicKeyToken=ab7a5c561934e089");
1838
1839                 var an3 = new AssemblyName ("TestDll");
1840                 var an4 = new AssemblyName ("tesTDlL");
1841
1842                 var an5 = new AssemblyName ("TestDll");
1843                 var an6 = new AssemblyName ("TestDll2");
1844
1845                 Assert.IsTrue (AssemblyName.ReferenceMatchesDefinition (an1, an2));
1846                 Assert.IsTrue (AssemblyName.ReferenceMatchesDefinition (an3, an4));
1847                 Assert.IsFalse (AssemblyName.ReferenceMatchesDefinition (an5, an6));
1848         }
1849
1850         [Test]
1851         public void CultureNameInvariant ()
1852         {
1853                 var an = new AssemblyName ("TestDll");
1854                 an.CultureInfo = new CultureInfo (CultureInfo.InvariantCulture.LCID);
1855
1856                 Assert.AreEqual ("", an.CultureName);
1857         }
1858 }
1859
1860 }