X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Ftests%2Fgenerics-sharing.2.cs;h=6110cf2f8fad627ea0ccfb11c59fb75767efc348;hb=45d6da52ce69cbd24f5930e1cad88d425e706186;hp=19faeee1b2327a86c9711b8f99af80b2244882fa;hpb=89866fadb0772bc092d7c77a188053eae5b4be4a;p=mono.git

diff --git a/mono/tests/generics-sharing.2.cs b/mono/tests/generics-sharing.2.cs
index 19faeee1b23..6110cf2f8fa 100644
--- a/mono/tests/generics-sharing.2.cs
+++ b/mono/tests/generics-sharing.2.cs
@@ -1,18 +1,104 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection;
+
+namespace GenericSharingTest {
+
+public delegate int IntVoidDelegate ();
 
 public class ClassA {}
 public class ClassB {}
 public class ClassC {}
 
+public class GenExc<T> : Exception {}
+
 public class NonGen {
 	public static int field = 123;
+
+	public static void doThrow () {
+		throw new GenExc<ClassA> ();
+	}
+}
+
+public class GenBi<S,T> {
+	public static int field = 123;
+	public static float floatField = 1.0f;
+
+	public static int staticMethod (int x) {
+		return x + field;
+	}
+
+	public static void staticVoidMethod (int x) {
+		field = x;
+	}
+
+	public static float staticFloatMethod () {
+		return floatField;
+	}
+
+	public static long staticLongMethod (long x) {
+		return x + field;
+	}
+
+	public static GenStruct<T> staticValueMethod (int x) {
+		return new GenStruct<T> (x);
+	}
+}
+
+public struct GenStruct<T> {
+	public static int staticField;
+
+	public int field;
+	public int dummy1;
+	public int dummy2;
+	public int dummy3;
+
+	public GenStruct (int f) {
+		field = f;
+		dummy1 = dummy2 = dummy3 = 0;
+	}
+
+	public int method (int x) {
+		return x + field;
+	}
+}
+
+public interface IGen<T> {
+	T[] iMethod ();
+	void voidIMethod (int x);
+	long longIMethod (long x);
+	float floatIMethod ();
+	GenStruct<T> valueIMethod (int x);
+}
+
+public class IGenImpl<T> : IGen<T> {
+	public int field;
+
+	public T[] iMethod () {
+		return new T[3];
+	}
+
+	public void voidIMethod (int x) {
+		field = x;
+	}
+
+	public long longIMethod (long x) {
+		return x + 1;
+	}
+
+	public float floatIMethod () {
+		return 1.0f;
+	}
+
+	public GenStruct<T> valueIMethod (int x) {
+		return new GenStruct<T> (x);
+	}
 }
 
 public class GenA<T> {
 	public static T[] arr;
 
-	public static GenA () {
+	static GenA () {
 		arr = new T [3];
 	}
 
@@ -34,6 +120,10 @@ public class GenA<T> {
 		return NonGen.field;
 	}
 
+	public int getGenStructStaticField () {
+		return GenStruct<T>.staticField;
+	}
+
 	public T[] getArr () {
 		return arr;
 	}
@@ -66,6 +156,130 @@ public class GenA<T> {
 	public T cast (Object obj) {
 		return (T)obj;
 	}
+
+	public GenStruct<T> structCast (Object obj) {
+		return (GenStruct<T>)obj;
+	}
+
+	public Type ldtokenT () {
+		return typeof (T);
+	}
+
+	public Type ldtokenIGenT () {
+		return typeof (IGen<T>);
+	}
+
+	public Type ldtokenGenAIGenT () {
+		return typeof (GenA<IGen<T>>);
+	}
+
+	public Type ldtokenGenB () {
+		return typeof (GenB<>);
+	}
+
+	public GenStruct<T>? makeNullable (Object obj) {
+		return (GenStruct<T>?)obj;
+	}
+
+	public object unmakeNullable (GenStruct<T>? obj) {
+		return (object)obj;
+	}
+
+	public void except () {
+		try {
+			NonGen.doThrow ();
+		}
+		catch (GenExc<T>) {
+			//Console.WriteLine("exception thrown");
+		}
+	}
+
+	public static void staticExcept () {
+		try {
+			NonGen.doThrow ();
+		}
+		catch (GenExc<T>) {
+			Console.WriteLine("exception thrown and caught");
+		}
+	}
+
+	public static int staticField = 54321;
+
+	public static int staticMethod () {
+		return staticField;
+	}
+
+	public static int staticMethodCaller () {
+		return staticMethod ();
+	}
+
+	public static float staticFloatField = 1.0f;
+
+	public static float staticFloatMethod () {
+		return staticFloatField;
+	}
+
+	public static int staticBiCaller (int x) {
+		return GenBi<int,T>.staticMethod (x);
+	}
+
+	public static void staticBiVoidCaller (int x) {
+		GenBi<int,T>.staticVoidMethod (x);
+	}
+
+	public static float staticBiFloatCaller () {
+		return GenBi<int,T>.staticFloatMethod ();
+	}
+
+	public static GenStruct<T> staticBiValueCaller (int x) {
+		return GenBi<int,T>.staticValueMethod (x);
+	}
+
+	public static int staticSharedBiCaller (int x) {
+		return GenBi<T,T>.staticMethod (x);
+	}
+
+	public static void staticSharedBiVoidCaller (int x) {
+		GenBi<T,T>.staticVoidMethod (x);
+	}
+
+	public static float staticSharedBiFloatCaller () {
+		return GenBi<T,T>.staticFloatMethod ();
+	}
+
+	public static GenStruct<T> staticSharedBiValueCaller (int x) {
+		return GenBi<T,T>.staticValueMethod (x);
+	}
+
+	public static long staticBiLongCaller (long x) {
+		return GenBi<int, T>.staticLongMethod (x);
+	}
+
+	public int structCaller (int x) {
+		GenStruct<GenA<T>> gs = new GenStruct<GenA<T>> (123);
+
+		return gs.method (x);
+	}
+
+	public T[] callInterface (IGen<T> ig) {
+		return ig.iMethod ();
+	}
+
+	public void callVoidInterface (IGen<T> ig, int x) {
+		ig.voidIMethod (x);
+	}
+
+	public long callLongInterface (IGen<T> ig, long x) {
+		return ig.longIMethod (x);
+	}
+
+	public float callFloatInterface (IGen<T> ig) {
+		return ig.floatIMethod ();
+	}
+
+	public GenStruct<T> callValueInterface (IGen<T> ig, int x) {
+		return ig.valueIMethod (x);
+	}
 }
 
 public class GenB<T> {
@@ -75,7 +289,7 @@ public class GenB<T> {
 public class GenC<T> {
 	public static int field ;
 
-	public static GenC () {
+	static GenC () {
 		field = 1234;
 	}
 }
@@ -112,7 +326,7 @@ public class GenABDeriv<T> : GenA<GenB<T>> {
 
 public class NonGenUser<T> where T : NonGen {
 	public int getNonGenField () {
-		return T.field;
+		return NonGen.field;
 	}
 }
 
@@ -201,19 +415,37 @@ public class RGCTXTestSubASubSub<T> : RGCTXTestSubASub {
 }
 
 public class main {
+	delegate void ActionDelegate ();
+
 	static bool haveError = false;
 
-	public static void error (string message) {
+	static void error (string message) {
 		haveError = true;
 		Console.WriteLine (message);
 	}
 
-	public static void typeCheck (String method, Object obj, Type t) {
+	static void typeCheck (String method, Object obj, Type t) {
 		if (obj.GetType () != t)
 			error ("object from " + method + " should have type " + t.ToString () + " but has type " + obj.GetType ().ToString ());
 	}
 
-	public static void work<T> (T obj) {
+	static int callStaticMethod<T> () {
+		return GenA<T>.staticMethod ();
+	}
+
+	static void checkException<T> (String method, ActionDelegate action) where T : Exception {
+		try {
+			try {
+				action ();
+			} catch (T) {
+				return;
+			}
+		} catch (Exception exc) {
+			error ("method " + method + " should have thrown " + typeof (T).ToString () + " but did throw " + exc);
+		}
+	}
+
+	public static void work<T> (T obj, bool mustCatch) {
 		EqualityComparer<T> comp = EqualityComparer<T>.Default;
 
 		GenA<T> ga = new GenA<T> ();
@@ -232,6 +464,11 @@ public class main {
 		if (ga.getNonGenField () != 123)
 			error ("getNonGenField");
 
+		GenStruct<T>.staticField = 321;
+		if (ga.getGenStructStaticField () != 321)
+			error ("getGenStructStaticField");
+		GenStruct<T>.staticField = -1;
+
 		ga.hash (obj);
 
 		if (!comp.Equals (ga.ident (obj), obj))
@@ -239,9 +476,103 @@ public class main {
 
 		if (!comp.Equals (ga.cast (obj), obj))
 			error ("cast");
+		if (typeof (T).IsValueType) {
+			checkException<NullReferenceException> ("cast null value", delegate { ga.cast (null); });
+		} else {
+			if (ga.cast (null) != null)
+				error ("cast null");
+		}
+
+		GenStruct<T> genstructt = new GenStruct<T> (453);
+		if (ga.structCast ((object)genstructt).field != 453)
+			error ("structCast");
+		checkException<NullReferenceException> ("structCast null", delegate { ga.structCast (null); });
+
+		if (ga.makeNullable ((object)genstructt).Value.field != 453)
+			error ("makeNullable");
+		if (ga.makeNullable (null) != null)
+			error ("makeNullable null");
+
+		if (ga.ldtokenT () != typeof (T))
+			error ("ldtokenT");
+		if (ga.ldtokenIGenT () != typeof (IGen<T>))
+			error ("ldtokenIGenT");
+		if (ga.ldtokenGenAIGenT () != typeof (GenA<IGen<T>>))
+			error ("ldtokenGenAIGenT");
+		if (ga.ldtokenGenB () != typeof (GenB<>))
+			error ("ldtokenGenB");
+
+		if (callStaticMethod<T> () != 54321)
+			error ("staticMethod");
+
+		GenBi<int,T>.field = 123;
+		if (GenA<T>.staticBiCaller (123) != 246)
+			error ("staticBiCaller");
+		GenA<T>.staticBiVoidCaller (1234);
+		if (GenBi<int,T>.field != 1234)
+			error ("staticBiVoidCaller");
+		if (GenA<T>.staticBiFloatCaller () != 1.0f)
+			error ("staticBiFloatCaller");
+		if (GenA<T>.staticBiLongCaller (123) != 123 + 1234)
+			error ("staticBiLongCaller");
+		GenStruct<T> gs = GenA<T>.staticBiValueCaller (987);
+		if (gs.field != 987)
+			error ("staticBiValueCaller");
+
+		GenBi<T,T>.field = 123;
+		if (GenA<T>.staticSharedBiCaller (123) != 246)
+			error ("staticSharedBiCaller");
+		GenA<T>.staticSharedBiVoidCaller (1234);
+		if (GenBi<T,T>.field != 1234)
+			error ("staticSharedBiVoidCaller");
+		if (GenA<T>.staticSharedBiFloatCaller () != 1.0f)
+			error ("staticSharedBiFloatCaller");
+		GenStruct<T> gss = GenA<T>.staticSharedBiValueCaller (987);
+		if (gss.field != 987)
+			error ("staticSharedBiValueCaller");
+
+		IntVoidDelegate ivdel = new IntVoidDelegate (GenA<T>.staticMethod);
+		if (ivdel () != 54321)
+			error ("staticMethod delegate");
+
+		Type gatype = typeof (GenA<T>);
+		MethodInfo staticMethodInfo = gatype.GetMethod ("staticMethod");
+		if ((Convert.ToInt32 (staticMethodInfo.Invoke (null, null))) != 54321)
+			error ("staticMethod reflection");
+
+		if (GenA<T>.staticMethodCaller () != 54321)
+			error ("staticMethodCaller");
+
+		if (GenA<T>.staticFloatMethod () != 1.0)
+			error ("staticFloatMethod");
+
+		if (ga.structCaller (234) != 357)
+			error ("structCaller");
+
+		IGenImpl<T> igi = new IGenImpl<T> ();
+
+		typeCheck ("callInterface", ga.callInterface (igi), typeof (T[]));
+		if (ga.callLongInterface (igi, 345) != 346)
+			error ("callLongInterface");
+		GenStruct<T> gst = ga.callValueInterface (igi, 543);
+		if (gst.field != 543)
+			error ("callValueInterface");
+		ga.callVoidInterface (igi, 654);
+		if (igi.field != 654)
+			error ("callVoidInterface");
+		if (ga.callFloatInterface (igi) != 1.0f)
+			error ("callFloatInterface");
 
 		new GenADeriv<T> ();
 
+		if (mustCatch) {
+			checkException<GenExc<ClassA>> ("except", delegate { ga.except (); });
+			checkException<GenExc<ClassA>> ("staticExcept", delegate { GenA<T>.staticExcept (); });
+		} else {
+			ga.except ();
+			GenA<T>.staticExcept ();
+		}
+
 		MyDict<T, ClassB> dtb = new MyDict<T, ClassB> (obj, new ClassB ());
 
 		typeCheck ("MyPair", dtb.p, typeof (MyPair<T, ClassB>));
@@ -299,12 +630,16 @@ public class main {
 
 	public static int Main ()
 	{
-		work<ClassA> (new ClassA ());
-		work<ClassB> (new ClassB ());
-		work<ClassC> (new ClassC ());
-		work<GenA<ClassA>> (new GenA<ClassA> ());
-		work<int[]> (new int[3]);
-		work<int> (123);
+		work<ClassA> (new ClassA (), false);
+		work<ClassB> (new ClassB (), true);
+		work<ClassB> (new ClassB (), true);
+		work<ClassC> (new ClassC (), true);
+		work<GenA<ClassA>> (new GenA<ClassA> (), true);
+		work<int[]> (new int[3], true);
+		work<int> (123, true);
+		work<int?> (123, true);
+		work<GenStruct<ClassA>?> (new GenStruct<ClassA> (123), true);
+		work<GenStruct<ClassA>?> (null, true);
 
 		StaticTest<ClassA> sa = new StaticTest<ClassA> (1234);
 		StaticTest<ClassB> sb = new StaticTest<ClassB> (2345);
@@ -343,3 +678,5 @@ public class main {
 		return 0;
 	}
 }
+
+}