using System.Collections.Generic;
using System.IO;
using System.Reflection;
+#if !MONOTOUCH
using System.Reflection.Emit;
+#endif
using System.Runtime.InteropServices;
using System.Text;
using System.Globalization;
get { return 1; }
set { }
}
+
+ public event EventHandler E;
}
class Derived1 : Base1
get { return 1; }
set { }
}
+
+ public event Action E;
}
public class Foo<T>
{
return a;
}
+
+ public class Nested<K> {}
}
class Foo<T, U>
}
}
-
[TestFixture]
public class TypeTest
{
- private AssemblyBuilder assembly;
+#if !MONOTOUCH
private ModuleBuilder module;
+#endif
const string ASSEMBLY_NAME = "MonoTests.System.TypeTest";
static int typeIndexer = 0;
{
AssemblyName assemblyName = new AssemblyName ();
assemblyName.Name = ASSEMBLY_NAME;
- assembly = AppDomain.CurrentDomain.DefineDynamicAssembly (
+#if !MONOTOUCH
+ var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly (
assemblyName, AssemblyBuilderAccess.RunAndSave, Path.GetTempPath ());
module = assembly.DefineDynamicModule ("module1");
+#endif
}
private string genTypeName ()
{
}
- private void GenericMethod<Q> (Q q)
+ public interface IFace {
+ }
+
+ private void GenericMethod<Q, T1> (Q q, T1 t) where T1 : IFace
{
}
mi = typeof (TypeTest).GetMethod ("GenericMethod", BindingFlags.Instance|BindingFlags.NonPublic);
Assert.IsTrue (mi.GetParameters ()[0].ParameterType.IsAssignableFrom (mi.GetParameters ()[0].ParameterType));
Assert.IsFalse (mi.GetParameters ()[0].ParameterType.IsAssignableFrom (typeof (int)));
+
+ // Tests for parameters with generic constraints
+ mi = typeof (TypeTest).GetMethod ("GenericMethod", BindingFlags.Instance|BindingFlags.NonPublic);
+ Assert.IsTrue (typeof (IFace).IsAssignableFrom (mi.GetParameters ()[1].ParameterType));
}
[Test]
Assert.AreEqual (1, typeof (Derived1).GetProperties ().Length, "#03");
}
+ [Test]
+ public void GetEvents ()
+ {
+ // Test hide-by-name
+ Assert.AreEqual (1, typeof (Derived2).GetEvents ().Length);
+ Assert.AreEqual (typeof (Derived2), typeof (Derived2).GetEvents ()[0].DeclaringType);
+ }
+
[Test]
public void GetProperties ()
{
i.GetInterfaces ();
}
- public static void GenericMethod<T> (T[] arr) where T: IComparable<T> {
+ public static void GenericMethod<T, T2> (T[] arr) where T: IComparable<T> {
}
public int AField;
Type [] typeArgs = typeof (List<>).GetGenericArguments ();
Assert.IsFalse (typeArgs [0].IsAbstract, "#7");
}
-
+#if !MOBILE
[Test]
public void IsCOMObject ()
{
type = tb.CreateType ();
Assert.IsTrue (type.IsImport, "#3");
}
-
+#endif
[Test]
public void IsInterface ()
{
Type t = Type.GetType ("System.String[*]");
Assert.AreEqual ("System.String[*]", t.ToString ());
}
+
+#if MONOTOUCH
+ // feature not available when compiled under FULL_AOT_RUNTIME
+ [ExpectedException (typeof (NotImplementedException))]
+#endif
+ [Test]
+ public void TypeFromCLSID ()
+ {
+ Guid CLSID_ShellDesktop = new Guid("00021400-0000-0000-c000-000000000046");
+ Guid CLSID_Bogus = new Guid("1ea9d7a9-f7ab-443b-b486-30d285b21f1b");
+
+ Type t1 = Type.GetTypeFromCLSID (CLSID_ShellDesktop);
+
+ Type t2 = Type.GetTypeFromCLSID (CLSID_Bogus);
+
+ Assert.AreEqual (t1.FullName, "System.__ComObject");
+
+ if (Environment.OSVersion.Platform == PlatformID.Win32Windows ||
+ Environment.OSVersion.Platform == PlatformID.Win32NT)
+ Activator.CreateInstance(t1);
+
+ Assert.AreEqual (t2.FullName, "System.__ComObject");
+
+ Assert.AreNotEqual (t1, t2);
+ }
+
+ [Test]
+ [Category("NotWorking")] // Mono throws TargetInvokationException
+ [ExpectedException("System.Runtime.InteropServices.COMException")]
+ public void TypeFromCLSIDBogus ()
+ {
+ Guid CLSID_Bogus = new Guid("1ea9d7a9-f7ab-443b-b486-30d285b21f1b");
+ Type t = Type.GetTypeFromCLSID (CLSID_Bogus);
+ if (Environment.OSVersion.Platform == PlatformID.Win32Windows ||
+ Environment.OSVersion.Platform == PlatformID.Win32NT)
+ Activator.CreateInstance(t);
+ else
+ throw new COMException ();
+ }
[Test]
public void ExerciseFilterName ()
Assert.AreEqual (0, mi.Length);
}
+ [Test]
+ [ExpectedException (typeof (InvalidFilterCriteriaException))]
+ public void FilterAttribute_Invalid ()
+ {
+ Type.FilterAttribute (MethodBase.GetCurrentMethod (), (byte) 1);
+ }
+
[Test]
public void GenericParameterMemberType ()
{
Assert.IsFalse (typeof (bug82431B4).IsDefined (typeof (NotInheritAttribute), true), "#K4");
}
+ class Bug13767Attribute : Attribute
+ {
+ public object[] field;
+
+ public Bug13767Attribute (params object[] args)
+ {
+ field = args;
+ }
+ }
+
+ public enum Bug13767Enum
+ {
+ Value0,
+ Value1,
+ }
+
+ [Bug13767("Demo", new[] { Bug13767Enum.Value1, Bug13767Enum.Value0 })]
+ public void Bug13767Method(string attributeName, Bug13767Enum[]options)
+ {
+
+ }
+
+ [Test] //Bug 13767
+ public void CustomAttributeWithNestedArrayOfEnum ()
+ {
+ var m = GetType ().GetMethod ("Bug13767Method");
+
+ var attr = m.GetCustomAttributes (false);
+ Assert.AreEqual (1, attr.Length, "#1");
+
+ var tc = (Bug13767Attribute)attr[0];
+ Assert.AreEqual (2, tc.field.Length, "#2");
+ Assert.AreEqual ("Demo", tc.field[0], "#3");
+ Assert.IsNotNull (tc.field[1], "#4");
+
+ var arr = (Bug13767Enum[])tc.field [1];
+ Assert.AreEqual (2, arr.Length, "#5");
+ Assert.AreEqual (Bug13767Enum.Value1, arr [0], "#6");
+ Assert.AreEqual (Bug13767Enum.Value0, arr [1], "#7");
+ }
+
[Test] // GetType (String)
public void GetType1_TypeName_Null ()
{
Assert.IsNull (i);
}
-#if !TARGET_JVM // Reflection.Emit is not supported for TARGET_JVM
+#if !TARGET_JVM && !MOBILE // Reflection.Emit is not supported for TARGET_JVM
[Test]
public void EqualsUnderlyingType ()
{
Assert.AreEqual ("System.Int32", t.FullName);
}
- [Test] //bug #331199
+ [Test]
+#if MONOTOUCH
+ [ExpectedException (typeof (NotSupportedException))]
+#endif
public void MakeGenericType_UserDefinedType ()
{
Type ut = new UserType (typeof (int));
}
[Test]
+#if MONOTOUCH
+ [ExpectedException (typeof (NotSupportedException))]
+#endif
public void MakeGenericType_BadUserType ()
{
Type ut = new UserType (null);
- try {
- Type t = typeof (Foo<>).MakeGenericType (ut);
- Assert.Fail ("#1");
- } catch (ArgumentException) {
- }
+ Type t = typeof (Foo<>).MakeGenericType (ut);
+ var g0 = t.GetGenericArguments () [0];
+ Assert.AreSame (g0, ut, "#1");
}
-
+
[Test]
public void MakeGenericType_WrongNumOfArguments ()
{
Assert.AreEqual (t1, t2);
}
-
+#if !MONOTOUCH
[Test]
public void Bug506757 ()
{
foreach (var m in t2.GetMethods (BindingFlags.Instance | BindingFlags.NonPublic))
Assert.IsTrue (m.DeclaringType == typeof (object), String.Format ("{0}::{1}", m.DeclaringType, m.Name));
}
-
+#endif
[Test]
public void MakeArrayTypeOfOneDimension ()
{
}
}
+ [Test] // Bug #574696
+ public void GetMember_DoesntReturnPrivatePropOfParent ()
+ {
+ BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
+ Assert.AreEqual (1, typeof (Bar).GetMember ("PrivInst", flags).Length);
+ Assert.AreEqual (0, typeof (Bar).GetMember ("PrivInstBase", flags).Length);
+ Assert.AreEqual (1, typeof (Foo).GetMember ("PrivInstBase", flags).Length);
+ }
+
+ [Test] // Bug #484246
+ public void GetInterfaceCompareAgainstGTDNames ()
+ {
+ var t = typeof (Dictionary<string,string>);
+ var iface = typeof (IDictionary<string,string>);
+
+ Assert.AreSame (iface, t.GetInterface ("System.Collections.Generic.IDictionary`2"), "#1");
+
+ string name = "System.Collections.Generic.IDictionary`2[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]";
+
+ Assert.IsNull (t.GetInterface (name), "#2");
+ }
+
+ [Test]
+ public void RuntimeCorrectlyNormalizeGenericTypes ()
+ {
+ Type lst = typeof (MList<>);
+ Type arg = lst.GetGenericArguments ()[0];
+
+ Type sup = lst.BaseType;
+ Type sa0 = sup.GetGenericArguments ()[0];
+ Type sa1 = sup.GetGenericArguments ()[1];
+
+ Assert.IsTrue (sa1 == lst, "#1");
+ Assert.IsTrue (sa0 == arg, "#2");
+
+ Type inst = typeof (Cons<,>).MakeGenericType (arg, lst.MakeGenericType (arg));
+ Assert.IsTrue (inst == sup, "#3");
+ }
+
+ class Cons<T,U>
+ {
+
+ }
+
+ class MList<A> : Cons<A, MList<A>>
+ {
+
+ }
+
+ [Test] // Bug #331126
+ public void IsAssignableFromWorksCorrectlyWithByRefs ()
+ {
+ Type int_byref = typeof (int).MakeByRefType ();
+ Type obj_byref = typeof (object).MakeByRefType ();
+ Type long_byref = typeof (long).MakeByRefType ();
+ Type enum1_byref = typeof (AttributeTargets).MakeByRefType ();
+ Type enum2_byref = typeof (PlatformID).MakeByRefType ();
+ Type uint_byref = typeof (uint).MakeByRefType ();
+ Type string_byref = typeof (object).MakeByRefType ();
+ Type struct0_byref = typeof (Size4).MakeByRefType ();
+ Type struct1_byref = typeof (Size4b).MakeByRefType ();
+ Type mvar0_byref = typeof (TypeTest).GetMethod ("Bug331126").GetGenericArguments ()[0].MakeByRefType ();
+ Type mvar1_byref = typeof (TypeTest).GetMethod ("Bug331126").GetGenericArguments ()[1].MakeByRefType ();
+
+ Assert.IsFalse (typeof (int).IsAssignableFrom (int_byref), "#1");
+ Assert.IsFalse (int_byref.IsAssignableFrom (typeof (int)), "#2");
+ Assert.IsFalse (obj_byref.IsAssignableFrom (long_byref), "#3");
+ Assert.IsFalse (long_byref.IsAssignableFrom (obj_byref), "#4");
+ Assert.IsTrue (enum1_byref.IsAssignableFrom (enum2_byref), "#5");
+ Assert.IsTrue (enum2_byref.IsAssignableFrom (enum1_byref), "#6");
+ Assert.IsTrue (int_byref.IsAssignableFrom (enum2_byref), "#7");
+ Assert.IsTrue (enum2_byref.IsAssignableFrom (int_byref), "#8");
+ Assert.IsTrue (enum2_byref.IsAssignableFrom (uint_byref), "#9");
+ Assert.IsTrue (uint_byref.IsAssignableFrom (enum2_byref), "#10");
+ Assert.IsTrue (int_byref.IsAssignableFrom (uint_byref), "#11");
+ Assert.IsTrue (uint_byref.IsAssignableFrom (int_byref), "#12");
+
+ Assert.IsTrue (typeof (object).IsAssignableFrom (typeof (long)), "#13");
+
+ Assert.IsTrue (obj_byref.IsAssignableFrom (string_byref), "#14");
+ Assert.IsTrue (string_byref.IsAssignableFrom (obj_byref), "#15");
+
+ Assert.IsFalse (uint_byref.IsAssignableFrom (struct0_byref), "#16");
+ Assert.IsFalse (struct0_byref.IsAssignableFrom (int_byref), "#17");
+ Assert.IsFalse (struct0_byref.IsAssignableFrom (struct1_byref), "#18");
+
+ Assert.IsFalse (obj_byref.IsAssignableFrom (mvar0_byref), "#19");
+ Assert.IsFalse (mvar0_byref.IsAssignableFrom (mvar1_byref), "#20");
+ Assert.IsTrue (mvar0_byref.IsAssignableFrom (mvar0_byref), "#21");
+ Assert.IsFalse (mvar0_byref.IsAssignableFrom (obj_byref), "#22");
+ }
+
+ public void Bug331126<T,K> () {}
+
+ public struct Size4 {
+ public int field;
+ }
+
+ public struct Size4b {
+ public int field;
+ }
+
+ [Test] // Bug #612780
+ public void CannotMakeDerivedTypesFromTypedByRef ()
+ {
+ try {
+ typeof (global::System.TypedReference).MakeArrayType ();
+ Assert.Fail ("#1");
+ } catch (TypeLoadException) { }
+
+ try {
+ typeof (global::System.TypedReference).MakeByRefType ();
+ Assert.Fail ("#2");
+ } catch (TypeLoadException) { }
+
+ try {
+ typeof (global::System.TypedReference).MakePointerType ();
+ Assert.Fail ("#3");
+ } catch (TypeLoadException) { }
+
+ }
+
+ [Test] //Bug643890
+ public void DeclaringTypeOfGenericNestedTypeInstanceIsOpen ()
+ {
+ var type = typeof (Foo<int>.Nested<string>);
+ Assert.AreSame (typeof (Foo<>), type.DeclaringType, "#1");
+ }
+
#if NET_4_0
interface IGetInterfaceMap<in T>
{
a.Equals (a);
Assert.AreEqual (1, ta.eq, "#1");
- Assert.AreEqual (2, ta.ust, "#2");
+ Assert.AreEqual (0, ta.ust, "#2");
a.Equals (b);
Assert.AreEqual (2, ta.eq, "#3");
- Assert.AreEqual (3, ta.ust, "#4");
+ Assert.AreEqual (1, ta.ust, "#4");
Assert.AreEqual (0, tb.eq, "#5");
Assert.AreEqual (1, tb.ust, "#6");
}
A,B,C
}
+
+ public enum MyRealEnum2 : byte {
+ A,B,C
+ }
+
+ public enum MyRealEnum3 : short {
+ A,B,C
+ }
+
public class MyEnum : TypeDelegator {
public bool is_enum { get; set; }
public int fields { get; set; }
Assert.AreEqual ("B", res [1], "#6");
Assert.AreEqual ("C", res [2], "#7");
}
+
+ public enum OutOfOrderEnum : sbyte
+ {
+ D = -1, C = 2, B = 1, A = 0
+ }
+
+ [Test]
+ public void GetEnumNamesSortsByUnsignedValue ()
+ {
+ string[] names = typeof (OutOfOrderEnum).GetEnumNames ();
+ Assert.AreEqual (4, names.Length);
+ Assert.AreEqual ("A", names [0]);
+ Assert.AreEqual ("B", names [1]);
+ Assert.AreEqual ("C", names [2]);
+ Assert.AreEqual ("D", names [3]);
+ }
+
+ [Test]
+ public void GetEnumValues () {
+ try {
+ new MyEnum () { is_enum = false }.GetEnumValues ();
+ Assert.Fail ("#1");
+ } catch (ArgumentException) {}
+
+ try {
+ new MyEnum () { is_enum = true }.GetEnumValues ();
+ Assert.Fail ("#2");
+ } catch (NotImplementedException) {}
+
+ var array = typeof (MyRealEnum).GetEnumValues ();
+ Assert.AreEqual (typeof (MyRealEnum[]), array.GetType (), "#3");
+ MyRealEnum[] res = (MyRealEnum[])array;
+
+ Assert.AreEqual (3, res.Length, "#4");
+ Assert.AreEqual (MyRealEnum.A, res [0], "#5");
+ Assert.AreEqual (MyRealEnum.B, res [1], "#6");
+ Assert.AreEqual (MyRealEnum.C, res [2], "#7");
+ }
+
+ [Test]
+ public void GetEnumValue () {
+ try {
+ typeof (MyRealEnum).GetEnumName (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentException) { }
+
+ try {
+ new MyEnum () { is_enum = false }.GetEnumName (99);
+ Assert.Fail ("#2");
+ } catch (ArgumentException) { }
+
+
+ Assert.IsNull (new MyEnum () { fields = 1, is_enum = true }.GetEnumName (77), "#3");
+ Assert.AreEqual ("A", new MyEnum () { fields = 1, is_enum = true }.GetEnumName (0), "#4");
+ Assert.AreEqual ("A", new MyEnum () { fields = 1, is_enum = true }.GetEnumName (MyRealEnum.A), "#5");
+ Assert.AreEqual ("A", new MyEnum () { fields = 1, is_enum = true }.GetEnumName (MyRealEnum2.A), "#6");
+
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName (MyRealEnum.A), "#7");
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((short)0), "#8");
+ Assert.AreEqual ("C", typeof (MyRealEnum).GetEnumName (2), "#9");
+ Assert.IsNull (typeof (MyRealEnum).GetEnumName (9), "#10");
+
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((byte)0), "#11");
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((sbyte)0), "#12");
+ try {
+ typeof (MyRealEnum).GetEnumName (false);
+ Assert.Fail ("#13");
+ } catch (ArgumentException) { }
+
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((short)0), "#14");
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((ushort)0), "#15");
+ try {
+ typeof (MyRealEnum).GetEnumName ('c');
+ Assert.Fail ("#16");
+ } catch (ArgumentException) { }
+
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((int)0), "#17");
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((uint)0), "#18");
+
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((long)0), "#19");
+ Assert.AreEqual ("A", typeof (MyRealEnum).GetEnumName ((ulong)0), "#20");
+
+ try {
+ typeof (MyRealEnum).GetEnumName ((float)0);
+ Assert.Fail ("#21");
+ } catch (ArgumentException) { }
+ try {
+ typeof (MyRealEnum).GetEnumName ((double)0);
+ Assert.Fail ("#22");
+ } catch (ArgumentException) { }
+
+
+ Assert.AreEqual ("A", typeof (MyRealEnum2).GetEnumName ((byte)0), "#23");
+ Assert.AreEqual ("A", typeof (MyRealEnum2).GetEnumName ((sbyte)0), "#24");
+ try {
+ typeof (MyRealEnum2).GetEnumName (false);
+ Assert.Fail ("#22", "#25");
+ } catch (ArgumentException) { }
+
+ Assert.AreEqual ("A", typeof (MyRealEnum2).GetEnumName ((short)0), "#26");
+ Assert.AreEqual ("A", typeof (MyRealEnum2).GetEnumName ((ushort)0), "#27");
+
+ try {
+ typeof (MyRealEnum2).GetEnumName ('c');
+ Assert.Fail ("#28");
+ } catch (ArgumentException) { }
+
+ Assert.AreEqual ("A", typeof (MyRealEnum2).GetEnumName ((int)0), "#29");
+ Assert.AreEqual ("A", typeof (MyRealEnum2).GetEnumName ((uint)0), "#30");
+
+ Assert.AreEqual ("A", typeof (MyRealEnum2).GetEnumName ((long)0), "#31");
+ Assert.AreEqual ("A", typeof (MyRealEnum2).GetEnumName ((ulong)0), "#32");
+
+ try {
+ typeof (MyRealEnum2).GetEnumName ((float)0);
+ Assert.Fail ("#33");
+ } catch (ArgumentException) { }
+ try {
+ typeof (MyRealEnum2).GetEnumName ((double)0);
+ Assert.Fail ("#34");
+ } catch (ArgumentException) { }
+
+ Assert.IsNull (typeof (MyRealEnum2).GetEnumName (12345), "#35");
+ }
+
+ [Test]
+ public void IsEnumDefined () {
+ try {
+ typeof (MyRealEnum).IsEnumDefined (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentException) { }
+
+ try {
+ new MyEnum () { is_enum = false }.IsEnumDefined (99);
+ Assert.Fail ("#2");
+ } catch (ArgumentException) { }
+
+ try {
+ typeof (MyRealEnum).IsEnumDefined (0);
+ Assert.Fail ("#3");
+ } catch (ArgumentException) { }
+
+ try {
+ typeof (MyRealEnum).IsEnumDefined ((ushort)0);
+ Assert.Fail ("#4");
+ } catch (ArgumentException) { }
+
+ try {
+ typeof (MyRealEnum).IsEnumDefined (MyRealEnum3.A);
+ Assert.Fail ("#5");
+ } catch (ArgumentException) { }
+
+ try {
+ typeof (MyRealEnum).IsEnumDefined (true);
+ Assert.Fail ("#6");
+ } catch (InvalidOperationException) { }
+
+ try {
+ typeof (MyRealEnum).IsEnumDefined (MyRealEnum2.A);
+ Assert.Fail ("#7");
+ } catch (ArgumentException) { }
+
+ try {
+ typeof (MyRealEnum).IsEnumDefined (typeof (MyRealEnum));
+ Assert.Fail ("#8");
+ } catch (InvalidOperationException) { }
+
+ Assert.IsTrue (typeof (MyRealEnum).IsEnumDefined ((short)0), "#9");
+ Assert.IsFalse (typeof (MyRealEnum).IsEnumDefined ((short)88), "#10");
+ Assert.IsTrue (typeof (MyRealEnum).IsEnumDefined (MyRealEnum.A), "#11");
+ Assert.IsFalse (typeof (MyRealEnum).IsEnumDefined ("d"), "#12");
+ Assert.IsTrue (typeof (MyRealEnum).IsEnumDefined ("A"), "#13");
+ Assert.IsFalse (new MyEnum () { is_enum = true, fields = 1 }.IsEnumDefined ((short)99), "#14");
+ }
+
+
+
+ public class Outer {
+ public class Inner {}
+ }
+
+
+ public class Outer<T> {
+ public class Inner {}
+ }
+
+ [Test]
+ public void GetTypeWithDelegates () {
+ var tname = typeof (MyRealEnum).AssemblyQualifiedName;
+ var res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (MyRealEnum), res, "#1");
+
+
+ tname = typeof (Dictionary<int, string>).AssemblyQualifiedName;
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (Dictionary<int, string>), res, "#2");
+
+
+ tname = typeof (Foo<int>).AssemblyQualifiedName;
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (Foo<int>), res, "#3");
+
+
+ tname = typeof (Outer.Inner).AssemblyQualifiedName;
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (Outer.Inner), res, "#4");
+
+
+ tname = typeof (Outer<double>.Inner).AssemblyQualifiedName;
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (Outer<double>.Inner), res, "#5");
+
+
+ tname = "System.Collections.Generic.List`1[System.Int32]";
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (List<int>), res, "#6");
+
+
+ tname = typeof (Foo<>).FullName + "[,][]";
+ res = Type.GetType (tname, name => {
+ Console.WriteLine ("resolve-asm name {0}", name);
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (Foo<>).MakeArrayType (2).MakeArrayType (), res, "#7");
+
+ tname = string.Format("{0}[{1}][]*&", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName);
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (Foo<MyRealEnum>[]).MakePointerType ().MakeByRefType (), res, "#8");
+
+
+ tname = typeof (MyRealEnum).FullName + "[][]";
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (MyRealEnum[][]), res, "#9");
+
+
+ tname = typeof (MyRealEnum).FullName + "[*]";
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (MyRealEnum).MakeArrayType (1), res, "#10");
+
+
+ tname = typeof (MyRealEnum).FullName + "&";
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (MyRealEnum).MakeByRefType (), res, "#11");
+
+
+ tname = typeof (MyRealEnum).FullName + "*";
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual (typeof (MyRealEnum).MakePointerType (), res, "#12");
+
+ // assembly resolve without type resolve
+ res = Type.GetType ("System.String,mscorlib", delegate (AssemblyName aname) { return typeof (int).Assembly; }, null);
+ Assert.AreEqual (typeof (string), res);
+ }
+
+
+ public class CustomGetType : TypeDelegator {
+ string name;
+
+ public CustomGetType (string name) { this.name = name; }
+
+ public override Type MakeGenericType (Type[] args) {
+ return new CustomGetType ("GINST");
+ }
+
+ public override Type GetNestedType(String name, BindingFlags bidingAttr) {
+ return new CustomGetType ("NESTED");
+ }
+
+ public override string ToString () { return "UT_" + name; }
+
+ public override string Name {
+ get { return "UT_" + name; }
+ }
+ }
+
+ [Test]
+ public void GetTypeWithDelegatesAndUserTypes ()
+ {
+ var tname = "Magic[System.Int32]";
+ var res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ if (name == "Magic") return new CustomGetType ("MAGIC");
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual ("UT_GINST", res.Name, "#1");
+
+
+ tname = "Magic+MyRealEnum";
+ res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ if (name == "Magic") return new CustomGetType ("MAGIC");
+ return asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, false, false);
+ Assert.AreEqual ("UT_NESTED", res.Name, "#2");
+ }
+
+ void MustTLE (string tname) {
+ try {
+ var res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return (object)asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, true, false);
+ Assert.Fail (tname);
+ } catch (TypeLoadException) {}
+ }
+
+ void MustANE (string tname) {
+ try {
+ var res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return (object)asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, true, false);
+ Assert.Fail (tname);
+ } catch (ArgumentNullException) {}
+ }
+
+ void MustAE (string tname) {
+ try {
+ var res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return (object)asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, true, false);
+ Assert.Fail (tname);
+ } catch (ArgumentException) {}
+ }
+
+ void MustFNFE (string tname) {
+ try {
+ var res = Type.GetType (tname, name => {
+ return Assembly.Load (name);
+ },(asm,name,ignore) => {
+ return (object)asm == null ? Type.GetType (name, false, ignore) : asm.GetType (name, false, ignore);
+ }, true, false);
+ Assert.Fail (tname);
+ } catch (FileNotFoundException) {}
+ }
+
+ [Test]
+ public void NewGetTypeErrors () {
+ MustANE (null);
+ MustAE (string.Format ("{0}[{1}&]", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[{1}*]", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}&&", typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}&*", typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}&[{1}]", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+
+
+ MustAE (string.Format ("{0}[[{1},", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[[{1}]", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[[{1}],", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[[{1}]_", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+
+ MustAE (string.Format ("{0}[{1}", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[{1},", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[{1},,", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[{1} (", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[", typeof (Foo<>).FullName));
+
+ MustAE (string.Format ("{0}[**]", typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[*,*]", typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[*,]", typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[,*]", typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[,-]", typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[,{0}]", typeof (MyRealEnum).FullName));
+
+ MustAE (string.Format ("{0}[{1}]]", typeof (Foo<>).FullName, typeof (MyRealEnum).FullName));
+ MustAE (string.Format ("{0}[,]]", typeof (MyRealEnum).FullName));
+
+
+ string aqn = typeof (MyRealEnum).Assembly.FullName;
+ MustFNFE (string.Format ("{0}, ZZZ{1}", typeof (MyRealEnum).FullName, aqn));
+ MustTLE (string.Format ("{0}ZZZZ", typeof (MyRealEnum).FullName));
+ MustTLE (string.Format ("{0}ZZZZ,{1}", typeof (MyRealEnum).FullName, aqn));
+ }
+
+ delegate void MyAction<in T>(T ag);
+
+ [Test] //bug #668506
+ public void IsAssignableFromWithVariantDelegate () {
+ Assert.IsFalse (typeof(MyAction<string>).IsAssignableFrom(typeof(MyAction<>)), "#1");
+ }
+
+ [Test] //bug #124
+ public void IsAssignableFromWithNullable () {
+ Console.WriteLine(typeof(IEnumerable<int?>).IsAssignableFrom(typeof(IEnumerable<int>)));
+ }
#endif
+ [Test]
+ public void GetTypeParseGenericCorrectly () { //Bug #15124
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1"), typeof (Foo<>), "#1");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[System.Int32]"), typeof (Foo<int>), "#2");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[[System.Int32]]"), typeof (Foo<int>), "#3");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[System.Int32][]"), typeof (Foo<int>[]), "#4");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[][System.Int32]"), null, "#5");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[System.Int32][,]"), typeof (Foo<int>[,]), "#6");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[]"), typeof (Foo<>).MakeArrayType(), "#7");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[,]"), typeof (Foo<>).MakeArrayType (2), "#8");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[][]"), typeof (Foo<>).MakeArrayType ().MakeArrayType (), "#9");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1["), null, "#10");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[["), null, "#11");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[[]"), null, "#12");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[,"), null, "#13");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[*"), null, "#14");
+ Assert.AreEqual (Type.GetType ("MonoTests.System.Foo`1[System.Int32"), null, "#15");
+ }
+
public abstract class Stream : IDisposable
{
public void Dispose ()
projects / mono.git / blobdiff