JavaTXCompilerInJavaTXNoMaven/tests/TestComplete.java

import de.dhbwstuttgart.environment.ByteArrayClassLoader;
import org.junit.Ignore;
import org.junit.Test;

import java.lang.reflect.*;
import java.util.Arrays;
import java.util.Vector;

import targetast.TestCodegen;

import static org.junit.Assert.*;
import static targetast.TestCodegen.generateClassFiles;

public class TestComplete {

    
    // @Test
    // public void applyLambdaTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "applyLambda.jav");
    //     var applyLambda = classFiles.get("applyLambda");
    //     var instance = applyLambda.getDeclaredConstructor().newInstance();
    //     var m = applyLambda.getDeclaredMethod("m");
    //     var result = m.invoke(instance);

    //     assertEquals(result.getClass(), classFiles.get("Apply"));
    // }

    @Test
    public void binaryTest() throws Exception {
        var classFiles = generateClassFiles(new ByteArrayClassLoader(), "BinaryInMeth.jav");
        var binaryInMeth = classFiles.get("BinaryInMeth");
        var instance = binaryInMeth.getDeclaredConstructor().newInstance();

        var m2 = binaryInMeth.getDeclaredMethod("m2", Integer.class, Integer.class);
        var m3 = binaryInMeth.getDeclaredMethod("m3", Integer.class);
        assertEquals(6, m2.invoke(instance, 2, 3));
        assertEquals(4, m3.invoke(instance, 2));
    }

    // @Test
    // public void classGenLamTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "ClassGenLam.jav");
    //     classFiles.get("ClassGenLam").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void facTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Fac.jav");
    //     var fac = classFiles.get("Fac");
    //     var instance = fac.getDeclaredConstructor().newInstance();

    //     var getFac = fac.getDeclaredMethod("getFac", Integer.class);
    //     // assertEquals(6, getFac.invoke(instance, 3)); TODO This could be either an Integer or a Double so this simple test fails
    // }

    // @Test
    // public void facultyTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Faculty.jav");

    //     var fac = classFiles.get("Faculty");
    //     var constructor = fac.getDeclaredConstructor();
    //     constructor.setAccessible(true);
    //     var instance = constructor.newInstance();

    //     var getFact = fac.getDeclaredMethod("getFact", Integer.class);
    //     assertEquals(6, getFact.invoke(instance, 3));
    // }

    // @Test
    // public void fieldTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Field.jav");
    //     var field = classFiles.get("Field");
    //     var instance = field.getDeclaredConstructor().newInstance();
    //     assertEquals(1, field.getFields().length);
    // }

    // @Test
    // public void fieldTph2Test() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "FieldTph2.jav");
    //     var fieldtph2 = classFiles.get("FieldTph2");
    //     var instance = fieldtph2.getDeclaredConstructor().newInstance();

    //     var a = fieldtph2.getDeclaredField("a");
    //     var m2 = fieldtph2.getDeclaredMethod("m2", Object.class);
    //     m2.invoke(instance, 1);

    //     var m = fieldtph2.getDeclaredMethod("m", Object.class);
    //     assertEquals(1, m.invoke(instance, 1));
    // }

    // @Test
    // public void fieldTphConsMethTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "FieldTphConsMeth.jav");
    //     var fieldTphConsMeth = classFiles.get("FieldTphConsMeth");

    //     var ctor = fieldTphConsMeth.getDeclaredConstructor(Object.class);
    //     var instance = ctor.newInstance("C");
    //     var a = fieldTphConsMeth.getDeclaredField("a");
    //     var id = fieldTphConsMeth.getDeclaredMethod("id", Object.class);

    //     assertEquals(42, id.invoke(instance, 42));
    //     assertEquals("C", a.get(instance));
    // }

    // @Test
    // public void fieldTphMMethTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "FieldTphMMeth.jav");
    //     var fieldTphMMeth = classFiles.get("FieldTphMMeth");
    //     var ctor = fieldTphMMeth.getDeclaredConstructor(Object.class, Object.class, Boolean.class);

    //     var instance1 = ctor.newInstance("C", 42, true);
    //     var instance2 = ctor.newInstance("C", 42, false);

    //     var m = fieldTphMMeth.getDeclaredMethod("m", Object.class, Object.class, Boolean.class);
    //     assertEquals(42, m.invoke(instance1, "C", 42, false));

    //     var a = fieldTphMMeth.getDeclaredField("a");
    //     assertEquals("C", a.get(instance1));
    //     assertEquals(42, a.get(instance2));
    // }

    // @Test
    // public void genTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Gen.jav");
    // }

    // @Test
    // public void idTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Id.jav");
    //     var instance = classFiles.get("Id").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void infTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Inf.jav");
    //     var instance = classFiles.get("Inf").getDeclaredConstructor().newInstance();
    //     // TODO check generics
    // }

    // @Test
    // public void kompTphTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "KompTph.jav");
    //     var instance = classFiles.get("KompTph").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void lambdaCaptureTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "LambdaCapture.jav");
    //     var instance = classFiles.get("LambdaCapture").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void lambdaTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Lambda.jav");
    //     var classToTest = classFiles.get("Lambda");
    //     var instanceOfClass = classToTest.getDeclaredConstructor().newInstance();

    //     var m = classToTest.getDeclaredMethod("m");
    //     var lambda = m.invoke(instanceOfClass).getClass();
    //     var apply = lambda.getMethod("apply", Object.class);
    //     apply.setAccessible(true);

    //     var i = Integer.valueOf(77);
    //     assertEquals(i, apply.invoke(m.invoke(instanceOfClass), i));
    // }

    // @Test
    // public void mathStrucInteger() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "mathStrucInteger.jav");
    //     var mathStrucInteger = classFiles.get("mathStrucInteger");
    //     mathStrucInteger.getDeclaredConstructor(Integer.class).newInstance(10);
    // }

    // @Test
    // public void mathStruc() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "mathStruc.jav");
    //     var mathStruc = classFiles.get("mathStruc");
    //     mathStruc.getDeclaredConstructor(Object.class).newInstance("A");
    // }

    // @Test
    // public void matrixOpTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "MatrixOP.jav");
    //     var matrixOP = classFiles.get("MatrixOP");

    //     Vector<Vector<Integer>> vv = new Vector<>();
    //     Vector<Integer> v1 = new Vector<>();
    //     v1.addElement(2);
    //     v1.addElement(2);
    //     Vector<Integer> v2 = new Vector<>();
    //     v2.addElement(3);
    //     v2.addElement(3);
    //     vv.addElement(v1);
    //     vv.addElement(v2);

    //     var instanceOfClass_m1 = matrixOP.getDeclaredConstructor(Vector.class).newInstance(vv);

    //     Vector<Vector<Integer>> vv1 = new Vector<>();
    //     Vector<Integer> v3 = new Vector<>();
    //     v3.addElement(2);
    //     v3.addElement(2);
    //     Vector<Integer> v4 = new Vector<>();
    //     v4.addElement(3);
    //     v4.addElement(3);
    //     vv1.addElement(v3);
    //     vv1.addElement(v4);

    //     var instanceOfClass_m2 = matrixOP.getDeclaredConstructor(Vector.class).newInstance(vv1);// Matrix m2 = new Matrix(vv1);

    //     var mul = matrixOP.getField("mul");
    //     mul.setAccessible(true);

    //     var lambda = mul.get(instanceOfClass_m1).getClass();
    //     var apply = lambda.getMethod("apply", Object.class, Object.class);
    //     apply.setAccessible(true);

    //     var result = apply.invoke(mul.get(instanceOfClass_m1), instanceOfClass_m1, instanceOfClass_m2);
    //     System.out.println(instanceOfClass_m1.toString() + " * " + instanceOfClass_m2.toString() + " = " + result.toString());

    //     Vector<Vector<Integer>> res = new Vector<>();
    //     Vector<Integer> v5 = new Vector<>();
    //     v5.addElement(10);
    //     v5.addElement(10);
    //     Vector<Integer> v6 = new Vector<>();
    //     v6.addElement(15);
    //     v6.addElement(15);
    //     res.addElement(v5);
    //     res.addElement(v6);

    //     var instanceOfClass_m3 = matrixOP.getDeclaredConstructor(Vector.class).newInstance(res);
    //     assertEquals(result, instanceOfClass_m3);
    // }

    // @Test
    // //@Ignore("This is too complex")
    // public void matrixTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Matrix.jav");
    //     var matrix = classFiles.get("Matrix");

    //     Vector<Vector<Integer>> vv = new Vector<>();
    //     Vector<Integer> v1 = new Vector<>();
    //     v1.addElement(2);
    //     v1.addElement(2);
    //     Vector<Integer> v2 = new Vector<>();
    //     v2.addElement(3);
    //     v2.addElement(3);
    //     vv.addElement(v1);
    //     vv.addElement(v2);

    //     var instanceOfClass_m1 = matrix.getDeclaredConstructor(Vector.class).newInstance(vv);

    //     Vector<Vector<Integer>> vv1 = new Vector<>();
    //     Vector<Integer> v3 = new Vector<>();
    //     v3.addElement(2);
    //     v3.addElement(2);
    //     Vector<Integer> v4 = new Vector<>();
    //     v4.addElement(3);
    //     v4.addElement(3);
    //     vv1.addElement(v3);
    //     vv1.addElement(v4);

    //     var instanceOfClass_m2 = matrix.getDeclaredConstructor(Vector.class).newInstance(vv1);

    //     var mul = matrix.getDeclaredMethod("mul", Vector.class);
    //     var result = mul.invoke(instanceOfClass_m1, instanceOfClass_m2);
    //     System.out.println(instanceOfClass_m1.toString() + " * " + instanceOfClass_m2.toString() + " = " + result.toString());

    //     Vector<Vector<Integer>> res = new Vector<>();
    //     Vector<Integer> v5 = new Vector<>();
    //     v5.addElement(10);
    //     v5.addElement(10);
    //     Vector<Integer> v6 = new Vector<>();
    //     v6.addElement(15);
    //     v6.addElement(15);
    //     res.addElement(v5);
    //     res.addElement(v6);

    //     var instanceOfClass_m3 = matrix.getDeclaredConstructor(Vector.class).newInstance(res);
    //     assertEquals(result, instanceOfClass_m3);
    // }

    // @Test
    // public void scalarTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Scalar.jav");
    //     var scalar = classFiles.get("Scalar");

    //     Vector<Vector<Integer>> vv = new Vector<>();
    //     Vector<Integer> v1 = new Vector<>();
    //     v1.addElement(2);
    //     v1.addElement(2);

    //     var instanceOfClass_s1 = scalar.getDeclaredConstructor(Vector.class).newInstance(v1);

    //     Vector<Integer> v2 = new Vector<>();
    //     v2.addElement(2);
    //     v2.addElement(2);

    //     var instanceOfClass_s2 = scalar.getDeclaredConstructor(Vector.class).newInstance(v2);

    //     var mul = scalar.getDeclaredMethod("mul", Vector.class);
    //     var result = mul.invoke(instanceOfClass_s1, instanceOfClass_s2);
    //     System.out.println(instanceOfClass_s1.toString() + " * " + instanceOfClass_s2.toString() + " = " + result.toString());

    //     assertEquals(result, 8);
    // }

    // @Test
    // public void mergeTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Merge.jav");
    //     var instance = classFiles.get("Merge").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void overloadingSortingTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Sorting.jav");
    //     var instance = classFiles.get("Sorting").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void overloadingTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Overloading.jav");
    //     var overloading = classFiles.get("Overloading");
    //     var overloading2 = classFiles.get("Overloading2");
    //     var instance1 = overloading.getDeclaredConstructor().newInstance();
    //     var instance2 = overloading2.getDeclaredConstructor().newInstance();

    //     var m1 = overloading.getDeclaredMethod("test", overloading);
    //     assertEquals("Overloading", m1.invoke(instance1, instance1));
    //     var m2 = overloading.getDeclaredMethod("test", overloading2);
    //     assertEquals("Overloading2", m2.invoke(instance1, instance2));
    // }

    // @Test
    // public void plusTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Plus.jav");
    //     var plus = classFiles.get("Plus");
    //     var instance = plus.getDeclaredConstructor().newInstance();

    //     var addInt = plus.getDeclaredMethod("m", Integer.class, Integer.class);
    //     assertEquals(10, addInt.invoke(instance, 7, 3));

    //     var addString = plus.getDeclaredMethod("m", String.class, String.class);
    //     assertEquals("ByteCode", addString.invoke(instance, "Byte", "Code"));
    // }

    // @Test
    // public void relOpsTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "RelOps.jav");
    //     var relOps = classFiles.get("RelOps");
    //     var instance = relOps.getDeclaredConstructor().newInstance();

    //     var m = relOps.getDeclaredMethod("m", Integer.class, Integer.class);
    //     assertFalse((Boolean) m.invoke(instance, 7, 3));
    // }

    // @Test
    // public void simpleCyclesTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "SimpleCycle.jav");
    //     var instance = classFiles.get("SimpleCycle").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void subMatTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "SubMatrix.jav");
    //     var instance = classFiles.get("SubMatrix").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void tphTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Tph.jav");
    //     var tph = classFiles.get("Tph");
    //     var instance = tph.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void tph2Test() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Tph2.jav");
    //     var tph2 = classFiles.get("Tph2");
    //     var instance = tph2.getDeclaredConstructor().newInstance();

    //     assertEquals(1, tph2.getTypeParameters().length);
    //     // public class Tph2<DZG>
    //     var DZG = tph2.getTypeParameters()[0];

    //     var id = tph2.getDeclaredField("id");
    //     // public Fun1$$<DZG, DZG> id
    //     var idParams = ((ParameterizedType) id.getGenericType()).getActualTypeArguments();
    //     assertEquals(2, idParams.length);
    //     assertEquals(DZG, idParams[0]);
    //     assertEquals(DZG, idParams[1]);

    //     var id3 = tph2.getDeclaredMethod("id3", Object.class);
    //     // public <U extends DZG> DZG id3(U var1)
    //     var paraTypes = id3.getGenericParameterTypes();
    //     var typeParaTypes = id3.getTypeParameters();

    //     var U = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[0])).findFirst().get();
    //     assertEquals(DZG, U.getBounds()[0]);
    //     assertEquals(DZG, id3.getGenericReturnType());
    // }

    // @Test
    // public void tph3Test() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Tph3.jav");
    //     var tph3 = classFiles.get("Tph3");
    //     var instance = tph3.getDeclaredConstructor().newInstance();
    //     var m1 = tph3.getDeclaredMethod("m1", Object.class, Object.class);

    //     // public <DXBE extends DXBD, DXBD> void m1(DXBD var1, DXBE var2)
    //     var paraTypes = m1.getGenericParameterTypes();
    //     var typeParaTypes = m1.getTypeParameters();

    //     var DXBD = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[0])).findFirst().get();
    //     assertEquals(Object.class, DXBD.getBounds()[0]);
    //     var DXBE = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[1])).findFirst().get();
    //     assertEquals(DXBD, DXBE.getBounds()[0]);

    //     var m2 = tph3.getDeclaredMethod("m2", Object.class);

    //     // public <V> void m2(V var1)
    //     var paraTypes2 = m2.getGenericParameterTypes();
    //     var typeParaTypes2 = m2.getTypeParameters();

    //     var V = Arrays.stream(typeParaTypes2).filter(t -> t.equals(paraTypes2[0])).findFirst().get();
    //     assertEquals(Object.class, V.getBounds()[0]);
    // }

    // @Test
    // public void tph4Test() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Tph4.jav");
    //     var tph4 = classFiles.get("Tph4");
    //     var instance = tph4.getDeclaredConstructor().newInstance();
    //     var m = tph4.getDeclaredMethod("m", Object.class, Object.class);

    //     // public <N, O> N m(O var1, N var2) {
    //     var paraTypes = m.getGenericParameterTypes();
    //     var typeParaTypes = m.getTypeParameters();

    //     var N = Arrays.stream(typeParaTypes).filter(t -> t.equals(m.getGenericReturnType())).findFirst().get();
    //     assertEquals(Object.class, N.getBounds()[0]);

    //     var O = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[0])).findFirst().get();
    //     var N2 = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[1])).findFirst().get();
    //     assertEquals(N, N2);
    //     assertEquals(N.getBounds()[0], Object.class);
    //     assertEquals(O.getBounds()[0], Object.class);

    //     var m2 = tph4.getDeclaredMethod("m2", Object.class);

    //     // public <X> X m2(X var1)
    //     var paraTypes2 = m2.getGenericParameterTypes();
    //     var typeParaTypes2 = m2.getTypeParameters();

    //     var X = Arrays.stream(typeParaTypes2).filter(t -> t.equals(paraTypes2[0])).findFirst().get();
    //     assertEquals(Object.class, X.getBounds()[0]);
    //     assertEquals(X, m2.getGenericReturnType());
    // }

    // @Test
    // public void tph5Test() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Tph5.jav");
    //     var tph5 = classFiles.get("Tph5");
    //     var instance = tph5.getDeclaredConstructor().newInstance();
    //     var m = tph5.getDeclaredMethod("m", Object.class, Object.class);

    //     // public <N, O extends N> void m(N var1, O var2)
    //     var paraTypes = m.getGenericParameterTypes();
    //     var typeParaTypes = m.getTypeParameters();

    //     var N = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[0])).findFirst().get();
    //     var O = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[1])).findFirst().get();

    //     assertEquals(O.getBounds()[0], N);
    //     assertEquals(Object.class, N.getBounds()[0]);

    //     var m2 = tph5.getDeclaredMethod("m2", Object.class);

    //     // public <R> R m2(R var1)
    //     var paraTypes2 = m2.getGenericParameterTypes();
    //     var typeParaTypes2 = m2.getTypeParameters();

    //     var R = Arrays.stream(typeParaTypes2).filter(t -> t.equals(paraTypes2[0])).findFirst().get();
    //     assertEquals(Object.class, R.getBounds()[0]);
    //     assertEquals(R, m2.getGenericReturnType());
    // }

    // @Test
    // public void tph6Test() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Tph6.jav");
    //     var tph5 = classFiles.get("Tph6");
    //     var instance = tph5.getDeclaredConstructor().newInstance();
    //     var m = tph5.getDeclaredMethod("m", Object.class, Object.class);

    //     // public <P, O> void m(O var1, P var2)
    //     var paraTypes = m.getGenericParameterTypes();
    //     var typeParaTypes = m.getTypeParameters();

    //     var P = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[0])).findFirst().get();
    //     var O = Arrays.stream(typeParaTypes).filter(t -> t.equals(paraTypes[1])).findFirst().get();

    //     assertEquals(P.getBounds()[0], Object.class);
    //     assertEquals(O.getBounds()[0], Object.class);

    //     var m2 = tph5.getDeclaredMethod("m2", Object.class);

    //     // public <W> W m2(W var1)
    //     var paraTypes2 = m2.getGenericParameterTypes();
    //     var typeParaTypes2 = m2.getTypeParameters();

    //     var W = Arrays.stream(typeParaTypes2).filter(t -> t.equals(paraTypes2[0])).findFirst().get();
    //     assertEquals(Object.class, W.getBounds()[0]);
    //     assertEquals(W, m2.getGenericReturnType());
    // }

    // @Test
    // public void Tph7Test() throws Exception {
    //     var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "Tph7.jav");
    //     var classToTest = classFiles.get("Tph7");
    //     var instanceOfClass = classToTest.getDeclaredConstructor().newInstance();

    //     // public <N, O> N m(O var1, N var2)
    //     Method m = classToTest.getDeclaredMethod("m", Object.class, Object.class);

    //     // System.out.println(m.toString());

    //     // Argumenttypes of the method m
    //     var paraTypes = m.getGenericParameterTypes();

    //     // Typeparameters of the method m
    //     var typeParaTypes = m.getTypeParameters();

    //     // Typeparameters are extracted from the argumenttypes
    //     // Conditions for the extracted typeparameters are set

    //     // paraTypes[0] = O
    //     var boundFstArg = Arrays.stream(typeParaTypes).filter(x -> x.equals(paraTypes[0])).findFirst().get().getBounds();

    //     // Bound of O has to be Object
    //     assertEquals(Object.class, Arrays.stream(boundFstArg).findFirst().get());

    //     // paraTypes[1] = N
    //     var N = Arrays.stream(typeParaTypes).filter(x -> x.equals(paraTypes[1])).findFirst().get();
    //     var boundSndArg = N.getBounds();

    //     // Bound of H has to be Object
    //     assertEquals(Object.class, Arrays.stream(boundSndArg).findFirst().get());

    //     // N has to be the return type of m
    //     assertEquals(N, m.getGenericReturnType());

    //     // public <DZU> DZU m2(DZU);
    //     Method m2 = classToTest.getDeclaredMethod("m2", Object.class);

    //     // Argumenttypes of the method m2
    //     var paraTypesm2 = m2.getGenericParameterTypes();

    //     // Typeparameters of the method m2
    //     var typeParaTypesm2 = m2.getTypeParameters();

    //     // Typeparameters are extracted from the argumenttypes
    //     // Conditions for the extracted typeparameters are set

    //     // paraTypes[0] = DZU
    //     var fstArgm2 = Arrays.stream(typeParaTypesm2).filter(x -> x.equals(paraTypesm2[0])).findFirst().get();

    //     // Bound of DZU has to be Object
    //     assertEquals(Object.class, Arrays.stream(fstArgm2.getBounds()).findFirst().get());

    //     // DZU has to be the return type of m
    //     assertEquals(fstArgm2, m2.getGenericReturnType());
    // }

    // @Test
    // public void testTXGenerics() throws Exception {
    //     var classLoader = new ByteArrayClassLoader();
    //     generateClassFiles(classLoader, "Cycle.jav");
    //     var classFiles = generateClassFiles(classLoader, "TXGenerics.jav");
    //     var instance = classFiles.get("TXGenerics").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void typedIdTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "TypedID.jav");
    //     var instance = classFiles.get("TypedID").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void vectorAddTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "VectorAdd.jav");
    //     var instance = classFiles.get("VectorAdd").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void vectorSuperTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "VectorSuper.jav");
    //     var instance = classFiles.get("VectorSuper").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void yTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Y.jav");
    //     var instance = classFiles.get("Y").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // @Ignore("This one isn't working")
    // public void boxTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Box.jav");
    //     var instance = classFiles.get("Box_Main").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void cycleTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Cycle.jav");
    //     var instance = classFiles.get("Cycle").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void olFunTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "OLFun.jav");
    //     var instance = classFiles.get("OLFun").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void olFun2Test() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "OLFun2.jav");
    //     var instance = classFiles.get("OLFun2").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void pairTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Pair.jav");
    //     var instance = classFiles.get("Pair").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void olTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "OL.jav");
    //     var instance = classFiles.get("OL").getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void recordTest() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "RecordTest.jav");
    //     var clazz = classFiles.get("RecordTest");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     assertTrue((Boolean) clazz.getDeclaredMethod("doesEqual").invoke(instance));
    //     assertFalse((Boolean) clazz.getDeclaredMethod("doesNotEqual").invoke(instance));
    //     System.out.println(clazz.getDeclaredMethod("hashCode").invoke(instance));
    //     System.out.println(clazz.getDeclaredMethod("toString").invoke(instance));
    // }

    // @Test
    // public void testSwitch() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Switch.jav");
    //     var clazz = classFiles.get("Switch");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     var swtch = clazz.getDeclaredMethod("main", Object.class);

    //     var record = classFiles.get("Rec");
    //     var ctor = record.getDeclaredConstructor(Integer.class, Object.class);
    //     var r1 = ctor.newInstance(10, 20);
    //     var r2 = ctor.newInstance(10, 20f);
    //     var r3 = ctor.newInstance(10, r1);

    //     assertEquals(swtch.invoke(instance, r1), 30);
    //     assertEquals(swtch.invoke(instance, r2), 20);
    //     assertEquals(swtch.invoke(instance, r3), 40);
    //     assertEquals(swtch.invoke(instance, 50), 50);
    //     assertEquals(swtch.invoke(instance, "Some string"), 0);
    // }

    // @Ignore("Not implemented")
    // @Test
    // public void testSwitch2() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Switch2.jav");
    //     var clazz = classFiles.get("Switch2");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testStringSwitch() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "SwitchString.jav");
    //     var clazz = classFiles.get("SwitchString");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     var main = clazz.getDeclaredMethod("main", String.class);

    //     assertEquals(main.invoke(instance, "AaAaAa"), 1);
    //     assertEquals(main.invoke(instance, "AaAaBB"), 2);
    //     assertEquals(main.invoke(instance, "test"), 3);
    //     assertEquals(main.invoke(instance, "TEST"), 3);
    //     assertEquals(main.invoke(instance, "awawa"), 4);
    // }

    // @Test
    // public void testInstanceOfPattern() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "InstanceOf.jav");
    //     var clazz = classFiles.get("InstanceOf");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Ignore("Not implemented")
    // @Test
    // public void testOverloadPattern() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "OverloadPattern.jav");
    //     var clazz = classFiles.get("OverloadPattern");
    //     var rec = classFiles.get("Point");

    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     var m1 = clazz.getDeclaredMethod("m", rec);
    //     var m2 = clazz.getDeclaredMethod("m", Integer.class);

    //     var pt = rec.getDeclaredConstructor(Number.class, Number.class).newInstance(10, 20);
    //     assertEquals(m1.invoke(instance, pt), 30);
    //     assertEquals(m2.invoke(instance, 10), 10);
    // }

    // @Test
    // public void testInterfaces() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Interfaces.jav");
    //     var clazz = classFiles.get("Interfaces");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }
    // @Test
    // public void testStatic() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Static.jav");
    //     var clazz = classFiles.get("Static");
    //     var m = clazz.getDeclaredMethod("m");
    //     assertEquals(m.invoke(null), 50);
    // }

    // @Test
    // public void testFor() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "For.jav");
    //     var clazz = classFiles.get("For");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     var m = clazz.getDeclaredMethod("m", Integer.class);
    //     assertEquals(m.invoke(instance, 10), 60);
    // }

    // @Test
    // public void testForEach() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "ForEach.jav");
    //     var clazz = classFiles.get("ForEach");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     var m = clazz.getDeclaredMethod("m");
    //     assertEquals(m.invoke(instance), 6);
    // }
    
    // @Test
    // public void testLambdaRunnable() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "LambdaRunnable.jav");
    //     var clazz = classFiles.get("LambdaRunnable");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     //var m = clazz.getDeclaredMethod("m", Integer.class);
    //     //assertEquals(m.invoke(instance, 10), 60);
    // }

    // @Test
    // public void testFunctionalInterface() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "FunctionalInterface.jav");
    //     var clazz = classFiles.get("FunctionalInterface");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     var m = clazz.getDeclaredMethod("m");
    //     assertEquals(m.invoke(instance), 200);
    // }

    // @Test
    // public void testChain() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Chain.jav");
    //     var clazz = classFiles.get("Chain");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     var m = clazz.getDeclaredMethod("m");
    //     assertEquals(m.invoke(instance), 5);
    // }

    // @Test
    // public void testHelloWorld() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "HelloWorld.jav");
    //     var clazz = classFiles.get("HelloWorld");
    //     var hello = clazz.getDeclaredMethod("hello");
    //     hello.invoke(null);
    // }

    // @Test
    // public void testSuperCall() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "SuperCall.jav");
    //     var clazz = classFiles.get("SuperCall");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testInstanceOf() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "InstanceOf.jav");
    //     var clazz = classFiles.get("InstanceOf");
    //     var instance = clazz.getDeclaredConstructor().newInstance();

    //     assertTrue((Boolean) clazz.getDeclaredMethod("test1").invoke(instance));
    //     assertTrue((Boolean) clazz.getDeclaredMethod("test2").invoke(instance));
    //     assertFalse((Boolean) clazz.getDeclaredMethod("test3").invoke(instance));
    // }

    // @Test
    // public void testExceptions() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Exceptions.jav");
    //     var clazz = classFiles.get("Exceptions");
    //     var instance = clazz.getDeclaredConstructor().newInstance();

    //     try {
    //         clazz.getDeclaredMethod("m").invoke(instance);
    //         fail("No exception thrown!");
    //     } catch (InvocationTargetException exception) {
    //         var exc = exception.getTargetException();
    //         if (!(exc instanceof RuntimeException rexp) || !rexp.getMessage().equals("Some Exception")) {
    //             fail("Wrong exception thrown!");
    //         }
    //     }
    // }

    // @Test
    // public void testLiteral() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Literal.jav");
    //     var clazz = classFiles.get("Literal");
    //     var instance = clazz.getDeclaredConstructor().newInstance();

    //     assertNull(clazz.getDeclaredMethod("m").invoke(instance));
    //     assertEquals(clazz.getDeclaredMethod("m2").invoke(instance), 'C');
    // }

    // @Test
    // public void testOLConstructor() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "OLConstructor.jav");
    //     var clazz = classFiles.get("Child");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    //     assertEquals(clazz.getSuperclass().getDeclaredField("x").get(instance), 3);
    // }

    // @Ignore("Not implemented")
    // @Test
    // public void testStringConcat() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Op2.jav");
    //     var clazz = classFiles.get("Op2");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testLamRunnable() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "LamRunnable.jav");
    //     var clazz = classFiles.get("LamRunnable");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testAccess() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Access.jav");
    //     var clazzPublic = classFiles.get("Access");
    //     var clazzDefault = classFiles.get("AccessDefault");

    //     assertEquals(clazzPublic.getModifiers(), Modifier.PUBLIC);
    //     assertEquals(clazzDefault.getModifiers(), 0);

    //     assertEquals(clazzPublic.getDeclaredMethod("mPublic").getModifiers(), Modifier.PUBLIC);
    //     assertEquals(clazzPublic.getDeclaredMethod("mProtected").getModifiers(), Modifier.PROTECTED);
    //     assertEquals(clazzPublic.getDeclaredMethod("mDefault").getModifiers(), 0);
    //     assertEquals(clazzPublic.getDeclaredMethod("mPrivate").getModifiers(), Modifier.PRIVATE);

    //     assertEquals(clazzPublic.getDeclaredField("fPublic").getModifiers(), Modifier.PUBLIC);
    //     assertEquals(clazzPublic.getDeclaredField("fProtected").getModifiers(), Modifier.PROTECTED);
    //     assertEquals(clazzPublic.getDeclaredField("fDefault").getModifiers(), 0);
    //     assertEquals(clazzPublic.getDeclaredField("fPrivate").getModifiers(), Modifier.PRIVATE);
    // }

    // @Test
    // public void testTypeCast() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "TypeCast.jav");
    //     var clazz = classFiles.get("TypeCast");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testAnnotation() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Annotation.jav");
    //     var clazz = classFiles.get("Annotation");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testWilcards() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Wildcards.jav");
    //     var clazz = classFiles.get("Wildcards");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }


    // @Test
    // public void testBug122() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Bug122.jav");
    //     var clazz = classFiles.get("Bug122");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testBug123() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Bug123.jav");
    //     var clazz = classFiles.get("Bug123");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testBug125() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Bug125.jav");
    //     var clazz = classFiles.get("Bug125");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testBug112() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Bug112.jav");
    //     var clazz = classFiles.get("Bug112");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testBug285() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Bug285.jav");
    //     var clazz = classFiles.get("Bug285");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testBug290() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Bug290A.jav");
    //     var clazz = classFiles.get("Bug290A");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }

    // @Test
    // public void testBug293() throws Exception {
    //     var classFiles = generateClassFiles(new ByteArrayClassLoader(), "Bug293.jav");
    //     var clazz = classFiles.get("Bug293");
    //     var instance = clazz.getDeclaredConstructor().newInstance();
    // }
}