New tests.
[mono.git] / mcs / class / corlib / Test / System / TypeTest.cs
index a67c14f5ec48e39fe17b4ad6d0886dc5b30133f6..dc3b50836dc05f82d837c57f9a08b3dc053d07ba 100644 (file)
@@ -1562,6 +1562,19 @@ namespace MonoTests.System
                        Assert.AreEqual (2, t2.Length);
                }
 
+               [Test]
+               public void GetInterfacesGenericVarWithConstraints ()
+               {
+                       var a = typeof (TypeTest).GetMethod ("GenericMethod");
+
+                       var p = a.GetParameters ();
+                       var i = p[0].ParameterType.GetElementType ();
+                       i.GetInterfaces ();
+               }
+
+               public static void GenericMethod<T> (T[] arr) where T: IComparable<T> {
+               }
+
                public int AField;
 
                [Test]
@@ -1734,6 +1747,15 @@ PublicKeyToken=b77a5c561934e089"));
                        Assert.AreEqual (0, mi.Length);
                }
 
+               [Test]
+               public void GenericParameterMemberType ()
+               {
+                       var t = typeof (Foo<>).GetGenericArguments () [0];
+                       Assert.IsNotNull (t);
+
+                       Assert.AreEqual (MemberTypes.TypeInfo, t.MemberType);
+               }
+
                public class ByRef0
                {
                        public int field;
@@ -2045,6 +2067,15 @@ PublicKeyToken=b77a5c561934e089"));
                        Assert.AreEqual (Type.Missing, Missing.Value);
                }
 
+               [Test]
+               public void GetGenericMethodDefinitionOverInflatedMethodOnGTD () {
+                       var l = typeof (List<>);
+                       var m = l.GetMethod ("ConvertAll");
+                       var infl = m.MakeGenericMethod (typeof (int));
+                       var res = m.GetGenericMethodDefinition ();
+                       Assert.AreEqual (m, res, "#1");
+               }
+
                [Test]
                public void InvokeMember_OutParam ()
                {
@@ -2887,7 +2918,6 @@ PublicKeyToken=b77a5c561934e089"));
                }
 
                [Test] //bug #331199
-               //FIXME: 2.0 SP 1 has a diferent behavior
                public void MakeGenericType_UserDefinedType ()
                {
                        Type ut = new UserType (typeof (int));
@@ -2898,7 +2928,7 @@ PublicKeyToken=b77a5c561934e089"));
                        Type arg = t.GetGenericArguments () [0];
                        Assert.IsNotNull (arg, "#B1");
                        Assert.IsFalse (arg.IsGenericType, "#B2");
-                       Assert.AreEqual (typeof (int), arg, "#B3");
+                       Assert.AreEqual (ut, arg, "#B3");
                }
 
                [Category ("NotWorking")]
@@ -3167,6 +3197,694 @@ PublicKeyToken=b77a5c561934e089"));
                        } catch (ArgumentException) {}
                }
 
+               [Test] //Bug #564379
+               public void GetMethodsReturnPublicMethodsInInterfaces ()
+               {
+                       Type t = typeof (NonClosingStream);
+                       MethodInfo[] methods = t.GetMethods (BindingFlags.Public | BindingFlags.Instance);
+
+                       Assert.AreEqual (5, methods.Length, "#1");
+                       int id = 2;
+
+                       foreach (var m in methods) {
+                               if (m.Name.Equals ("ToString"))
+                                       Assert.IsTrue (m.DeclaringType == typeof (NonClosingStream), "#" + id);
+                               else if (m.Name.Equals ("Dispose") && m.GetParameters ().Length == 0)
+                                       Assert.IsTrue (m.DeclaringType == typeof (Stream), "#" + id);
+                               else if (m.Name.Equals ("Equals") || m.Name.Equals ("GetHashCode") || m.Name.Equals ("GetType"))
+                                       Assert.IsTrue (m.DeclaringType == typeof (object), "#" + id);
+                               else
+                                       Assert.Fail ("invalid method " + m);
+                               ++id;
+                       }
+               }
+
+               [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;
+               }
+
+#if NET_4_0
+               interface IGetInterfaceMap<in T>
+               {
+                   string Bar (T t);
+               }
+
+               class GetInterfaceMap : IGetInterfaceMap<object>
+               {
+                   public string Bar (object t)
+                   {
+                       return t.GetType ().FullName;
+                   }
+               }
+
+               [Test]
+               public void GetInterfaceMapWorksWithVariantIfaces ()
+               {
+                       InterfaceMapping res = typeof (GetInterfaceMap).GetInterfaceMap (typeof (IGetInterfaceMap <object>));
+                       Assert.AreEqual (typeof (IGetInterfaceMap <object>), res.InterfaceType);
+                       Assert.AreEqual (typeof (object), res.InterfaceMethods [0].GetParameters () [0].ParameterType);
+
+                       res = typeof (GetInterfaceMap).GetInterfaceMap (typeof (IGetInterfaceMap <string>));
+                       Assert.AreEqual (typeof (IGetInterfaceMap <string>), res.InterfaceType);
+                       Assert.AreEqual (typeof (string), res.InterfaceMethods [0].GetParameters () [0].ParameterType);
+               }
+
+
+               public class MyType : TypeDelegator {
+                       public int eq, ust;
+
+                       public override bool Equals (Type t) {
+                               ++eq;
+                               return base.Equals (t);
+                       }
+
+                       public override Type UnderlyingSystemType  {
+                               get { 
+                                       ++ust;
+                                       return typeof (int);
+                               }
+                       }
+               }
+
+               [Test]
+               public void NewV4EqualsBehavior ()
+               {
+                       var ta = new MyType ();
+                       var tb = new MyType ();
+                       object a = ta, b = tb;
+
+                       a.Equals (a);
+                       Assert.AreEqual (1, ta.eq, "#1");
+                       Assert.AreEqual (0, ta.ust, "#2");
+                       a.Equals (b);
+                       Assert.AreEqual (2, ta.eq, "#3");
+                       Assert.AreEqual (1, ta.ust, "#4");
+                       Assert.AreEqual (0, tb.eq, "#5");
+                       Assert.AreEqual (1, tb.ust, "#6");
+               }
+
+               public enum MyRealEnum : short {
+                       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; }
+
+                       public override bool IsSubclassOf (Type c) {
+                               return c == typeof (Enum) && is_enum;
+                       }
+
+                       public override FieldInfo[] GetFields (BindingFlags bindingAttr) {
+                               if (fields == 0)
+                                       return null;
+                               FieldInfo[] res = new FieldInfo [fields];
+                               for (int i = 0; i < fields; ++i) {
+                                       if ((bindingAttr & BindingFlags.Instance) != 0)
+                                               res [i] = typeof (MyRealEnum).GetField ("value__");
+                                       else
+                                               res [i] = typeof (MyRealEnum).GetField ("A");
+                               }
+                               return res;
+                       }
+               }
+
+               [Test]
+               public void GetEnumUnderlyingType () {
+
+                       try {
+                               new MyEnum () { is_enum = false }.GetEnumUnderlyingType ();
+                               Assert.Fail ("#1");
+                       } catch (ArgumentException) {}
+
+                       try {
+                               new MyEnum () { is_enum = true, fields = 0 }.GetEnumUnderlyingType ();
+                               Assert.Fail ("#2");
+                       } catch (ArgumentException) {}
+
+                       try {
+                               new MyEnum () { is_enum = true, fields = 2 }.GetEnumUnderlyingType ();
+                               Assert.Fail ("#3");
+                       } catch (ArgumentException) {}
+
+                       Assert.AreSame (typeof (short), new MyEnum () { is_enum = true, fields = 1 }.GetEnumUnderlyingType ());
+               }
+
+               [Test]
+               public void GetEnumNames () {
+                       try {
+                               new MyEnum () { is_enum = false }.GetEnumNames ();
+                               Assert.Fail ("#1");
+                       } catch (ArgumentException) {}
+
+                       var res = new MyEnum () { is_enum = true, fields = 1 }.GetEnumNames ();
+                       Assert.AreEqual (1, res.Length, "#2");
+                       Assert.AreEqual ("A", res [0], "#3");
+
+                       res = typeof (MyRealEnum).GetEnumNames ();
+                       Assert.AreEqual (3, res.Length, "#4");
+                       Assert.AreEqual ("A", res [0], "#5");
+                       Assert.AreEqual ("B", res [1], "#6");
+                       Assert.AreEqual ("C", res [2], "#7");
+               }
+
+               [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");
+               }
+
+
+               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));
+               }
+
+#endif
+
+               public abstract class Stream : IDisposable
+               {
+                       public void Dispose ()
+                       {
+                               Console.WriteLine ("stream::dispose");
+                       }
+
+                       protected virtual void Dispose (bool disposing)
+                       {
+                       }
+               }
+
+               public class NonClosingStream 
+                       : Stream, IDisposable
+               {
+                       void  IDisposable.Dispose()
+                       {
+                               Console.WriteLine ("ncs::dispose");
+                       }
+
+                       public override string ToString () { return ""; }
+               }
+
                static bool ContainsProperty (PropertyInfo [] props, string name)
                {
                        foreach (PropertyInfo p in props)
@@ -3490,7 +4208,7 @@ PublicKeyToken=b77a5c561934e089"));
        
                public override Type UnderlyingSystemType { get { return this.type; } }
        
-               public override Assembly Assembly { get { return this.type.Assembly; } }
+               public override Assembly Assembly { get { return this.type == null ? null : this.type.Assembly; } }
        
                public override string AssemblyQualifiedName { get { return null; } }