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);
}
