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) : "<empty>");
- msg += " is different than " + (array2.Length > 0 ? BitConverter.ToString (array2, 0) : "<empty>");
- 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 ()
Directory.CreateDirectory (tempDir);
+#if !TARGET_JVM // Thread.GetDomain is not supported for TARGET_JVM.
domain = Thread.GetDomain ();
+#endif // TARGET_JVM
}
[TearDown]
}
}
- [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 ();
- AssemblyName an = a.GetName ();
+ 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");
+ }
- Assert.IsNotNull (an.GetPublicKey (), "PublicKey(self)");
- Assert.AreEqual (0, an.GetPublicKey ().Length, "PublicKey.Length");
+ [Test]
+ public void Flags_Corlib ()
+ {
+ an = typeof (int).Assembly.GetName ();
+ Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags);
}
[Test]
- public void FullName1 ()
+ public void Flags_Self ()
{
- // !!! 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");
+ Assembly a = Assembly.GetExecutingAssembly ();
+ an = a.GetName ();
+ Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags);
}
[Test]
- public void FullName2 ()
+ 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 ();
+ an = a.GetName ();
+
+ 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 FullName_Flags ()
{
const string assemblyName = "TestAssembly";
// tests for AssemblyName with only name
- AssemblyName an = new AssemblyName ();
+ 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 FullName_Name ()
+ {
+ const string assemblyName = "TestAssembly";
+
+ // tests for AssemblyName with only name
+ an = new AssemblyName ();
an.Name = assemblyName;
Assert.IsNotNull (an.FullName, "FullName2#1");
Assert.AreEqual (an.Name, an.FullName, "FullName2#2");
}
[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
- AssemblyName an = new AssemblyName ();
+ 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 (publicKey);
- Assert.AreEqual (assemblyName + ", PublicKeyToken=" + GetTokenString(token), an.FullName, "FullName5#1");
+ 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 FullName6 ()
+ public void FullName_PublicKey_KeyPair ()
+ {
+ const string assemblyName = "TestAssembly";
+
+ // tests for AssemblyName with name and public key
+ an = new AssemblyName ();
+ an.Name = assemblyName;
+ 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 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;
return assemblyName;
}
+#if !TARGET_JVM && !MOBILE // Reflection.Emit is not supported for TARGET_JVM.
private Assembly GenerateAssembly (AssemblyName name)
{
AssemblyBuilder ab = domain.DefineDynamicAssembly (
[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]
}
[Test]
- [Category ("NotWorking")]
public void Version_Dynamic ()
{
AssemblyName name = GenAssemblyName ();
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 ()
[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;
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;
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));\r
+ 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 ();
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");
- }\r
+ }
[Test]
public void Clone_Self ()
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");
- }\r
+ Assert.AreEqual (an.GetPublicKey (), clone.GetPublicKey (), "GetPublicKey");
+ Assert.AreEqual (an.GetPublicKeyToken (), clone.GetPublicKeyToken (), "GetPublicKeyToken");
+ Assert.AreEqual (an.ToString (), clone.ToString (), "ToString");
+ }
+
+ [Test]
+ [ExpectedException (typeof (FileNotFoundException))]
+ public void GetAssemblyName_AssemblyFile_DoesNotExist ()
+ {
+ AssemblyName.GetAssemblyName (Path.Combine (tempDir, "doesnotexist.dll"));
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void GetAssemblyName_AssemblyFile_ReadLock ()
+ {
+ string file = Path.Combine (tempDir, "loadfailure.dll");
+ using (FileStream fs = File.Open (file, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None)) {
+ try {
+ 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);
+ }
+
+ [Test]
+ public void GetAssemblyName_AssemblyFile_BadImage ()
+ {
+ string file = Path.Combine (tempDir, "badimage.dll");
+ using (StreamWriter sw = File.CreateText (file)) {
+ sw.WriteLine ("somegarbage");
+ }
+ try {
+ 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);
+ }
+ }
+
+ [Test]
+ public void GetAssemblyName_CodeBase ()
+ {
+ Assembly execAssembly = Assembly.GetExecutingAssembly ();
+
+ AssemblyName aname = AssemblyName.GetAssemblyName (execAssembly.Location);
+ Assert.IsNotNull (aname.CodeBase, "#1");
+ Assert.AreEqual (execAssembly.CodeBase, aname.CodeBase, "#2");
+ }
// helpers
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");
+ }
+ }
+
+ [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";
+
+ try {
+ 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");
+ }
+ }
+
+ [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";
+
+ try {
+ 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");
+ }
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1_PublicKeyToken_Invalid ()
+ {
+ const string assemblyName = "TestAssembly";
+
+ try {
+ 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");
+ }
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1_Retargetable ()
+ {
+ const string assemblyName = "TestAssembly";
+
+ try {
+ 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#1");
- // empty string
- an = null;
try {
- an = new AssemblyName ("");
- } catch (ArgumentException) {
+ 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#2");
- // incomplete entry
- an = null;
try {
- an = new AssemblyName (assemblyName + ", Version=,Culture=neutral");
- } 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#3");
- // bad format for version
- an = null;
try {
- an = new AssemblyName (assemblyName + ", Version=a.b");
- } 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#4");
- // bad culture info
- an = null;
try {
- an = new AssemblyName (assemblyName + ", Culture=aa-AA");
- } catch (ArgumentException) {
+ 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#5");
- // incorrect length for key token
- an = null;
+ 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");
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1_Retargetable_Incomplete ()
+ {
+ const string assemblyName = "TestAssembly";
+
try {
- an = new AssemblyName (assemblyName + ", PublicKeyToken=27576a8182a188");
- } catch (FileLoadException) {
+ 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");
}
- Assert.IsNull (an, "Ctor6#6");
+ }
+
+ [Test] // ctor (String)
+ public void Constructor1_Retargetable_Invalid ()
+ {
+ const string assemblyName = "TestAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
- // Incorrect length for key
- an = null;
try {
- an = new AssemblyName (assemblyName + ", PublicKey=0024000004800000940000000602000000240000525341310004000011000000e39d99616f48cf7d6d59f345e485e713e89b8b1265a31b1a393e9894ee3fbddaf382dcaf4083dc31ee7a40a2a25c69c6d019fba9f37ec17fd680e4f6fe3b5305f71ae9e494e3501d92508c2e98ca1e22991a217aa8ce259c9882ffdfff4fbc6fa5e6660a8ff951cd94ed011e5633651b64e8f4522519b6ec84921ee22e4840e");
- } catch (FileLoadException) {
+ 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");
}
- Assert.IsNull (an, "Ctor6#7");
- // missing spec
- an = null;
try {
- an = new AssemblyName (assemblyName + ", =1.2.4.5");
- } catch (FileLoadException) {
+ 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");
}
- Assert.IsNull (an, "Ctor6#8");
- // No '=' found
- an = null;
try {
- an = new AssemblyName (assemblyName + ", OtherAttribute");
- } catch (FileLoadException) {
+ 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");
}
- Assert.IsNull (an, "Ctor6#9");
}
-#endif
+ [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));
+ }
}
}
projects / mono.git / blobdiff