public int structCaller(int x) { GenStruct <GenA <T> > gs = new GenStruct <GenA <T> > (123); return(gs.method(x)); }
public static void work <T> (T obj, bool mustCatch) { EqualityComparer <T> comp = EqualityComparer <T> .Default; GenA <T> ga = new GenA <T> (); typeCheck("newGen", ga.newGen(), typeof(GenA <T>)); typeCheck("newGenInt", ga.newGenInt(), typeof(GenA <int>)); typeCheck("getArr", ga.getArr(), typeof(T[])); typeCheck("newArr", ga.newArr(), typeof(T[])); typeCheck("newSelfArr", ga.newSelfArr(), typeof(GenA <T>[])); //ga.newArrNested (); typeCheck("newArrNested", ga.newArrNested(), typeof(GenB <GenB <T> >[])); if (ga.getGenField() != 123) { error("getGenField"); } 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)) { error("ident"); } 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>)); GenABDeriv <T> gabd = new GenABDeriv <T> (); typeCheck("GenABDeriv.newArr", gabd.newArr(), typeof(GenB <T>[])); typeCheck("GenABDeriv.newDerivArr", gabd.newDerivArr(), typeof(T[])); RGCTXTest <T> rt = new RGCTXTest <T> (); RGCTXTestSubA <T> rtsa = new RGCTXTestSubA <T> (); RGCTXTestSubB <T> rtsb = new RGCTXTestSubB <T> (); RGCTXTestSubASub rtsas = new RGCTXTestSubASub(); RGCTXTestSubASubSub <T> rtsass = new RGCTXTestSubASubSub <T> (); typeCheck("rtsass.newCArr", rtsass.newCArr(), typeof(GenC <T>[])); typeCheck("rgsa.newBArr", rtsa.newBArr(), typeof(GenB <T>[])); typeCheck("rg.newAArr", rt.newAArr(), typeof(GenA <T>[])); typeCheck("rgsb.newCArr", rtsb.newCArr(), typeof(GenC <T>[])); /* repeat all for each class */ typeCheck("rtsass.newCArr", rtsass.newCArr(), typeof(GenC <T>[])); typeCheck("rtsass.newBArr", rtsass.newBArr(), typeof(GenB <ClassA>[])); typeCheck("rtsass.newAArr", rtsass.newAArr(), typeof(GenA <ClassA>[])); typeCheck("rtsas.newBArr", rtsas.newBArr(), typeof(GenB <ClassA>[])); typeCheck("rtsas.newAArr", rtsas.newAArr(), typeof(GenA <ClassA>[])); typeCheck("rtsa.newBArr", rtsa.newBArr(), typeof(GenB <T>[])); typeCheck("rtsa.newAArr", rtsa.newAArr(), typeof(GenA <T>[])); typeCheck("rtsb.newCArr", rtsb.newCArr(), typeof(GenC <T>[])); typeCheck("rtsb.newAArr", rtsb.newAArr(), typeof(GenA <T>[])); typeCheck("rt.newAArr", rt.newAArr(), typeof(GenA <T>[])); }
public object unmakeNullable(GenStruct <T>?obj) { return((object)obj); }