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

   1 //
   2 // AssemblyNameTest.cs - NUnit Test Cases for AssemblyName
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2002 Motus Technologies Inc. (http://www.motus.com)
   8 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13 using System.Configuration.Assemblies;
  14 using System.IO;
  15 using System.Reflection;
  16 #if !TARGET_JVM
  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
  25 namespace MonoTests.System.Reflection {
  26
  27 [TestFixture]
  28 public class AssemblyNameTest {
  29         static public void AssertEqualsByteArrays (string msg, byte[] array1, byte[] array2)
  30         {
  31                 if ((array1 == null) && (array2 == null))
  32                         return;
  33                 if (array1 == null)
  34                         Assert.Fail (msg + " -> First array is NULL");
  35                 if (array2 == null)
  36                         Assert.Fail (msg + " -> Second array is NULL");
  37
  38                 bool a = (array1.Length == array2.Length);
  39                 if (a) {
  40                         for (int i = 0; i < array1.Length; i++) {
  41                                 if (array1 [i] != array2 [i]) {
  42                                         a = false;
  43                                         break;
  44                                 }
  45                         }
  46                 }
  47                 msg += " -> Expected " + (array1.Length > 0 ? BitConverter.ToString (array1, 0) : "<empty>");
  48                 msg += " is different than " + (array2.Length > 0 ? BitConverter.ToString (array2, 0) : "<empty>");
  49                 Assert.IsTrue (a, msg);
  50         }
  51
  52         private AssemblyName an;
  53
  54         private string tempDir = Path.Combine (Path.GetTempPath (), "MonoTests.System.Reflection.AssemblyNameTest");
  55
  56 #if !TARGET_JVM // Thread.GetDomain is not supported for TARGET_JVM.
  57         private AppDomain domain;
  58 #endif // TARGET_JVM
  59
  60         // created with "sn -o test.snk test.txt"
  61         static byte[] publicKey = { 0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x3D, 0xBD, 0x72, 0x08, 0xC6, 0x2B, 0x0E, 0xA8, 0xC1, 0xC0, 0x58, 0x07, 0x2B, 0x63, 0x5F, 0x7C, 0x9A, 0xBD, 0xCB, 0x22, 0xDB, 0x20, 0xB2, 0xA9, 0xDA, 0xDA, 0xEF, 0xE8, 0x00, 0x64, 0x2F, 0x5D, 0x8D, 0xEB, 0x78, 0x02, 0xF7, 0xA5, 0x36, 0x77, 0x28, 0xD7, 0x55, 0x8D, 0x14, 0x68, 0xDB, 0xEB, 0x24, 0x09, 0xD0, 0x2B, 0x13, 0x1B, 0x92, 0x6E, 0x2E, 0x59, 0x54, 0x4A, 0xAC, 0x18, 0xCF, 0xC9, 0x09, 0x02, 0x3F, 0x4F, 0xA8, 0x3E, 0x94, 0x00, 0x1F, 0xC2, 0xF1, 0x1A, 0x27, 0x47, 0x7D, 0x10, 0x84, 0xF5, 0x14, 0xB8, 0x61, 0x62, 0x1A, 0x0C, 0x66, 0xAB, 0xD2, 0x4C, 0x4B, 0x9F, 0xC9, 0x0F, 0x3C, 0xD8, 0x92, 0x0F, 0xF5, 0xFF, 0xCE, 0xD7, 0x6E, 0x5C, 0x6F, 0xB1, 0xF5, 0x7D, 0xD3, 0x56, 0xF9, 0x67, 0x27, 0xA4, 0xA5, 0x48, 0x5B, 0x07, 0x93, 0x44, 0x00, 0x4A, 0xF8, 0xFF, 0xA4, 0xCB, 0x73, 0xC0, 0x6A, 0x62, 0xB4, 0xB7, 0xC8, 0x92, 0x58, 0x87, 0xCD, 0x07,
  62                 0x0C, 0x7D, 0x6C, 0xC1, 0x4A, 0xFC, 0x82, 0x57, 0x0E, 0x43, 0x85, 0x09, 0x75, 0x98, 0x51, 0xBB, 0x35, 0xF5, 0x64, 0x83, 0xC7, 0x79, 0x89, 0x5C, 0x55, 0x36, 0x66, 0xAB, 0x27, 0xA4, 0xD9, 0xD4, 0x7E, 0x6B, 0x67, 0x64, 0xC1, 0x54, 0x4E, 0x37, 0xF1, 0x4E, 0xCA, 0xB3, 0xE5, 0x63, 0x91, 0x57, 0x12, 0x14, 0xA6, 0xEA, 0x8F, 0x8F, 0x2B, 0xFE, 0xF3, 0xE9, 0x16, 0x08, 0x2B, 0x86, 0xBC, 0x26, 0x0D, 0xD0, 0xC6, 0xC4, 0x1A, 0x72, 0x43, 0x76, 0xDC, 0xFF, 0x28, 0x52, 0xA1, 0xDE, 0x8D, 0xFA, 0xD5, 0x1F, 0x0B, 0xB5, 0x4F, 0xAF, 0x06, 0x79, 0x11, 0xEE, 0xA8, 0xEC, 0xD3, 0x74, 0x55, 0xA2, 0x80, 0xFC, 0xF8, 0xD9, 0x50, 0x69, 0x48, 0x01, 0xC2, 0x5A, 0x04, 0x56, 0xB4, 0x3E, 0x24, 0x32, 0x20, 0xB5, 0x2C, 0xDE, 0xBB, 0xBD, 0x13, 0xFD, 0x13, 0xF7, 0x03, 0x3E, 0xE3, 0x37, 0x84, 0x74, 0xE7, 0xD0, 0x5E, 0x9E, 0xB6, 0x26, 0xAE, 0x6E, 0xB0, 0x55, 0x6A, 0x52, 0x63, 0x6F, 0x5A, 0x9D, 0xF2, 0x67, 0xD6, 0x61, 0x4F, 0x7A, 0x45, 0xEE, 0x5C, 0x3D, 0x2B, 0x7C, 0xB2, 0x40, 0x79, 0x54, 0x84, 0xD1,
  63                 0xBE, 0x61, 0x3E, 0x5E, 0xD6, 0x18, 0x8E, 0x14, 0x98, 0xFC, 0x35, 0xBF, 0x5F, 0x1A, 0x20, 0x2E, 0x1A, 0xD8, 0xFF, 0xC4, 0x6B, 0xC0, 0xC9, 0x7D, 0x06, 0xEF, 0x09, 0xF9, 0xF3, 0x69, 0xFC, 0xBC, 0xA2, 0xE6, 0x80, 0x22, 0xB9, 0x79, 0x7E, 0xEF, 0x57, 0x9F, 0x49, 0xE1, 0xBC, 0x0D, 0xB6, 0xA1, 0xFE, 0x8D, 0xBC, 0xBB, 0xA3, 0x05, 0x02, 0x6B, 0x04, 0x45, 0xF7, 0x5D, 0xEE, 0x43, 0x06, 0xD6, 0x9C, 0x94, 0x48, 0x1A, 0x0B, 0x9C, 0xBC, 0xB4, 0x4E, 0x93, 0x60, 0x87, 0xCD, 0x58, 0xD6, 0x9A, 0x39, 0xA6, 0xC0, 0x7F, 0x8E, 0xFF, 0x25, 0xC1, 0xD7, 0x2C, 0xF6, 0xF4, 0x6F, 0x24, 0x52, 0x0B, 0x39, 0x42, 0x1B, 0x0D, 0x04, 0xC1, 0x93, 0x2A, 0x19, 0x1C, 0xF0, 0xB1, 0x9B, 0xC1, 0x24, 0x6D, 0x1B, 0x0B, 0xDA, 0x1C, 0x8B, 0x72, 0x48, 0xF0, 0x3E, 0x52, 0xBF, 0x0A, 0x84, 0x3A, 0x9B, 0xC8, 0x6D, 0x13, 0x1E, 0x72, 0xF4, 0x46, 0x93, 0x88, 0x1A, 0x5F, 0x4C, 0x3C, 0xE5, 0x9D, 0x6E, 0xBB, 0x4E, 0xDD, 0x5D, 0x1F, 0x11, 0x40, 0xF4, 0xD7, 0xAF, 0xB3, 0xAB, 0x9A, 0x99, 0x15, 0xF0, 0xDC, 0xAA, 0xFF,
  64                 0x9F, 0x2D, 0x9E, 0x56, 0x4F, 0x35, 0x5B, 0xBA, 0x06, 0x99, 0xEA, 0xC6, 0xB4, 0x48, 0x51, 0x17, 0x1E, 0xD1, 0x95, 0x84, 0x81, 0x18, 0xC0, 0xF1, 0x71, 0xDE, 0x44, 0x42, 0x02, 0x06, 0xAC, 0x0E, 0xA8, 0xE2, 0xF3, 0x1F, 0x96, 0x1F, 0xBE, 0xB6, 0x1F, 0xB5, 0x3E, 0xF6, 0x81, 0x05, 0x20, 0xFA, 0x2E, 0x40, 0x2E, 0x4D, 0xA0, 0x0E, 0xDA, 0x42, 0x9C, 0x05, 0xAA, 0x9E, 0xAF, 0x5C, 0xF7, 0x3A, 0x3F, 0xBB, 0x91, 0x73, 0x45, 0x27, 0xA8, 0xA2, 0x07, 0x4A, 0xEF, 0x59, 0x1E, 0x97, 0x9D, 0xE0, 0x30, 0x5A, 0x83, 0xCE, 0x1E, 0x57, 0x32, 0x89, 0x43, 0x41, 0x28, 0x7D, 0x14, 0x8D, 0x8B, 0x41, 0x1A, 0x56, 0x76, 0x43, 0xDB, 0x64, 0x86, 0x41, 0x64, 0x8D, 0x4C, 0x91, 0x83, 0x4E, 0xF5, 0x6C };
  65
  66         static byte[] token = { 0xFF, 0xEF, 0x94, 0x53, 0x67, 0x69, 0xDA, 0x06 };
  67
  68         [SetUp]
  69         public void SetUp ()
  70         {
  71                 try {
  72                         if (Directory.Exists (tempDir))
  73                                 Directory.Delete (tempDir, true);
  74                 }
  75                 catch (Exception) {
  76                 }
  77
  78                 Directory.CreateDirectory (tempDir);
  79
  80 #if !TARGET_JVM // Thread.GetDomain is not supported for TARGET_JVM.
  81                 domain = Thread.GetDomain ();
  82 #endif // TARGET_JVM
  83         }
  84
  85         [TearDown]
  86         public void TearDown ()
  87         {
  88                 try {
  89                         if (Directory.Exists (tempDir))
  90                                 Directory.Delete (tempDir, true);
  91                 }
  92                 catch (Exception) {
  93                         // This can happen on windows when the directory contains
  94                         // files opened by the CLR
  95                 }
  96         }
  97
  98         [Test]
  99 #if NET_2_0
 100         [Category ("NotWorking")]
 101 #endif
 102         public void EmptyAssembly ()
 103         {
 104                 an = new AssemblyName ();
 105                 Assert.IsNull (an.CodeBase, "CodeBase");
 106                 Assert.IsNull (an.CultureInfo, "CultureInfo");
 107                 Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase");
 108                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
 109 #if NET_2_0
 110                 Assert.AreEqual (String.Empty, an.FullName, "FullName");
 111 #else
 112                 Assert.IsNull (an.FullName, "FullName");
 113 #endif
 114                 Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm");
 115                 Assert.IsNull (an.KeyPair, "KeyPair");
 116                 Assert.IsNull (an.Name, "Name");
 117                 Assert.IsNull (an.Version, "Version");
 118                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
 119                         an.VersionCompatibility, "VersionCompatibility");
 120         }
 121
 122         [Test]
 123 #if NET_2_0
 124         [Category ("NotWorking")]
 125         [ExpectedException (typeof (SecurityException))]
 126 #endif
 127         public void PublicKey ()
 128         {
 129                 an = new AssemblyName ();
 130                 Assert.IsNull (an.GetPublicKey (), "PublicKey(empty)");
 131                 an.SetPublicKey (publicKey);
 132
 133                 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags");
 134                 // strangly it doesn't affect the KeyPair ?
 135                 Assert.IsNull (an.KeyPair, "KeyPair");
 136                 AssertEqualsByteArrays ("PublicKey", publicKey, an.GetPublicKey ());
 137                 AssertEqualsByteArrays ("PublicKeyToken", token, an.GetPublicKeyToken ());
 138         }
 139
 140         [Test]
 141         public void PublicKeyToken ()
 142         {
 143                 an = new AssemblyName ();
 144                 an.SetPublicKeyToken (token);
 145
 146                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
 147                 Assert.IsNull (an.KeyPair, "KeyPair");
 148                 Assert.IsNull (an.GetPublicKey (), "PublicKey");
 149                 AssertEqualsByteArrays ("PublicKeyToken", token, an.GetPublicKeyToken ());
 150         }
 151
 152         [Test]
 153         public void KeyPair ()
 154         {
 155                 an = new AssemblyName ();
 156                 an.KeyPair = new StrongNameKeyPair (publicKey);
 157
 158                 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags");
 159                 Assert.IsNotNull (an.KeyPair, "KeyPair");
 160                 Assert.IsNull (an.GetPublicKey (), "PublicKey");
 161                 Assert.IsNull (an.GetPublicKeyToken (), "PublicKeyToken");
 162         }
 163
 164         // !!! this assembly MUST NOT use a StrongName !!!
 165         [Test]
 166         [Category ("NotWorking")] // in other cases null is returned
 167         public void Self ()
 168         {
 169                 Assembly a = Assembly.GetExecutingAssembly ();
 170                 AssemblyName an = a.GetName ();
 171
 172                 Assert.IsNotNull (an.GetPublicKey (), "PublicKey(self)");
 173                 Assert.AreEqual (0, an.GetPublicKey ().Length, "PublicKey.Length");
 174         }
 175
 176         [Test]
 177         public void FullName1 ()
 178         {
 179                 // !!! we assume the mscorlib has a strong name !!!
 180                 AssemblyName an = typeof(int).Assembly.GetName ();
 181                 Assert.IsNotNull (an.FullName, "FullName1#1");
 182                 Assert.IsTrue (an.FullName.IndexOf ("Version=") != -1, "FullName1#2");
 183                 Assert.IsTrue (an.FullName.IndexOf("Culture=") != -1, "FullName1#3");
 184                 Assert.IsTrue (an.FullName.IndexOf ("PublicKeyToken=") != -1, "FullName1#4");
 185         }
 186
 187         [Test]
 188         public void FullName2 ()
 189         {
 190                 const string assemblyName = "TestAssembly";
 191
 192                 // tests for AssemblyName with only name
 193                 AssemblyName an = new AssemblyName ();
 194                 an.Name = assemblyName;
 195                 Assert.IsNotNull (an.FullName, "FullName2#1");
 196                 Assert.AreEqual (an.Name, an.FullName, "FullName2#2");
 197                 Assert.AreEqual (-1, an.FullName.IndexOf ("Culture="), "FullName2#3");
 198                 Assert.AreEqual (-1, an.FullName.IndexOf ("PublicKeyToken="), "FullName2#4");
 199         }
 200
 201         [Test]
 202         public void FullName3 ()
 203         {
 204                 const string assemblyName = "TestAssembly";
 205                 const string assemblyVersion = "1.2";
 206
 207                 // tests for AssemblyName with name and version
 208                 AssemblyName an = new AssemblyName ();
 209                 an.Name = assemblyName;
 210                 an.Version = new Version (assemblyVersion);
 211                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion, an.FullName, "FullName3#1");
 212         }
 213
 214         [Test]
 215         public void FullName4 ()
 216         {
 217                 const string assemblyName = "TestAssembly";
 218
 219                 // tests for AssemblyName with name and neutral culture
 220                 AssemblyName an = new AssemblyName ();
 221                 an.Name = assemblyName;
 222                 an.CultureInfo = CultureInfo.InvariantCulture;
 223                 Assert.AreEqual (assemblyName + ", Culture=neutral", an.FullName, "FullName4#1");
 224         }
 225
 226         [Test]
 227 #if NET_2_0
 228         [Category ("NotWorking")]
 229         [ExpectedException (typeof (SecurityException))]
 230 #endif
 231         public void FullName5 ()
 232         {
 233                 const string assemblyName = "TestAssembly";
 234
 235                 // tests for AssemblyName with name and public key
 236                 AssemblyName an = new AssemblyName ();
 237                 an.Name = assemblyName;
 238                 an.SetPublicKey (publicKey);
 239                 Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString(token), an.FullName, "FullName5#1");
 240         }
 241
 242         [Test]
 243         public void FullName6 ()
 244         {
 245                 const string assemblyName = "TestAssembly";
 246                 const string assemblyVersion = "1.2";
 247
 248                 // tests for AssemblyName with name, version and neutral culture
 249                 AssemblyName an = new AssemblyName ();
 250                 an.Name = assemblyName;
 251                 an.Version = new Version (assemblyVersion);
 252                 an.CultureInfo = CultureInfo.InvariantCulture;
 253                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 254                         + ", Culture=neutral", an.FullName, "FullName6#1");
 255         }
 256
 257         [Test]
 258 #if NET_2_0
 259         [Category ("NotWorking")]
 260         [ExpectedException (typeof (SecurityException))]
 261 #endif
 262         public void FullName7 ()
 263         {
 264                 const string assemblyName = "TestAssembly";
 265                 const string assemblyVersion = "1.2";
 266
 267                 // tests for AssemblyName with name, version and public key
 268                 AssemblyName an = new AssemblyName ();
 269                 an.Name = assemblyName;
 270                 an.Version = new Version (assemblyVersion);
 271                 an.SetPublicKey (publicKey);
 272                 Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion
 273                         + ", PublicKeyToken=" + GetTokenString (token),
 274                         an.FullName, "FullName7#1");
 275         }
 276
 277         [Test]
 278 #if NET_2_0
 279         [Category ("NotWorking")]
 280         [ExpectedException (typeof (SecurityException))]
 281 #endif
 282         public void FullName8 ()
 283         {
 284                 const string assemblyName = "TestAssembly";
 285
 286                 // tests for AssemblyName with name, culture and public key
 287                 AssemblyName an = new AssemblyName ();
 288                 an.Name = assemblyName;
 289                 an.CultureInfo = CultureInfo.InvariantCulture;
 290                 an.SetPublicKey (publicKey);
 291                 Assert.AreEqual (assemblyName + ", Culture=neutral"
 292                         + ", PublicKeyToken=" + GetTokenString (token),
 293                         an.FullName, "FullName8#1");
 294         }
 295
 296         static int nameIndex = 0;
 297
 298         private AssemblyName GenAssemblyName ()
 299         {
 300                 AssemblyName assemblyName = new AssemblyName();
 301                 assemblyName.Name = "MonoTests.System.Reflection.AssemblyNameTest" + (nameIndex ++);
 302                 return assemblyName;
 303         }
 304
 305 #if !TARGET_JVM // Reflection.Emit is not supported for TARGET_JVM.
 306         private Assembly GenerateAssembly (AssemblyName name)
 307         {
 308                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 309                         name,
 310                         AssemblyBuilderAccess.RunAndSave,
 311                         tempDir);
 312                 ab.DefineDynamicModule ("def_module");
 313                 ab.Save (name.Name + ".dll");
 314
 315                 return Assembly.LoadFrom (Path.Combine (tempDir, name.Name + ".dll"));
 316         }
 317
 318         private AssemblyBuilder GenerateDynamicAssembly (AssemblyName name)
 319         {
 320                 AssemblyBuilder ab = domain.DefineDynamicAssembly (
 321                                 name,
 322                                 AssemblyBuilderAccess.Run);
 323
 324                 return ab;
 325         }
 326
 327         [Test]
 328         public void TestCultureInfo ()
 329         {
 330                 AssemblyName name;
 331                 Assembly a;
 332                 CultureInfo culture;
 333
 334                 name = GenAssemblyName ();
 335                 name.CultureInfo = CultureInfo.CreateSpecificCulture ("ar-DZ");
 336                 a = GenerateAssembly (name);
 337                 culture = a.GetName ().CultureInfo;
 338                 Assert.IsFalse (culture.IsNeutralCulture, "#A1");
 339                 Assert.IsFalse (culture.IsReadOnly, "#A2");
 340                 Assert.AreEqual (5121, culture.LCID, "#A3");
 341                 Assert.AreEqual ("ar-DZ", culture.Name, "#A4");
 342                 Assert.IsTrue (culture.UseUserOverride, "#A5");
 343
 344                 name = GenAssemblyName ();
 345                 name.CultureInfo = new CultureInfo ("en");
 346                 a = GenerateAssembly (name);
 347                 culture = a.GetName ().CultureInfo;
 348                 Assert.IsTrue (culture.IsNeutralCulture, "#B1");
 349                 Assert.IsFalse (culture.IsReadOnly, "#B2");
 350                 Assert.AreEqual (9, culture.LCID, "#B3");
 351                 Assert.AreEqual ("en", culture.Name, "#B4");
 352                 Assert.IsTrue (culture.UseUserOverride, "#B5");
 353
 354                 name = GenAssemblyName ();
 355                 name.CultureInfo = CultureInfo.InvariantCulture;
 356                 a = GenerateAssembly (name);
 357                 culture = a.GetName ().CultureInfo;
 358                 Assert.IsFalse (culture.IsNeutralCulture, "#C1");
 359 #if NET_2_0
 360                 Assert.IsFalse (culture.IsReadOnly, "#C2");
 361 #else
 362                 Assert.IsTrue (culture.IsReadOnly, "#C2");
 363 #endif
 364                 Assert.AreEqual (127, culture.LCID, "#C3");
 365                 Assert.AreEqual (string.Empty, culture.Name, "#C4");
 366                 Assert.IsFalse (culture.UseUserOverride, "#C5");
 367
 368                 a = typeof (int).Assembly;
 369                 name = a.GetName ();
 370                 culture = name.CultureInfo;
 371                 Assert.IsFalse (culture.IsNeutralCulture, "#D1");
 372 #if NET_2_0
 373                 Assert.IsFalse (culture.IsReadOnly, "#D2");
 374 #else
 375                 Assert.IsTrue (culture.IsReadOnly, "#D2");
 376 #endif
 377                 Assert.AreEqual (127, culture.LCID, "#D3");
 378                 Assert.AreEqual (string.Empty, culture.Name, "#D4");
 379                 Assert.IsFalse (culture.UseUserOverride, "#D5");
 380
 381                 a = Assembly.GetExecutingAssembly ();
 382                 name = a.GetName ();
 383                 culture = name.CultureInfo;
 384                 Assert.IsFalse (culture.IsNeutralCulture, "#E1");
 385 #if NET_2_0
 386                 Assert.IsFalse (culture.IsReadOnly, "#E2");
 387 #else
 388                 Assert.IsTrue (culture.IsReadOnly, "#E2");
 389 #endif
 390                 Assert.AreEqual (127, culture.LCID, "#E3");
 391                 Assert.AreEqual (string.Empty, culture.Name, "#E4");
 392                 Assert.IsFalse (culture.UseUserOverride, "#E5");
 393
 394                 AssemblyName [] names = a.GetReferencedAssemblies ();
 395                 foreach (AssemblyName an in names) {
 396                         culture = an.CultureInfo;
 397                         Assert.IsFalse (culture.IsNeutralCulture, "#F1:" + an.Name);
 398                         Assert.IsFalse (culture.IsReadOnly, "#F2:" + an.Name);
 399                         Assert.AreEqual (127, culture.LCID, "#F3:" + an.Name);
 400                         Assert.AreEqual (string.Empty, culture.Name, "#F4:" + an.Name);
 401 #if NET_2_0
 402                         Assert.IsFalse (culture.UseUserOverride, "#F5:" + an.Name);
 403 #else
 404                         Assert.IsTrue (culture.UseUserOverride, "#F5:" + an.Name);
 405 #endif
 406                 }
 407         }
 408
 409         [Test]
 410         public void Version ()
 411         {
 412                 AssemblyName name = GenAssemblyName ();
 413                 name.Version = new Version (1, 2, 3, 4);
 414
 415                 Assembly a = GenerateAssembly (name);
 416                 Assert.AreEqual ("1.2.3.4", a.GetName ().Version.ToString (), "1.2.3.4 normal");
 417
 418                 name = GenAssemblyName ();
 419                 name.Version = new Version (1, 2, 3);
 420
 421                 a = GenerateAssembly (name);
 422                 Assert.AreEqual ("1.2.3.0", a.GetName ().Version.ToString (), "1.2.3.0 normal");
 423
 424                 name = GenAssemblyName ();
 425                 name.Version = new Version (1, 2);
 426
 427                 a = GenerateAssembly (name);
 428                 Assert.AreEqual ("1.2.0.0", a.GetName ().Version.ToString (), "1.2.0.0 normal");
 429         }
 430
 431         [Test]
 432         [Category ("NotWorking")]
 433         public void Version_Dynamic ()
 434         {
 435                 AssemblyName name = GenAssemblyName ();
 436                 name.Version = new Version (1, 2, 3, 4);
 437
 438                 AssemblyBuilder ab = GenerateDynamicAssembly (name);
 439                 Assert.AreEqual ("1.2.3.4", ab.GetName ().Version.ToString (), "1.2.3.4 dynamic");
 440
 441                 name = GenAssemblyName ();
 442                 name.Version = new Version (1, 2, 3);
 443
 444                 ab = GenerateDynamicAssembly (name);
 445 #if NET_2_0
 446                 Assert.AreEqual ("1.2.3.0", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
 447 #else
 448                 Assert.AreEqual ("1.2.3.65535", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic");
 449 #endif
 450
 451                 name = GenAssemblyName ();
 452                 name.Version = new Version (1, 2);
 453
 454                 ab = GenerateDynamicAssembly (name);
 455 #if NET_2_0
 456                 Assert.AreEqual ("1.2.0.0", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
 457 #else
 458                 Assert.AreEqual ("1.2.65535.65535", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic");
 459 #endif
 460         }
 461 #endif // TARGET_JVM
 462
 463         [Test]
 464         public void HashAlgorithm ()
 465         {
 466                 Assert.AreEqual (AssemblyHashAlgorithm.SHA1,
 467                         typeof (int).Assembly.GetName ().HashAlgorithm);
 468         }
 469
 470         [Test]
 471         public void Serialization ()
 472         {
 473                 AssemblyName an = new AssemblyName ();
 474                 an.CodeBase = "http://www.test.com/test.dll";
 475                 an.CultureInfo = CultureInfo.InvariantCulture;
 476                 an.Flags = AssemblyNameFlags.PublicKey;
 477                 an.HashAlgorithm = AssemblyHashAlgorithm.MD5;
 478                 an.KeyPair = new StrongNameKeyPair (publicKey);
 479                 an.Name = "TestAssembly";
 480                 an.Version = new Version (1, 5);
 481                 an.VersionCompatibility = AssemblyVersionCompatibility.SameProcess;
 482
 483                 MemoryStream ms = new MemoryStream ();
 484                 BinaryFormatter bf = new BinaryFormatter ();
 485                 bf.Serialize (ms, an);
 486
 487                 // reset position of memorystream
 488                 ms.Position = 0;
 489
 490                 // deserialze assembly name
 491                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
 492
 493                 // close the memorystream
 494                 ms.Close ();
 495
 496                 // compare orginal and deserialized assembly name
 497                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
 498                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
 499                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
 500                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
 501                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
 502                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
 503                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
 504                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
 505                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
 506                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
 507                 AssertEqualsByteArrays ("PublicKey", an.GetPublicKey (), dsAssemblyName.GetPublicKey ());
 508                 AssertEqualsByteArrays ("PublicToken", an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken ());
 509         }
 510
 511         [Test]
 512         public void Serialization_WithoutStrongName ()
 513         {
 514                 AssemblyName an = new AssemblyName ();
 515                 an.CodeBase = "http://www.test.com/test.dll";
 516                 an.CultureInfo = CultureInfo.InvariantCulture;
 517                 an.Flags = AssemblyNameFlags.None;
 518                 an.HashAlgorithm = AssemblyHashAlgorithm.SHA1;
 519                 an.KeyPair = null;
 520                 an.Name = "TestAssembly2";
 521                 an.Version = new Version (1, 5, 0, 0);
 522                 an.VersionCompatibility = AssemblyVersionCompatibility.SameMachine;
 523
 524                 MemoryStream ms = new MemoryStream ();
 525                 BinaryFormatter bf = new BinaryFormatter ();
 526                 bf.Serialize (ms, an);
 527
 528                 // reset position of memorystream
 529                 ms.Position = 0;
 530
 531                 // deserialze assembly name
 532                 AssemblyName dsAssemblyName = (AssemblyName) bf.Deserialize (ms);
 533
 534                 // close the memorystream
 535                 ms.Close ();
 536
 537                 // compare orginal and deserialized assembly name
 538                 Assert.AreEqual (an.CodeBase, dsAssemblyName.CodeBase, "CodeBase");
 539                 Assert.AreEqual (an.CultureInfo, dsAssemblyName.CultureInfo, "CultureInfo");
 540                 Assert.AreEqual (an.Flags, dsAssemblyName.Flags, "Flags");
 541                 Assert.AreEqual (an.HashAlgorithm, dsAssemblyName.HashAlgorithm, "HashAlgorithm");
 542                 Assert.AreEqual (an.Name, dsAssemblyName.Name, "Name");
 543                 Assert.AreEqual (an.Version, dsAssemblyName.Version, "Version");
 544                 Assert.AreEqual (an.VersionCompatibility, dsAssemblyName.VersionCompatibility, "VersionCompatibility");
 545                 Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase");
 546                 Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName");
 547                 Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString");
 548                 AssertEqualsByteArrays ("PublicKey", an.GetPublicKey (), dsAssemblyName.GetPublicKey ());
 549                 AssertEqualsByteArrays ("PublicToken", an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken ());
 550         }
 551
 552 #if !TARGET_JVM // Assemblyname.GetObjectData not implemented yet for TARGET_JVM
 553         [Test]
 554         [ExpectedException (typeof (ArgumentNullException))]
 555         public void GetObjectData_Null ()
 556         {
 557                 AssemblyName an = new AssemblyName ();
 558                 an.GetObjectData (null, new StreamingContext (StreamingContextStates.All));
 559         }
 560 #endif // TARGET_JVM
 561
 562         [Test]
 563 #if NET_2_0
 564         [Category ("NotWorking")]
 565 #endif
 566         public void Clone_Empty ()
 567         {
 568                 an = new AssemblyName ();
 569                 AssemblyName clone = (AssemblyName) an.Clone ();
 570
 571                 Assert.IsNull (clone.CodeBase, "CodeBase");
 572                 Assert.IsNull (clone.CultureInfo, "CultureInfo");
 573                 Assert.IsNull (clone.EscapedCodeBase, "EscapedCodeBase");
 574                 Assert.AreEqual (AssemblyNameFlags.None, clone.Flags, "Flags");
 575 #if NET_2_0
 576                 Assert.AreEqual (String.Empty, clone.FullName, "FullName");
 577 #else
 578                 Assert.IsNull (clone.FullName, "FullName");
 579 #endif
 580                 Assert.AreEqual (AssemblyHashAlgorithm.None, clone.HashAlgorithm, "HashAlgorithm");
 581                 Assert.IsNull (clone.KeyPair, "KeyPair");
 582                 Assert.IsNull (clone.Name, "Name");
 583                 Assert.IsNull (clone.Version, "Version");
 584                 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine,
 585                         clone.VersionCompatibility, "VersionCompatibility");
 586         }
 587
 588         [Test]
 589         public void Clone_Self ()
 590         {
 591                 an = Assembly.GetExecutingAssembly ().GetName ();
 592                 AssemblyName clone = (AssemblyName) an.Clone ();
 593
 594                 Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase");
 595                 Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo");
 596                 Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase");
 597                 Assert.AreEqual (an.Flags, clone.Flags, "Flags");
 598                 Assert.AreEqual (an.FullName, clone.FullName, "FullName");
 599                 Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm");
 600                 Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair");
 601                 Assert.AreEqual (an.Name, clone.Name, "Name");
 602                 Assert.AreEqual (an.Version, clone.Version, "Version");
 603                 Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility");
 604         }
 605
 606         [Test]
 607         [ExpectedException (typeof (FileNotFoundException))]
 608         public void GetAssemblyName_AssemblyFile_DoesNotExist ()
 609         {
 610                 AssemblyName.GetAssemblyName (Path.Combine (tempDir, "doesnotexist.dll"));
 611         }
 612
 613         [Test]
 614         [Category ("NotWorking")]
 615         public void GetAssemblyName_AssemblyFile_LoadFailure ()
 616         {
 617                 string file = Path.Combine (tempDir, "loadfailure.dll");
 618                 using (FileStream fs = File.Open (file, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None)) {
 619                         try {
 620                                 AssemblyName.GetAssemblyName (file);
 621                                 Assert.Fail ("#1");
 622                         } catch (FileLoadException ex) {
 623                         }
 624                 }
 625                 File.Delete (file);
 626         }
 627
 628         [Test]
 629         public void GetAssemblyName_AssemblyFile_BadImage ()
 630         {
 631                 string file = Path.Combine (tempDir, "badimage.dll");
 632                 using (StreamWriter sw = File.CreateText (file)) {
 633                         sw.WriteLine ("somegarbage");
 634                 }
 635                 try {
 636                         AssemblyName.GetAssemblyName (file);
 637                         Assert.Fail ("#1");
 638                 } catch (BadImageFormatException ex) {
 639                 }
 640                 File.Delete (file);
 641         }
 642
 643         [Test]
 644         public void GetAssemblyName_CodeBase ()
 645         {
 646                 Assembly execAssembly = Assembly.GetExecutingAssembly ();
 647
 648                 AssemblyName aname = AssemblyName.GetAssemblyName (execAssembly.Location);
 649                 Assert.IsNotNull (aname.CodeBase, "#1");
 650                 Assert.AreEqual (execAssembly.CodeBase, aname.CodeBase, "#2");
 651         }
 652
 653         // helpers
 654
 655         private string GetTokenString (byte[] value)
 656         {
 657                 string tokenString = "";
 658                 for (int i = 0; i < value.Length; i++) {
 659                         tokenString += value[i].ToString ("x2");
 660                 }
 661                 return tokenString;
 662         }
 663
 664 #if NET_2_0
 665         [Test]
 666         [Category ("NotWorking")]
 667         public void Ctor1 ()
 668         {
 669                 const string assemblyName = "TestAssembly";
 670                 AssemblyName an = new AssemblyName (assemblyName);
 671                 Assert.IsNotNull (an.Name, "Ctor1#1");
 672                 Assert.AreEqual (an.Name, assemblyName, "Ctor1#2");
 673                 Assert.IsNull (an.Version, "Ctor1#3");
 674                 Assert.IsNull (an.CultureInfo, "Ctor1#4");
 675                 Assert.IsNull (an.GetPublicKeyToken (), "Ctor1#5");
 676         }
 677
 678         [Test]
 679         [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM.
 680         public void Ctor2 ()
 681         {
 682                 const string assemblyName = "TestAssembly";
 683                 const string assemblyVersion = "1.2.3.4";
 684                 AssemblyName an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion);
 685                 Assert.IsNotNull (an.Name, "Ctor2#1");
 686                 Assert.AreEqual (an.Name, assemblyName, "Ctor2#2");
 687                 Assert.IsNotNull (an.Version, "Ctor2#3");
 688                 Assert.AreEqual (an.Version, new Version (assemblyVersion), "Ctor2#4");
 689                 Assert.IsNull (an.CultureInfo, "Ctor2#5");
 690                 Assert.IsNull (an.GetPublicKeyToken (), "Ctor2#6");
 691         }
 692
 693         [Test]
 694         [Category ("NotWorking")]
 695         public void Ctor3 ()
 696         {
 697                 const string assemblyName = "TestAssembly";
 698                 const string assemblyCulture = "en-US";
 699                 AssemblyName an = new AssemblyName (assemblyName + ", Culture=" + assemblyCulture);
 700                 Assert.IsNotNull (an.Name, "Ctor3#1");
 701                 Assert.AreEqual (an.Name, assemblyName, "Ctor3#2");
 702                 Assert.IsNotNull (an.CultureInfo, "Ctor3#3");
 703                 Assert.AreEqual (an.CultureInfo, new CultureInfo (assemblyCulture), "Ctor3#4");
 704                 Assert.IsNull (an.Version, "Ctor3#5");
 705                 Assert.IsNull (an.GetPublicKeyToken (), "Ctor3#6");
 706         }
 707
 708         [Test]
 709         [Category ("NotWorking")]
 710         public void Ctor4 ()
 711         {
 712                 const string assemblyName = "TestAssembly";
 713                 byte [] assemblyKeyToken;
 714                 AssemblyName an = new AssemblyName (assemblyName + ", PublicKeyToken=" + GetTokenString (token));
 715                 Assert.IsNotNull (an.Name, "Ctor4#1");
 716                 Assert.AreEqual (an.Name, assemblyName, "Ctor4#2");
 717                 Assert.IsNotNull (assemblyKeyToken = an.GetPublicKeyToken (), "Ctor4#3");
 718                 Assert.AreEqual (assemblyKeyToken, token, "Ctor4#4");
 719                 Assert.IsNull (an.Version, "Ctor4#5");
 720                 Assert.IsNull (an.CultureInfo, "Ctor4#6");
 721         }
 722
 723         [Test]
 724         [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM.
 725         public void Ctor5 ()
 726         {
 727                 const string assemblyName = "TestAssembly";
 728                 const string assemblyCulture = "neutral";
 729                 const string assemblyVersion = "1.2.3.4";
 730                 byte [] assemblyKeyToken;
 731
 732                 AssemblyName an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion +
 733                                 ", Culture=" + assemblyCulture + ", PublicKeyToken=" + GetTokenString (token));
 734                 Assert.IsNotNull (an.Name, "Ctor5#1");
 735                 Assert.AreEqual (an.Name, assemblyName, "Ctor5#2");
 736                 Assert.IsNotNull (an.CultureInfo, "Ctor5#3");
 737                 Assert.AreEqual (an.CultureInfo, new CultureInfo (""), "Ctor5#4");
 738                 Assert.IsNotNull (an.Version, "Ctor5#5");
 739                 Assert.AreEqual (an.Version, new Version (assemblyVersion), "Ctor5#6");
 740                 Assert.IsNotNull (assemblyKeyToken = an.GetPublicKeyToken (), "Ctor5#7");
 741                 Assert.AreEqual (assemblyKeyToken, token, "Ctor5#8");
 742         }
 743
 744         [Test]
 745         [Category ("NotWorking")]
 746         public void Ctor6 ()
 747         {
 748                 const string assemblyName = "TestAssembly";
 749                 AssemblyName an = null;
 750
 751                 // null argument
 752                 try {
 753                         an = new AssemblyName (null);
 754                 } catch (ArgumentNullException) {
 755                 }
 756                 Assert.IsNull (an, "Ctor6#1");
 757
 758                 // empty string
 759                 an = null;
 760                 try {
 761                         an = new AssemblyName ("");
 762                 } catch (ArgumentException) {
 763                 }
 764                 Assert.IsNull (an, "Ctor6#2");
 765
 766                 // incomplete entry
 767                 an = null;
 768                 try {
 769                         an = new AssemblyName (assemblyName + ", Version=,Culture=neutral");
 770                 } catch (FileLoadException) {
 771                 }
 772                 Assert.IsNull (an, "Ctor6#3");
 773
 774                 // bad format for version
 775                 an = null;
 776                 try {
 777                         an = new AssemblyName (assemblyName + ", Version=a.b");
 778                 } catch (FileLoadException) {
 779                 }
 780                 Assert.IsNull (an, "Ctor6#4");
 781
 782                 // bad culture info
 783                 an = null;
 784                 try {
 785                         an = new AssemblyName (assemblyName + ", Culture=aa-AA");
 786                 } catch (ArgumentException) {
 787                 }
 788                 Assert.IsNull (an, "Ctor6#5");
 789
 790                 // incorrect length for key token
 791                 an = null;
 792                 try {
 793                         an = new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188");
 794                 } catch (FileLoadException) {
 795                 }
 796                 Assert.IsNull (an, "Ctor6#6");
 797
 798                 // Incorrect length for key
 799                 an = null;
 800                 try {
 801                         an = new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e");
 802                 } catch (FileLoadException) {
 803                 }
 804                 Assert.IsNull (an, "Ctor6#7");
 805
 806                 // missing spec
 807                 an = null;
 808                 try {
 809                         an = new AssemblyName (assemblyName + ", =1.2.4.5");
 810                 } catch (FileLoadException) {
 811                 }
 812                 Assert.IsNull (an, "Ctor6#8");
 813
 814                 // No '=' found
 815                 an = null;
 816                 try {
 817                         an = new AssemblyName (assemblyName + ", OtherAttribute");
 818                 } catch (FileLoadException) {
 819                 }
 820                 Assert.IsNull (an, "Ctor6#9");
 821         }
 822
 823 #endif
 824 }
 825
 826 }