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