X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2Fcorlib%2FTest%2FSystem.Reflection%2FAssemblyNameTest.cs;h=ae086137d5a0d5f89ba151be1d902d0ff6d564df;hb=5ad1099341581dee94f77b32db728918e90fa64f;hp=73b29df048dc9f396fa844d4e2fcf39873505180;hpb=d49951ccf584ba637afb1dab7fff714478e3174d;p=mono.git diff --git a/mcs/class/corlib/Test/System.Reflection/AssemblyNameTest.cs b/mcs/class/corlib/Test/System.Reflection/AssemblyNameTest.cs index 73b29df048d..ae086137d5a 100644 --- a/mcs/class/corlib/Test/System.Reflection/AssemblyNameTest.cs +++ b/mcs/class/corlib/Test/System.Reflection/AssemblyNameTest.cs @@ -13,53 +13,134 @@ using System; using System.Configuration.Assemblies; using System.IO; using System.Reflection; +#if !TARGET_JVM && !MOBILE using System.Reflection.Emit; +#endif using System.Runtime.Serialization; using System.Threading; using System.Globalization; using System.Runtime.Serialization.Formatters.Binary; using System.Security; +using System.Security.Permissions; namespace MonoTests.System.Reflection { [TestFixture] public class AssemblyNameTest { - static public void AssertEqualsByteArrays (string msg, byte[] array1, byte[] array2) - { - if ((array1 == null) && (array2 == null)) - return; - if (array1 == null) - Assert.Fail (msg + " -> First array is NULL"); - if (array2 == null) - Assert.Fail (msg + " -> Second array is NULL"); - - bool a = (array1.Length == array2.Length); - if (a) { - for (int i = 0; i < array1.Length; i++) { - if (array1 [i] != array2 [i]) { - a = false; - break; - } - } - } - msg += " -> Expected " + (array1.Length > 0 ? BitConverter.ToString (array1, 0) : ""); - msg += " is different than " + (array2.Length > 0 ? BitConverter.ToString (array2, 0) : ""); - Assert.IsTrue (a, msg); - } - private AssemblyName an; private string tempDir = Path.Combine (Path.GetTempPath (), "MonoTests.System.Reflection.AssemblyNameTest"); +#if !TARGET_JVM // Thread.GetDomain is not supported for TARGET_JVM. private AppDomain domain; +#endif // TARGET_JVM // created with "sn -o test.snk test.txt" - 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, - 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, - 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, - 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 }; - - static byte[] token = { 0xFF, 0xEF, 0x94, 0x53, 0x67, 0x69, 0xDA, 0x06 }; + static byte[] keyPair = { + 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, + 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, 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, 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 }; + + static byte [] publicKey1 = { + 0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00, + 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, + 0x52, 0x53, 0x41, 0x31, 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 }; + + static byte [] pk_token1 = { 0xce, 0x52, 0x76, 0xd8, 0x68, 0x7e, 0Xc6, 0xdc }; + + static byte [] publicKey2 = { + 0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00, + 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, + 0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x6d, 0xfd, 0xba, 0xb9, 0x9d, 0x43, 0xf1, 0xef, + 0x33, 0xe2, 0xbd, 0x2d, 0x7c, 0x26, 0xe2, 0x9d, 0x37, 0x4a, + 0xdf, 0xb5, 0x63, 0x12, 0x90, 0x35, 0x90, 0x24, 0x8a, 0xe7, + 0x5a, 0xc5, 0xa3, 0x3a, 0x84, 0xee, 0x9b, 0xd1, 0xac, 0x3a, + 0x59, 0x2b, 0x91, 0x97, 0x83, 0x01, 0x4f, 0x92, 0x01, 0xc6, + 0x3b, 0x96, 0x20, 0x19, 0xeb, 0xdc, 0x2c, 0x6f, 0x1f, 0xbb, + 0x04, 0x9b, 0x62, 0x39, 0xc0, 0xff, 0x58, 0x64, 0x17, 0x48, + 0xc2, 0x5b, 0x94, 0x98, 0x35, 0x50, 0x1f, 0x27, 0xbc, 0xea, + 0x91, 0x92, 0x3f, 0x5c, 0x33, 0x12, 0x17, 0x65, 0x56, 0x3e, + 0x40, 0x44, 0x27, 0x1d, 0xef, 0x0e, 0x72, 0xab, 0xd4, 0xf0, + 0x49, 0xa3, 0x95, 0x1a, 0x61, 0xb4, 0x47, 0x90, 0x20, 0xcc, + 0x50, 0xa4, 0x4d, 0x8b, 0x8a, 0x58, 0x17, 0x70, 0xa4, 0x53, + 0xe4, 0xdc, 0x73, 0x5d, 0x8c, 0x4e, 0xb8, 0xd3, 0xa9, 0xbf }; + + static byte [] publicKey3 = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + + static byte [] pk_token3 = { 0xb7, 0x7a, 0x5c, 0x56, 0x19, 0x34, 0xe0, 0x89 }; [SetUp] public void SetUp () @@ -73,7 +154,9 @@ public class AssemblyNameTest { Directory.CreateDirectory (tempDir); +#if !TARGET_JVM // Thread.GetDomain is not supported for TARGET_JVM. domain = Thread.GetDomain (); +#endif // TARGET_JVM } [TearDown] @@ -89,102 +172,267 @@ public class AssemblyNameTest { } } - [Test] -#if NET_2_0 - [Category ("NotWorking")] -#endif - public void EmptyAssembly () + [Test] // ctor () + public void Constructor0 () { an = new AssemblyName (); Assert.IsNull (an.CodeBase, "CodeBase"); Assert.IsNull (an.CultureInfo, "CultureInfo"); Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); -#if NET_2_0 Assert.AreEqual (String.Empty, an.FullName, "FullName"); -#else - Assert.IsNull (an.FullName, "FullName"); -#endif Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); Assert.IsNull (an.KeyPair, "KeyPair"); Assert.IsNull (an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA"); Assert.IsNull (an.Version, "Version"); Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, an.VersionCompatibility, "VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "GetPublicKey"); + Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (string.Empty, an.ToString (), "ToString"); } [Test] -#if NET_2_0 - [Category ("NotWorking")] - [ExpectedException (typeof (SecurityException))] -#endif - public void PublicKey () + public void SetPublicKey () { an = new AssemblyName (); - Assert.IsNull (an.GetPublicKey (), "PublicKey(empty)"); - an.SetPublicKey (publicKey); + Assert.IsNull (an.GetPublicKey (), "#A1"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A2"); + Assert.IsNull (an.KeyPair, "#A3"); + Assert.IsNull (an.GetPublicKeyToken (), "#A4"); + + an.SetPublicKey (publicKey1); + + Assert.AreEqual (publicKey1, an.GetPublicKey (), "#B1"); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#B2"); + Assert.IsNull (an.KeyPair, "#B3"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B4"); + an.SetPublicKey (keyPair); + Assert.AreEqual (keyPair, an.GetPublicKey (), "#B5"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B6"); + + an.SetPublicKey ((byte []) null); + + Assert.IsNull (an.GetPublicKey (), "#C1"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#C2"); + Assert.IsNull (an.KeyPair, "#C3"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C4"); + + an.SetPublicKey (publicKey1); + an.SetPublicKeyToken (pk_token1); + an.SetPublicKey ((byte []) null); + + Assert.IsNull (an.GetPublicKey (), "#D1"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#D2"); + Assert.IsNull (an.KeyPair, "#D3"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#D4"); + + an.SetPublicKey ((byte []) null); + an.SetPublicKeyToken (pk_token1); + an.SetPublicKey ((byte []) null); + + Assert.IsNull (an.GetPublicKey (), "#E1"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#E2"); + Assert.IsNull (an.KeyPair, "#E3"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#E4"); - Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags"); - // strangly it doesn't affect the KeyPair ? - Assert.IsNull (an.KeyPair, "KeyPair"); - AssertEqualsByteArrays ("PublicKey", publicKey, an.GetPublicKey ()); - AssertEqualsByteArrays ("PublicKeyToken", token, an.GetPublicKeyToken ()); + an = new AssemblyName (); + an.SetPublicKey (publicKey1); + an.SetPublicKey ((byte []) null); + an.SetPublicKeyToken (pk_token1); + an.SetPublicKey ((byte []) null); + + Assert.IsNull (an.GetPublicKey (), "#F1"); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#F2"); + Assert.IsNull (an.KeyPair, "#F3"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#F4"); + + an = new AssemblyName (); + an.SetPublicKey (publicKey1); + an.SetPublicKey ((byte []) null); + an.SetPublicKeyToken (pk_token1); + + Assert.IsNull (an.GetPublicKey (), "#G1"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#G2"); + Assert.IsNull (an.KeyPair, "#G3"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#G4"); + + an = new AssemblyName (); + an.SetPublicKey (new byte [0]); + + Assert.IsNotNull (an.GetPublicKey (), "#H1"); + Assert.AreEqual (0, an.GetPublicKey ().Length, "#H2"); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#H3"); + Assert.IsNull (an.KeyPair, "#H4"); + Assert.IsNotNull (an.GetPublicKeyToken (), "#H5"); + Assert.AreEqual (0, an.GetPublicKeyToken ().Length, "#H6"); + + an = new AssemblyName (); + an.SetPublicKey (publicKey1); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#I1"); + an.SetPublicKey (publicKey1); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#I2"); + + an = new AssemblyName (); + an.SetPublicKey ((byte []) null); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J1"); + an.SetPublicKey ((byte []) null); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#J2"); + an.SetPublicKey ((byte []) null); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J3"); + an.SetPublicKey (publicKey1); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#J4"); + Assert.AreEqual (publicKey1, an.GetPublicKey (), "#J5"); + an.SetPublicKey (publicKey2); + Assert.AreEqual (publicKey2, an.GetPublicKey (), "#J6"); } [Test] - public void PublicKeyToken () + public void SetPublicKey_PublicKey_Invalid () { an = new AssemblyName (); - an.SetPublicKeyToken (token); + an.SetPublicKey (new byte [] { 0x0b, 0x0a }); + Assert.AreEqual (new byte [] { 0x0b, 0x0a }, an.GetPublicKey (), "#1"); + } - Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); - Assert.IsNull (an.KeyPair, "KeyPair"); - Assert.IsNull (an.GetPublicKey (), "PublicKey"); - AssertEqualsByteArrays ("PublicKeyToken", token, an.GetPublicKeyToken ()); + [Test] + public void SetPublicKeyToken () + { + an = new AssemblyName (); + an.SetPublicKeyToken (pk_token1); + + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A1"); + Assert.IsNull (an.KeyPair, "#A2"); + Assert.IsNull (an.GetPublicKey (), "#A3"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A4"); + + an.SetPublicKeyToken ((byte []) null); + + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B1"); + Assert.IsNull (an.KeyPair, "#B2"); + Assert.IsNull (an.GetPublicKey (), "#B3"); + Assert.IsNull (an.GetPublicKeyToken (), "#B4"); + + an.SetPublicKeyToken (new byte [0]); + + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#C1"); + Assert.IsNull (an.KeyPair, "#C2"); + Assert.IsNull (an.GetPublicKey (), "#C3"); + Assert.IsNotNull (an.GetPublicKeyToken (), "#C4"); + Assert.AreEqual (0, an.GetPublicKeyToken ().Length, "#C5"); } [Test] public void KeyPair () { an = new AssemblyName (); - an.KeyPair = new StrongNameKeyPair (publicKey); + an.Name = "test"; + an.KeyPair = new StrongNameKeyPair (keyPair); - Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); - Assert.IsNotNull (an.KeyPair, "KeyPair"); - Assert.IsNull (an.GetPublicKey (), "PublicKey"); - Assert.IsNull (an.GetPublicKeyToken (), "PublicKeyToken"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A1"); + Assert.IsNotNull (an.KeyPair, "#A2"); + Assert.IsNull (an.GetPublicKey (), "#A3"); + Assert.IsNull (an.GetPublicKeyToken (), "#A4"); + Assert.AreEqual ("test", an.FullName, "#A5"); + + an.KeyPair = null; + + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B1"); + Assert.IsNull (an.KeyPair, "#B2"); + Assert.IsNull (an.GetPublicKey (), "#B3"); + Assert.IsNull (an.GetPublicKeyToken (), "#B4"); + Assert.AreEqual ("test", an.FullName, "#B5"); } // !!! this assembly MUST NOT use a StrongName !!! [Test] - [Category ("NotWorking")] // in other cases null is returned - public void Self () + public void Self () + { + Assembly a = Assembly.GetExecutingAssembly (); + an = a.GetName (); + + Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo"); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags"); + Assert.AreEqual (AssemblyHashAlgorithm.SHA1, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.IsNotNull (an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "PA"); + Assert.AreEqual (new Version (0, 0, 0, 0), an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.AreEqual (new byte [0], an.GetPublicKey (), "GetPublicKey"); + Assert.AreEqual (an.FullName, an.ToString (), "ToString"); + } + + [Test] + public void Flags_Corlib () + { + an = typeof (int).Assembly.GetName (); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags); + } + + [Test] + public void Flags_Self () + { + Assembly a = Assembly.GetExecutingAssembly (); + an = a.GetName (); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags); + } + + [Test] + public void FullName_Corlib () + { + an = typeof(int).Assembly.GetName (); + Assert.IsNotNull (an.FullName, "#1"); + + string AssemblyCorlib; +#if MOBILE + AssemblyCorlib = "mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e"; +#elif NET_4_0 + AssemblyCorlib = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"; +#else + AssemblyCorlib = "mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"; +#endif + Assert.AreEqual (AssemblyCorlib, an.FullName, "#2"); + } + + [Test] + public void FullName_Self () { Assembly a = Assembly.GetExecutingAssembly (); - AssemblyName an = a.GetName (); + an = a.GetName (); - Assert.IsNotNull (an.GetPublicKey (), "PublicKey(self)"); - Assert.AreEqual (0, an.GetPublicKey ().Length, "PublicKey.Length"); + Assert.IsNotNull (an.FullName, "#1"); + Assert.IsTrue (an.FullName.IndexOf ("Version=0.0.0.0") != -1, "#2"); + Assert.IsTrue (an.FullName.IndexOf ("Culture=neutral") != -1, "#3"); + Assert.IsTrue (an.FullName.IndexOf ("PublicKeyToken=null") != -1, "#4"); } [Test] - public void FullName1 () + public void FullName_Flags () { - // !!! we assume the mscorlib has a strong name !!! - AssemblyName an = typeof(int).Assembly.GetName (); - Assert.IsNotNull (an.FullName, "FullName1#1"); - Assert.IsTrue (an.FullName.IndexOf ("Version=") != -1, "FullName1#2"); - Assert.IsTrue (an.FullName.IndexOf("Culture=") != -1, "FullName1#3"); - Assert.IsTrue (an.FullName.IndexOf ("PublicKeyToken=") != -1, "FullName1#4"); + const string assemblyName = "TestAssembly"; + + // tests for AssemblyName with only name + an = new AssemblyName (); + an.Flags = AssemblyNameFlags.EnableJITcompileOptimizer | + AssemblyNameFlags.EnableJITcompileTracking | + AssemblyNameFlags.PublicKey | + AssemblyNameFlags.Retargetable; + an.Name = assemblyName; + Assert.AreEqual (assemblyName + ", Retargetable=Yes", an.FullName, "#1"); + an.Flags = AssemblyNameFlags.None; + Assert.AreEqual (assemblyName, an.FullName, "#2"); } [Test] - public void FullName2 () + public void FullName_Name () { const string assemblyName = "TestAssembly"; // tests for AssemblyName with only name - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.Name = assemblyName; Assert.IsNotNull (an.FullName, "FullName2#1"); Assert.AreEqual (an.Name, an.FullName, "FullName2#2"); @@ -193,98 +441,315 @@ public class AssemblyNameTest { } [Test] - public void FullName3 () + public void FullName_Version () { const string assemblyName = "TestAssembly"; const string assemblyVersion = "1.2"; // tests for AssemblyName with name and version - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.Name = assemblyName; an.Version = new Version (assemblyVersion); Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion, an.FullName, "FullName3#1"); } [Test] - public void FullName4 () + public void FullName_Culture () { const string assemblyName = "TestAssembly"; // tests for AssemblyName with name and neutral culture - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.Name = assemblyName; an.CultureInfo = CultureInfo.InvariantCulture; - Assert.AreEqual (assemblyName + ", Culture=neutral", an.FullName, "FullName4#1"); + Assert.AreEqual (assemblyName + ", Culture=neutral", an.FullName, "#1"); + an.CultureInfo = new CultureInfo ("nl-BE"); + Assert.AreEqual (assemblyName + ", Culture=nl-BE", an.FullName, "#2"); + an.Name = null; + Assert.AreEqual (string.Empty, an.FullName, "#3"); } [Test] -#if NET_2_0 - [Category ("NotWorking")] - [ExpectedException (typeof (SecurityException))] -#endif - public void FullName5 () + public void FullName_PublicKey () + { + const string assemblyName = "TestAssembly"; + + // tests for AssemblyName with name and public key + an = new AssemblyName (); + an.Name = assemblyName; + an.SetPublicKey (publicKey1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1"); + an.SetPublicKey ((byte []) null); + Assert.AreEqual (assemblyName, an.FullName, "#A2"); + an.SetPublicKey (new byte [0]); + Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3"); + an.Name = null; + Assert.AreEqual (string.Empty, an.FullName, "#A4"); + + an = new AssemblyName (); + an.HashAlgorithm = AssemblyHashAlgorithm.MD5; + an.Name = assemblyName; + an.SetPublicKey (publicKey1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1"); + an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 }); + Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2"); + an.SetPublicKeyToken ((byte []) null); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B3"); + an.Name = null; + Assert.AreEqual (string.Empty, an.FullName, "#B4"); + + an = new AssemblyName (); + an.HashAlgorithm = AssemblyHashAlgorithm.None; + an.Name = assemblyName; + an.SetPublicKey (publicKey1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1"); + an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 }); + Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#C2"); + an.SetPublicKeyToken ((byte []) null); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C3"); + an.Name = null; + Assert.AreEqual (string.Empty, an.FullName, "#C4"); + + an = new AssemblyName (); + an.Name = assemblyName; + an.SetPublicKey (new byte [0]); + Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1"); + an.Name = null; + Assert.AreEqual (string.Empty, an.FullName, "#D2"); + an.SetPublicKey (publicKey3); + Assert.AreEqual (string.Empty, an.FullName, "#D3"); + an.Name = assemblyName; + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "#D4"); + } + + [Test] + public void FullName_PublicKey_KeyPair () { const string assemblyName = "TestAssembly"; // tests for AssemblyName with name and public key - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.Name = assemblyName; - an.SetPublicKey (publicKey); - Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString(token), an.FullName, "FullName5#1"); + an.SetPublicKey (keyPair); + try { + Assert.Fail ("#A1: " + an.FullName); + } catch (SecurityException ex) { + // Invalid assembly public key + Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#A2"); + Assert.AreEqual ((SecurityAction) 0, ex.Action, "#A3"); + Assert.IsNull (ex.InnerException, "#A4"); + Assert.IsNotNull (ex.Message, "#A5"); + } + + an.SetPublicKeyToken (new byte [0]); + Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#B1"); + + an.SetPublicKeyToken ((byte []) null); + try { + Assert.Fail ("#C1: " + an.FullName); + } catch (SecurityException ex) { + // Invalid assembly public key + Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#C2"); + Assert.AreEqual ((SecurityAction) 0, ex.Action, "#C3"); + Assert.IsNull (ex.InnerException, "#C4"); + Assert.IsNotNull (ex.Message, "#C5"); + } + + an.SetPublicKeyToken (new byte [0]); + Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D1"); + an.SetPublicKey (publicKey1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2"); + an.SetPublicKeyToken ((byte []) null); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3"); } [Test] - public void FullName6 () + public void FullName_PublicKeyToken () + { + const string assemblyName = "TestAssembly"; + + an = new AssemblyName (); + an.Name = assemblyName; + an.SetPublicKeyToken (pk_token1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A1"); + an.SetPublicKeyToken ((byte []) null); + Assert.AreEqual (assemblyName, an.FullName, "#A2"); + an.SetPublicKeyToken (new byte [0]); + Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A3"); + an.SetPublicKeyToken (pk_token1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A4"); + an.Name = null; + Assert.AreEqual (string.Empty, an.FullName, "#A5"); + + an = new AssemblyName (); + an.HashAlgorithm = AssemblyHashAlgorithm.MD5; + an.Name = assemblyName; + an.SetPublicKeyToken (pk_token1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#B1"); + an.SetPublicKeyToken (new byte [] { 0x0a, 0x22 }); + Assert.AreEqual (assemblyName + ", PublicKeyToken=0a22", an.FullName, "#B2"); + an.SetPublicKeyToken ((byte []) null); + Assert.AreEqual (assemblyName, an.FullName, "#B3"); + an.Name = null; + Assert.AreEqual (string.Empty, an.FullName, "#B4"); + + an = new AssemblyName (); + an.Name = assemblyName; + an.SetPublicKey (publicKey1); + an.SetPublicKeyToken (pk_token1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C1"); + an.SetPublicKey ((byte []) null); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C2"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C3"); + an.SetPublicKey (new byte [0]); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#C4"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C5"); + + an = new AssemblyName (); + an.Name = assemblyName; + an.SetPublicKey (publicKey1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D1"); + an.SetPublicKey (new byte [0]); + Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#D2"); + an.SetPublicKeyToken (pk_token1); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D3"); + an.SetPublicKey ((byte []) null); + Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#D4"); + } + + [Test] + public void FullName_VersionCulture () { const string assemblyName = "TestAssembly"; const string assemblyVersion = "1.2"; // tests for AssemblyName with name, version and neutral culture - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.Name = assemblyName; an.Version = new Version (assemblyVersion); an.CultureInfo = CultureInfo.InvariantCulture; - Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion - + ", Culture=neutral", an.FullName, "FullName6#1"); + Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion + + ", Culture=neutral", an.FullName, "#1"); + an.CultureInfo = new CultureInfo ("en-US"); + Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion + + ", Culture=en-US", an.FullName, "#2"); + an.CultureInfo = new CultureInfo ("en"); + Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion + + ", Culture=en", an.FullName, "#3"); } [Test] -#if NET_2_0 - [Category ("NotWorking")] - [ExpectedException (typeof (SecurityException))] -#endif - public void FullName7 () + public void FullName_VersionPublicKey () { const string assemblyName = "TestAssembly"; const string assemblyVersion = "1.2"; // tests for AssemblyName with name, version and public key - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.Name = assemblyName; an.Version = new Version (assemblyVersion); - an.SetPublicKey (publicKey); + an.SetPublicKey (publicKey1); + an.SetPublicKeyToken (pk_token1); Assert.AreEqual (assemblyName + ", Version=" + assemblyVersion - + ", PublicKeyToken=" + GetTokenString (token), - an.FullName, "FullName7#1"); + + ", PublicKeyToken=" + GetTokenString (pk_token1), + an.FullName, "#1"); } [Test] -#if NET_2_0 - [Category ("NotWorking")] - [ExpectedException (typeof (SecurityException))] -#endif - public void FullName8 () + public void FullName_CulturePublicKey () { const string assemblyName = "TestAssembly"; // tests for AssemblyName with name, culture and public key - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.Name = assemblyName; an.CultureInfo = CultureInfo.InvariantCulture; - an.SetPublicKey (publicKey); + an.SetPublicKey (publicKey1); + an.SetPublicKeyToken (pk_token1); Assert.AreEqual (assemblyName + ", Culture=neutral" - + ", PublicKeyToken=" + GetTokenString (token), - an.FullName, "FullName8#1"); + + ", PublicKeyToken=" + GetTokenString (pk_token1), + an.FullName, "#1"); + } + + [Test] + public void GetPublicKeyToken () + { + const string assemblyName = "TestAssembly"; + + an = new AssemblyName (); + an.SetPublicKey (publicKey1); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A1"); + an.SetPublicKey (publicKey2); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A2"); + an.SetPublicKeyToken (new byte [] { 0x0a }); + Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A3"); + an.SetPublicKey (publicKey1); + Assert.AreEqual (new byte [] { 0x0a }, an.GetPublicKeyToken (), "#A4"); + an.SetPublicKeyToken (new byte [0]); + Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A5"); + an.Name = assemblyName; + an.SetPublicKey (publicKey2); + Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A6"); + Assert.AreEqual (assemblyName + ", PublicKeyToken=null", an.FullName, "#A7"); + + an = new AssemblyName (); + an.HashAlgorithm = AssemblyHashAlgorithm.MD5; + an.SetPublicKey (publicKey1); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#B1"); + + an = new AssemblyName (); + an.HashAlgorithm = AssemblyHashAlgorithm.None; + an.SetPublicKey (publicKey1); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#C1"); + + an = new AssemblyName (); + an.SetPublicKeyToken (new byte [0]); + Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#D1"); + an.SetPublicKeyToken (new byte [] { 0x0b, 0xff }); + Assert.AreEqual (new byte [] { 0x0b, 0xff }, an.GetPublicKeyToken (), "#D2"); + an.SetPublicKeyToken ((byte []) null); + Assert.IsNull (an.GetPublicKeyToken (), "#D3"); + + an = new AssemblyName (); + an.SetPublicKey (keyPair); + try { + an.GetPublicKeyToken (); + Assert.Fail ("#E1"); + } catch (SecurityException ex) { + // Invalid assembly public key + Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#E2"); + Assert.AreEqual ((SecurityAction) 0, ex.Action, "#E3"); + Assert.IsNull (ex.InnerException, "#E4"); + Assert.IsNotNull (ex.Message, "#E5"); + } + } + + [Test] + public void GetPublicKeyToken_Corlib () + { + an = typeof (int).Assembly.GetName (); + Assert.IsNotNull (an.GetPublicKeyToken (), "#1"); + Assert.IsTrue (an.GetPublicKeyToken ().Length > 0, "#2"); + } + + [Test] + public void GetPublicGetToken_Ecma () + { + const string assemblyName = "TestAssembly"; + + an = new AssemblyName (); + an.Name = assemblyName; + an.SetPublicKey (publicKey3); + Assert.IsNotNull (an.GetPublicKeyToken (), "#1"); + Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "#2"); + } + + [Test] + public void GetPublicKeyToken_Self () + { + Assembly a = Assembly.GetExecutingAssembly (); + an = a.GetName (); + Assert.AreEqual (new byte [0], an.GetPublicKeyToken ()); } static int nameIndex = 0; @@ -296,6 +761,7 @@ public class AssemblyNameTest { return assemblyName; } +#if !TARGET_JVM && !MOBILE // Reflection.Emit is not supported for TARGET_JVM. private Assembly GenerateAssembly (AssemblyName name) { AssemblyBuilder ab = domain.DefineDynamicAssembly ( @@ -320,11 +786,67 @@ public class AssemblyNameTest { [Test] public void TestCultureInfo () { - AssemblyName name = GenAssemblyName (); + AssemblyName name; + Assembly a; + CultureInfo culture; + + name = GenAssemblyName (); name.CultureInfo = CultureInfo.CreateSpecificCulture ("ar-DZ"); + a = GenerateAssembly (name); + culture = a.GetName ().CultureInfo; + Assert.IsFalse (culture.IsNeutralCulture, "#A1"); + Assert.IsFalse (culture.IsReadOnly, "#A2"); + Assert.AreEqual (5121, culture.LCID, "#A3"); + Assert.AreEqual ("ar-DZ", culture.Name, "#A4"); + Assert.IsTrue (culture.UseUserOverride, "#A5"); - Assembly a = GenerateAssembly (name); - Assert.AreEqual (a.GetName ().CultureInfo.Name, "ar-DZ"); + name = GenAssemblyName (); + name.CultureInfo = new CultureInfo ("en"); + a = GenerateAssembly (name); + culture = a.GetName ().CultureInfo; + Assert.IsTrue (culture.IsNeutralCulture, "#B1"); + Assert.IsFalse (culture.IsReadOnly, "#B2"); + Assert.AreEqual (9, culture.LCID, "#B3"); + Assert.AreEqual ("en", culture.Name, "#B4"); + Assert.IsTrue (culture.UseUserOverride, "#B5"); + + name = GenAssemblyName (); + name.CultureInfo = CultureInfo.InvariantCulture; + a = GenerateAssembly (name); + culture = a.GetName ().CultureInfo; + Assert.IsFalse (culture.IsNeutralCulture, "#C1"); + Assert.IsFalse (culture.IsReadOnly, "#C2"); + Assert.AreEqual (127, culture.LCID, "#C3"); + Assert.AreEqual (string.Empty, culture.Name, "#C4"); + Assert.IsFalse (culture.UseUserOverride, "#C5"); + + a = typeof (int).Assembly; + name = a.GetName (); + culture = name.CultureInfo; + Assert.IsFalse (culture.IsNeutralCulture, "#D1"); + Assert.IsFalse (culture.IsReadOnly, "#D2"); + Assert.AreEqual (127, culture.LCID, "#D3"); + Assert.AreEqual (string.Empty, culture.Name, "#D4"); + Assert.IsFalse (culture.UseUserOverride, "#D5"); + + a = Assembly.GetExecutingAssembly (); + name = a.GetName (); + culture = name.CultureInfo; + Assert.IsFalse (culture.IsNeutralCulture, "#E1"); + Assert.IsFalse (culture.IsReadOnly, "#E2"); + Assert.AreEqual (127, culture.LCID, "#E3"); + Assert.AreEqual (string.Empty, culture.Name, "#E4"); + Assert.IsFalse (culture.UseUserOverride, "#E5"); + + AssemblyName [] names = a.GetReferencedAssemblies (); + foreach (AssemblyName an in names) { + culture = an.CultureInfo; + Assert.IsFalse (culture.IsNeutralCulture, "#F1:" + an.Name); + Assert.IsFalse (culture.IsReadOnly, "#F2:" + an.Name); + Assert.AreEqual (127, culture.LCID, "#F3:" + an.Name); + Assert.AreEqual (string.Empty, culture.Name, "#F4:" + an.Name); + Assert.IsFalse (culture.UseUserOverride, "#F5:" + an.Name); + } } [Test] @@ -350,7 +872,6 @@ public class AssemblyNameTest { } [Test] - [Category ("NotWorking")] public void Version_Dynamic () { AssemblyName name = GenAssemblyName (); @@ -363,22 +884,15 @@ public class AssemblyNameTest { name.Version = new Version (1, 2, 3); ab = GenerateDynamicAssembly (name); -#if NET_2_0 Assert.AreEqual ("1.2.3.0", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic"); -#else - Assert.AreEqual ("1.2.3.65535", ab.GetName ().Version.ToString (), "1.2.3.0 dynamic"); -#endif name = GenAssemblyName (); name.Version = new Version (1, 2); ab = GenerateDynamicAssembly (name); -#if NET_2_0 Assert.AreEqual ("1.2.0.0", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic"); -#else - Assert.AreEqual ("1.2.65535.65535", ab.GetName ().Version.ToString (), "1.2.0.0 dynamic"); -#endif } +#endif // TARGET_JVM [Test] public void HashAlgorithm () @@ -390,12 +904,12 @@ public class AssemblyNameTest { [Test] public void Serialization () { - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.CodeBase = "http://www.test.com/test.dll"; an.CultureInfo = CultureInfo.InvariantCulture; an.Flags = AssemblyNameFlags.PublicKey; an.HashAlgorithm = AssemblyHashAlgorithm.MD5; - an.KeyPair = new StrongNameKeyPair (publicKey); + an.KeyPair = new StrongNameKeyPair (publicKey1); an.Name = "TestAssembly"; an.Version = new Version (1, 5); an.VersionCompatibility = AssemblyVersionCompatibility.SameProcess; @@ -424,14 +938,14 @@ public class AssemblyNameTest { Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase"); Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName"); Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString"); - AssertEqualsByteArrays ("PublicKey", an.GetPublicKey (), dsAssemblyName.GetPublicKey ()); - AssertEqualsByteArrays ("PublicToken", an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken ()); + Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey"); + Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken"); } [Test] public void Serialization_WithoutStrongName () { - AssemblyName an = new AssemblyName (); + an = new AssemblyName (); an.CodeBase = "http://www.test.com/test.dll"; an.CultureInfo = CultureInfo.InvariantCulture; an.Flags = AssemblyNameFlags.None; @@ -465,22 +979,51 @@ public class AssemblyNameTest { Assert.AreEqual (an.EscapedCodeBase, dsAssemblyName.EscapedCodeBase, "EscapedCodeBase"); Assert.AreEqual (an.FullName, dsAssemblyName.FullName, "FullName"); Assert.AreEqual (an.ToString (), dsAssemblyName.ToString (), "ToString"); - AssertEqualsByteArrays ("PublicKey", an.GetPublicKey (), dsAssemblyName.GetPublicKey ()); - AssertEqualsByteArrays ("PublicToken", an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken ()); + Assert.AreEqual (an.GetPublicKey (), dsAssemblyName.GetPublicKey (), "PublicKey"); + Assert.AreEqual (an.GetPublicKeyToken (), dsAssemblyName.GetPublicKeyToken (), "PublicToken"); } +#if !TARGET_JVM // Assemblyname.GetObjectData not implemented yet for TARGET_JVM [Test] - [ExpectedException (typeof (ArgumentNullException))] - public void GetObjectData_Null () + public void GetObjectData_Info_Null () { - AssemblyName an = new AssemblyName (); - an.GetObjectData (null, new StreamingContext (StreamingContextStates.All)); + an = new AssemblyName (); + try { + an.GetObjectData (null, new StreamingContext (StreamingContextStates.All)); + Assert.Fail ("#1"); + } catch (ArgumentNullException ex) { + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNotNull (ex.ParamName, "#5"); + Assert.AreEqual ("info", ex.ParamName, "#6"); + } + } +#endif // TARGET_JVM + + [Test] + public void Clone_Corlib () + { + an = typeof (int).Assembly.GetName (); + AssemblyName clone = (AssemblyName) an.Clone (); + + Assert.AreEqual (an.CodeBase, clone.CodeBase, "CodeBase"); + Assert.AreEqual (an.CultureInfo, clone.CultureInfo, "CultureInfo"); + Assert.AreEqual (an.EscapedCodeBase, clone.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (an.Flags, clone.Flags, "Flags"); + Assert.AreEqual (an.FullName, clone.FullName, "FullName"); + Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm"); + Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair"); + Assert.AreEqual (an.Name, clone.Name, "Name"); + //Assert.AreEqual (an.ProcessorArchitecture, clone.ProcessorArchitecture, "PA"); + Assert.AreEqual (an.Version, clone.Version, "Version"); + Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility"); + Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey"); + Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (an.ToString (), clone.ToString (), "ToString"); } [Test] -#if NET_2_0 - [Category ("NotWorking")] -#endif public void Clone_Empty () { an = new AssemblyName (); @@ -490,14 +1033,11 @@ public class AssemblyNameTest { Assert.IsNull (clone.CultureInfo, "CultureInfo"); Assert.IsNull (clone.EscapedCodeBase, "EscapedCodeBase"); Assert.AreEqual (AssemblyNameFlags.None, clone.Flags, "Flags"); -#if NET_2_0 Assert.AreEqual (String.Empty, clone.FullName, "FullName"); -#else - Assert.IsNull (clone.FullName, "FullName"); -#endif Assert.AreEqual (AssemblyHashAlgorithm.None, clone.HashAlgorithm, "HashAlgorithm"); Assert.IsNull (clone.KeyPair, "KeyPair"); Assert.IsNull (clone.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.None, clone.ProcessorArchitecture, "PA"); Assert.IsNull (clone.Version, "Version"); Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, clone.VersionCompatibility, "VersionCompatibility"); @@ -517,8 +1057,12 @@ public class AssemblyNameTest { Assert.AreEqual (an.HashAlgorithm, clone.HashAlgorithm, "HashAlgorithm"); Assert.AreEqual (an.KeyPair, clone.KeyPair, "KeyPair"); Assert.AreEqual (an.Name, clone.Name, "Name"); + Assert.AreEqual (an.ProcessorArchitecture, clone.ProcessorArchitecture, "PA"); Assert.AreEqual (an.Version, clone.Version, "Version"); Assert.AreEqual (an.VersionCompatibility, clone.VersionCompatibility, "VersionCompatibility"); + Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey"); + Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (an.ToString (), clone.ToString (), "ToString"); } [Test] @@ -530,7 +1074,7 @@ public class AssemblyNameTest { [Test] [Category ("NotWorking")] - public void GetAssemblyName_AssemblyFile_LoadFailure () + public void GetAssemblyName_AssemblyFile_ReadLock () { string file = Path.Combine (tempDir, "loadfailure.dll"); using (FileStream fs = File.Open (file, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None)) { @@ -538,6 +1082,15 @@ public class AssemblyNameTest { AssemblyName.GetAssemblyName (file); Assert.Fail ("#1"); } catch (FileLoadException ex) { + // Could not load file or assembly '...' or one + // of its dependencies. The process cannot access + // the file because it is being used by another + // process + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNotNull (ex.FileName, "#3"); + Assert.AreEqual (file, ex.FileName, "#4"); + Assert.IsNull (ex.InnerException, "#5"); + Assert.IsNotNull (ex.Message, "#6"); } } File.Delete (file); @@ -554,8 +1107,14 @@ public class AssemblyNameTest { AssemblyName.GetAssemblyName (file); Assert.Fail ("#1"); } catch (BadImageFormatException ex) { + Assert.AreEqual (typeof (BadImageFormatException), ex.GetType (), "#2"); + Assert.IsNotNull (ex.FileName, "#3"); + Assert.AreEqual (file, ex.FileName, "#4"); + Assert.IsNull (ex.InnerException, "#5"); + Assert.IsNotNull (ex.Message, "#6"); + } finally { + File.Delete (file); } - File.Delete (file); } [Test] @@ -579,164 +1138,721 @@ public class AssemblyNameTest { return tokenString; } -#if NET_2_0 - [Test] - [Category ("NotWorking")] - public void Ctor1 () + [Test] // ctor (String) + public void Constructor1_Name () { const string assemblyName = "TestAssembly"; - AssemblyName an = new AssemblyName (assemblyName); - Assert.IsNotNull (an.Name, "Ctor1#1"); - Assert.AreEqual (an.Name, assemblyName, "Ctor1#2"); - Assert.IsNull (an.Version, "Ctor1#3"); - Assert.IsNull (an.CultureInfo, "Ctor1#4"); - Assert.IsNull (an.GetPublicKeyToken (), "Ctor1#5"); + + an = new AssemblyName (assemblyName); + Assert.IsNull (an.CodeBase, "CodeBase"); + Assert.IsNull (an.CultureInfo, "CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); + Assert.AreEqual ("TestAssembly", an.FullName, "FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA"); + Assert.IsNull (an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "GetPublicKey"); + Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual ("TestAssembly", an.ToString (), "ToString"); +#if NET_4_5 + Assert.IsNull (an.CultureName, "CultureName"); + Assert.AreEqual (AssemblyContentType.Default, an.ContentType, "ContentType"); +#endif } - [Test] - public void Ctor2 () + [Test] // ctor (String) + [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM. + public void Constructor1_Full () { const string assemblyName = "TestAssembly"; + const string assemblyCulture = "neutral"; const string assemblyVersion = "1.2.3.4"; - AssemblyName an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion); - Assert.IsNotNull (an.Name, "Ctor2#1"); - Assert.AreEqual (an.Name, assemblyName, "Ctor2#2"); - Assert.IsNotNull (an.Version, "Ctor2#3"); - Assert.AreEqual (an.Version, new Version (assemblyVersion), "Ctor2#4"); - Assert.IsNull (an.CultureInfo, "Ctor2#5"); - Assert.IsNull (an.GetPublicKeyToken (), "Ctor2#6"); + + an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion + + ", Culture=" + assemblyCulture + ", PublicKeyToken=" + GetTokenString (pk_token1) + ",ProcessorArchitecture=X86"); + Assert.IsNull (an.CodeBase, "CodeBase"); + Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); + Assert.AreEqual ("TestAssembly, Version=1.2.3.4, Culture=neutral, PublicKeyToken=" + + GetTokenString (pk_token1), an.FullName, "FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA"); + Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "GetPublicKey"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (an.FullName, an.ToString (), "ToString"); } - [Test] - [Category ("NotWorking")] - public void Ctor3 () + [Test] // ctor (String) + public void Constructor1_AssemblyName_Empty () + { + try { + new AssemblyName (string.Empty); + Assert.Fail ("#1"); + } catch (ArgumentException ex) { + // String cannot have zero length + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNull (ex.ParamName, "#5"); + } + } + + [Test] // ctor (String) + public void Constructor1_AssemblyName_Invalid () + { + const string assemblyName = "TestAssembly"; + + try { + new AssemblyName (assemblyName + ", =1.2.4.5"); + Assert.Fail ("#A1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + + try { + new AssemblyName (assemblyName + ", OtherAttribute"); + Assert.Fail ("#B1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + } + + [Test] // ctor (String) + public void Constructor1_AssemblyName_Null () + { + try { + new AssemblyName (null); + Assert.Fail ("#1"); + } catch (ArgumentNullException ex) { + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNotNull (ex.ParamName, "#5"); + Assert.AreEqual ("assemblyName", ex.ParamName, "#6"); + } + } + + [Test] // ctor (String) + public void Constructor1_Culture () { const string assemblyName = "TestAssembly"; const string assemblyCulture = "en-US"; - AssemblyName an = new AssemblyName (assemblyName + ", Culture=" + assemblyCulture); - Assert.IsNotNull (an.Name, "Ctor3#1"); - Assert.AreEqual (an.Name, assemblyName, "Ctor3#2"); - Assert.IsNotNull (an.CultureInfo, "Ctor3#3"); - Assert.AreEqual (an.CultureInfo, new CultureInfo (assemblyCulture), "Ctor3#4"); - Assert.IsNull (an.Version, "Ctor3#5"); - Assert.IsNull (an.GetPublicKeyToken (), "Ctor3#6"); + + an = new AssemblyName (assemblyName + ", Culture=" + assemblyCulture); + Assert.IsNull (an.CodeBase, "CodeBase"); + Assert.AreEqual (new CultureInfo (assemblyCulture), an.CultureInfo, "CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); + Assert.AreEqual ("TestAssembly, Culture=en-US", an.FullName, "FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA"); + Assert.IsNull (an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "GetPublicKey"); + Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (an.FullName, an.ToString (), "ToString"); } - [Test] - [Category ("NotWorking")] - public void Ctor4 () + [Test] // ctor (String) + public void Constructor1_Culture_Incomplete () { const string assemblyName = "TestAssembly"; - byte [] assemblyKeyToken; - AssemblyName an = new AssemblyName (assemblyName + ", PublicKeyToken=" + GetTokenString (token)); - Assert.IsNotNull (an.Name, "Ctor4#1"); - Assert.AreEqual (an.Name, assemblyName, "Ctor4#2"); - Assert.IsNotNull (assemblyKeyToken = an.GetPublicKeyToken (), "Ctor4#3"); - Assert.AreEqual (assemblyKeyToken, token, "Ctor4#4"); - Assert.IsNull (an.Version, "Ctor4#5"); - Assert.IsNull (an.CultureInfo, "Ctor4#6"); + + try { + new AssemblyName (assemblyName + ", Culture="); + Assert.Fail ("#1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } } - [Test] - public void Ctor5 () + [Test] // ctor (String) + public void Constructor1_Culture_NotSupported () { const string assemblyName = "TestAssembly"; - const string assemblyCulture = "neutral"; - const string assemblyVersion = "1.2.3.4"; - byte [] assemblyKeyToken; - AssemblyName an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion + - ", Culture=" + assemblyCulture + ", PublicKeyToken=" + GetTokenString (token)); - Assert.IsNotNull (an.Name, "Ctor5#1"); - Assert.AreEqual (an.Name, assemblyName, "Ctor5#2"); - Assert.IsNotNull (an.CultureInfo, "Ctor5#3"); - Assert.AreEqual (an.CultureInfo, new CultureInfo (""), "Ctor5#4"); - Assert.IsNotNull (an.Version, "Ctor5#5"); - Assert.AreEqual (an.Version, new Version (assemblyVersion), "Ctor5#6"); - Assert.IsNotNull (assemblyKeyToken = an.GetPublicKeyToken (), "Ctor5#7"); - Assert.AreEqual (assemblyKeyToken, token, "Ctor5#8"); + try { + new AssemblyName (assemblyName + ", Culture=aa-AA"); + Assert.Fail ("#1"); +#if NET_4_0 + } catch (CultureNotFoundException ex) { + } +#else + } catch (ArgumentException ex) { + // Culture name 'aa-aa' is not supported + Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + Assert.IsNotNull (ex.ParamName, "#5"); + Assert.AreEqual ("name", ex.ParamName, "#6"); + } +#endif + } + + [Test] // ctor (String) + public void Constructor1_ProcessorArchitecture () + { + const string assemblyName = "TestAssembly"; + + an = new AssemblyName (assemblyName + ", ProcessorArchitecture=X86"); + Assert.IsNull (an.CodeBase, "CodeBase"); + Assert.IsNull (an.CultureInfo, "CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); + Assert.AreEqual ("TestAssembly", an.FullName, "FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.X86, an.ProcessorArchitecture, "PA"); + Assert.IsNull (an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "GetPublicKey"); + Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual ("TestAssembly", an.ToString (), "ToString"); + + an = new AssemblyName (assemblyName + ", ProcessorArchitecture=mSiL"); + Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "PA: MSIL"); + + an = new AssemblyName (assemblyName + ", ProcessorArchitecture=AmD64"); + Assert.AreEqual (ProcessorArchitecture.Amd64, an.ProcessorArchitecture, "PA: Amd64"); + + an = new AssemblyName (assemblyName + ", ProcessorArchitecture=iA64"); + Assert.AreEqual (ProcessorArchitecture.IA64, an.ProcessorArchitecture, "PA: IA64"); + } + + [Test] // ctor (String) + public void Constructor1_ProcessorArchitecture_Incomplete () + { + const string assemblyName = "TestAssembly"; + try { + new AssemblyName (assemblyName + ", ProcessorArchitecture="); + Assert.Fail ("#1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + } + + [Test] // ctor (String) + public void Constructor1_ProcessorArchitecture_Invalid () + { + const string assemblyName = "TestAssembly"; + try { + new AssemblyName (assemblyName + ", ProcessorArchitecture=XXX"); + Assert.Fail ("#A1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2"); + Assert.IsNull (ex.FileName, "#A3"); + Assert.IsNull (ex.InnerException, "#A4"); + Assert.IsNotNull (ex.Message, "#A5"); + } + + try { + new AssemblyName (assemblyName + ", ProcessorArchitecture=None"); + Assert.Fail ("#B1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2"); + Assert.IsNull (ex.FileName, "#B3"); + Assert.IsNull (ex.InnerException, "#B4"); + Assert.IsNotNull (ex.Message, "#B5"); + } + } + + [Test] // ctor (String) + [Category ("NotDotNet")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088 + public void Constructor1_PublicKey_Mono () + { + const string assemblyName = "TestAssembly"; + + an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1)); + Assert.IsNull (an.CodeBase, "CodeBase"); + Assert.IsNull (an.CultureInfo, "CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "Flags"); + Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA"); + Assert.IsNull (an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.AreEqual (publicKey1, an.GetPublicKey (), "GetPublicKey"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (an.FullName, an.ToString (), "ToString"); } [Test] - [Category ("NotWorking")] - public void Ctor6 () + [Category ("NotWorking")] // MS only sets the public key token not the public key: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=321088 + public void Constructor1_PublicKey_MS () + { + const string assemblyName = "TestAssembly"; + + an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey1)); + Assert.IsNull (an.CodeBase, "CodeBase"); + Assert.IsNull (an.CultureInfo, "CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); + Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA"); + Assert.IsNull (an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "GetPublicKey"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (an.FullName, an.ToString (), "ToString"); + } + + [Test] // ctor (String) + [Category ("NotWorking")] // bug #351725 + public void Constructor1_PublicKey_Ecma () + { + const string assemblyName = "TestAssembly"; + + an = new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (publicKey3)); + Assert.IsNull (an.CodeBase, "CodeBase"); + Assert.IsNull (an.CultureInfo, "CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); + Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token3), an.FullName, "FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA"); + Assert.IsNull (an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "GetPublicKey"); + Assert.AreEqual (pk_token3, an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (an.FullName, an.ToString (), "ToString"); + } + + [Test] // ctor (String) + public void Constructor1_PublicKey_Incomplete () { const string assemblyName = "TestAssembly"; - AssemblyName an = null; - // null argument try { - an = new AssemblyName (null); - } catch (ArgumentNullException) { + new AssemblyName (assemblyName + ", PublicKey="); + Assert.Fail ("#1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); } - Assert.IsNull (an, "Ctor6#1"); + } + + [Test] // ctor (String) + public void Constructor1_PublicKey_Invalid () + { + const string assemblyName = "TestAssembly"; + + try { + new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e"); + Assert.Fail ("#A1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2"); + Assert.IsNull (ex.FileName, "#A3"); + Assert.IsNull (ex.InnerException, "#A4"); + Assert.IsNotNull (ex.Message, "#A5"); + } + + try { + new AssemblyName (assemblyName + ", PublicKey=null"); + Assert.Fail ("#B1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2"); + Assert.IsNull (ex.FileName, "#B3"); + Assert.IsNull (ex.InnerException, "#B4"); + Assert.IsNotNull (ex.Message, "#B5"); + } + } + + [Test] // ctor (String) + [Category ("NotWorking")] // bug #351756 + public void Constructor1_PublicKey_KeyPair () + { + const string assemblyName = "TestAssembly"; - // empty string - an = null; try { - an = new AssemblyName (""); - } catch (ArgumentException) { + new AssemblyName (assemblyName + ", PublicKey=" + GetTokenString (keyPair)); + Assert.Fail ("#1"); + } catch (SecurityException ex) { + // Invalid assembly public key + Assert.AreEqual (typeof (SecurityException), ex.GetType (), "#2"); + Assert.AreEqual ((SecurityAction) 0, ex.Action, "#3"); + Assert.IsNull (ex.InnerException, "#4"); + Assert.IsNotNull (ex.Message, "#5"); } - Assert.IsNull (an, "Ctor6#2"); + } + + [Test] // ctor (String) + public void Constructor1_PublicKeyToken () + { + const string assemblyName = "TestAssembly"; + + an = new AssemblyName (assemblyName + ", PublicKeyToken=" + GetTokenString (pk_token1)); + Assert.IsNull (an.CodeBase, "#A:CodeBase"); + Assert.IsNull (an.CultureInfo, "#A:CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "#A:EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A:Flags"); + Assert.AreEqual ("TestAssembly, PublicKeyToken=" + GetTokenString (pk_token1), an.FullName, "#A:FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#A:HashAlgorithm"); + Assert.IsNull (an.KeyPair, "#A:KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "#A:Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#A:PA"); + Assert.IsNull (an.Version, "#A:Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "#A:VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "#A:GetPublicKey"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#A:GetPublicKeyToken"); + Assert.AreEqual (an.FullName, an.ToString (), "#A:ToString"); + + an = new AssemblyName (assemblyName + ", PublicKeyToken=null"); + Assert.IsNull (an.CodeBase, "#B:CodeBase"); + Assert.IsNull (an.CultureInfo, "#B:CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "#B:EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#B:Flags"); + //Assert.AreEqual ("TestAssembly, PublicKeyToken=null", an.FullName, "#B:FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#B:HashAlgorithm"); + Assert.IsNull (an.KeyPair, "#B:KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "#B:Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#B:PA"); + Assert.IsNull (an.Version, "#B:Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "#B:VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "#B:GetPublicKey"); + Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#B:GetPublicKeyToken"); + Assert.AreEqual (an.FullName, an.ToString (), "#B:ToString"); + } + + [Test] // ctor (String) + public void Constructor1_PublicKeyToken_Incomplete () + { + const string assemblyName = "TestAssembly"; - // incomplete entry - an = null; try { - an = new AssemblyName (assemblyName + ", Version=,Culture=neutral"); - } catch (FileLoadException) { + new AssemblyName (assemblyName + ", PublicKeyToken="); + Assert.Fail ("#1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); } - Assert.IsNull (an, "Ctor6#3"); + } + + [Test] // ctor (String) + public void Constructor1_PublicKeyToken_Invalid () + { + const string assemblyName = "TestAssembly"; - // bad format for version - an = null; try { - an = new AssemblyName (assemblyName + ", Version=a.b"); - } catch (FileLoadException) { + new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188"); + Assert.Fail ("#1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); } - Assert.IsNull (an, "Ctor6#4"); + } + + [Test] // ctor (String) + public void Constructor1_Retargetable () + { + const string assemblyName = "TestAssembly"; - // bad culture info - an = null; try { - an = new AssemblyName (assemblyName + ", Culture=aa-AA"); - } catch (ArgumentException) { + new AssemblyName (assemblyName + ", Retargetable=Yes"); + Assert.Fail ("#A1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2"); + Assert.IsNull (ex.FileName, "#A3"); + Assert.IsNull (ex.InnerException, "#A4"); + Assert.IsNotNull (ex.Message, "#A5"); } - Assert.IsNull (an, "Ctor6#5"); - // incorrect length for key token - an = null; try { - an = new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188"); - } catch (FileLoadException) { + new AssemblyName (assemblyName + ", Retargetable=No"); + Assert.Fail ("#B1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2"); + Assert.IsNull (ex.FileName, "#B3"); + Assert.IsNull (ex.InnerException, "#B4"); + Assert.IsNotNull (ex.Message, "#B5"); } - Assert.IsNull (an, "Ctor6#6"); - // Incorrect length for key - an = null; try { - an = new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e"); - } catch (FileLoadException) { + new AssemblyName (assemblyName + ", Version=1.0.0.0, Retargetable=Yes"); + Assert.Fail ("#C1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2"); + Assert.IsNull (ex.FileName, "#C3"); + Assert.IsNull (ex.InnerException, "#C4"); + Assert.IsNotNull (ex.Message, "#C5"); } - Assert.IsNull (an, "Ctor6#7"); - // missing spec - an = null; try { - an = new AssemblyName (assemblyName + ", =1.2.4.5"); - } catch (FileLoadException) { + new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, Retargetable=Yes"); + Assert.Fail ("#D1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#D2"); + Assert.IsNull (ex.FileName, "#D3"); + Assert.IsNull (ex.InnerException, "#D4"); + Assert.IsNotNull (ex.Message, "#D5"); } - Assert.IsNull (an, "Ctor6#8"); - // No '=' found - an = null; try { - an = new AssemblyName (assemblyName + ", OtherAttribute"); - } catch (FileLoadException) { + new AssemblyName (assemblyName + ", Version=1.0.0.0, PublicKeyToken=null, Retargetable=Yes"); + Assert.Fail ("#E1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#E2"); + Assert.IsNull (ex.FileName, "#E3"); + Assert.IsNull (ex.InnerException, "#E4"); + Assert.IsNotNull (ex.Message, "#E5"); } - Assert.IsNull (an, "Ctor6#9"); + + an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=yEs"); + Assert.IsNull (an.CodeBase, "F:CodeBase"); + Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#F:CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "#F:EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#F:Flags"); + Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=Yes", an.FullName, "#F:FullName"); + Assert.IsNull (an.GetPublicKey (), "#F:GetPublicKey"); + Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#F:GetPublicKeyToken"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#F:HashAlgorithm"); + Assert.IsNull (an.KeyPair, "#F:KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "#F:Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#F:PA"); + Assert.AreEqual (an.FullName, an.ToString (), "#F:ToString"); + Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#F:Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "#F:VersionCompatibility"); + + an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=null, Retargetable=nO"); + Assert.IsNull (an.CodeBase, "G:CodeBase"); + Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#G:CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "#G:EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#G:Flags"); + Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", an.FullName, "#G:FullName"); + Assert.IsNull (an.GetPublicKey (), "#G:GetPublicKey"); + Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#G:GetPublicKeyToken"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#G:HashAlgorithm"); + Assert.IsNull (an.KeyPair, "#G:KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "#G:Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#G:PA"); + Assert.AreEqual (an.FullName, an.ToString (), "#G:ToString"); + Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#G:Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "#G:VersionCompatibility"); + + an = new AssemblyName (assemblyName + ", Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=yes"); + Assert.IsNull (an.CodeBase, "H:CodeBase"); + Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#H:CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "#H:EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.Retargetable, an.Flags, "#H:Flags"); + Assert.AreEqual ("TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=" + GetTokenString (pk_token1) + ", Retargetable=Yes", an.FullName, "#H:FullName"); + Assert.IsNull (an.GetPublicKey (), "#H:GetPublicKey"); + Assert.AreEqual (pk_token1, an.GetPublicKeyToken (), "#H:GetPublicKeyToken"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "#H:HashAlgorithm"); + Assert.IsNull (an.KeyPair, "#H:KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "#H:Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "#H:PA"); + Assert.AreEqual (an.FullName, an.ToString (), "#H:ToString"); + Assert.AreEqual (new Version (1, 0, 0, 0), an.Version, "#H:Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "#H:VersionCompatibility"); } -#endif + [Test] // ctor (String) + public void Constructor1_Retargetable_Incomplete () + { + const string assemblyName = "TestAssembly"; + + try { + new AssemblyName (assemblyName + ", Retargetable="); + Assert.Fail ("#1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#4"); + Assert.IsNotNull (ex.Message, "#5"); + } + } + + [Test] // ctor (String) + public void Constructor1_Retargetable_Invalid () + { + const string assemblyName = "TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"; + + try { + new AssemblyName (assemblyName + ", Retargetable=False"); + Assert.Fail ("#A1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#A2"); + Assert.IsNull (ex.FileName, "#A3"); + Assert.IsNull (ex.InnerException, "#A4"); + Assert.IsNotNull (ex.Message, "#A5"); + } + + try { + new AssemblyName (assemblyName + ", Retargetable=1"); + Assert.Fail ("#B1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#B2"); + Assert.IsNull (ex.FileName, "#B3"); + Assert.IsNull (ex.InnerException, "#B4"); + Assert.IsNotNull (ex.Message, "#B5"); + } + + try { + new AssemblyName (assemblyName + ", Retargetable=True"); + Assert.Fail ("#C1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#C2"); + Assert.IsNull (ex.FileName, "#C3"); + Assert.IsNull (ex.InnerException, "#C4"); + Assert.IsNotNull (ex.Message, "#C5"); + } + } + + [Test] // ctor (String) + [Category("TargetJvmNotWorking")] // Not yet supported for TARGET_JVM. + public void Constructor1_Version () + { + const string assemblyName = "TestAssembly"; + const string assemblyVersion = "1.2.3.4"; + + an = new AssemblyName (assemblyName + ", Version=" + assemblyVersion); + Assert.IsNull (an.CodeBase, "CodeBase"); + Assert.IsNull (an.CultureInfo, "CultureInfo"); + Assert.IsNull (an.EscapedCodeBase, "EscapedCodeBase"); + Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "Flags"); + Assert.AreEqual ("TestAssembly, Version=1.2.3.4", an.FullName, "FullName"); + Assert.AreEqual (AssemblyHashAlgorithm.None, an.HashAlgorithm, "HashAlgorithm"); + Assert.IsNull (an.KeyPair, "KeyPair"); + Assert.AreEqual (assemblyName, an.Name, "Name"); + Assert.AreEqual (ProcessorArchitecture.None, an.ProcessorArchitecture, "PA"); + Assert.AreEqual (new Version (assemblyVersion), an.Version, "Version"); + Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, + an.VersionCompatibility, "VersionCompatibility"); + Assert.IsNull (an.GetPublicKey (), "GetPublicKey"); + Assert.IsNull (an.GetPublicKeyToken (), "GetPublicKeyToken"); + Assert.AreEqual (an.FullName, an.ToString (), "ToString"); + } + + + [Test] // ctor (String) + public void Constructor1_Version_Incomplete () + { + const string assemblyName = "TestAssembly"; + + try { + new AssemblyName (assemblyName + ", Version=, Culture=neutral"); + Assert.Fail ("#1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + } + + [Test] // ctor (String) + public void Constructor1_Version_Invalid () + { + const string assemblyName = "TestAssembly"; + + try { + new AssemblyName (assemblyName + ", Version=a.b"); + Assert.Fail ("#1"); + } catch (FileLoadException ex) { + // The given assembly name or codebase was invalid + Assert.AreEqual (typeof (FileLoadException), ex.GetType (), "#2"); + Assert.IsNull (ex.FileName, "#3"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNotNull (ex.Message, "#4"); + } + } + + [Test (Description="Xamarin bug #99 - whitespaces in key=value")] + public void WhiteSpaceInKeyValue () + { + string nameWithSpaces = String.Format ("MySql.Data.Tests, PublicKey = \t {0}, Culture =\tneutral, Version=\t1.2.3.4", GetTokenString (publicKey1)); + string fullName = "MySql.Data.Tests, Version=1.2.3.4, Culture=neutral, PublicKeyToken=ce5276d8687ec6dc"; + var an = new AssemblyName (nameWithSpaces); + + Assert.AreEqual (fullName, an.FullName); + } + + [Test] + public void ReferenceMatchesDefinition_Compares_Only_SimpleName () + { + var an1 = new AssemblyName ("TestDll, Version=1.0.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089"); + var an2 = new AssemblyName ("TestDll, Version=2.0.0.2001, Culture=en-US, PublicKeyToken=ab7a5c561934e089"); + + var an3 = new AssemblyName ("TestDll"); + var an4 = new AssemblyName ("tesTDlL"); + + var an5 = new AssemblyName ("TestDll"); + var an6 = new AssemblyName ("TestDll2"); + + Assert.IsTrue (AssemblyName.ReferenceMatchesDefinition (an1, an2)); + Assert.IsTrue (AssemblyName.ReferenceMatchesDefinition (an3, an4)); + Assert.IsFalse (AssemblyName.ReferenceMatchesDefinition (an5, an6)); + } } }