JavaTXCompilerInJavaTX/javatx-src/test/java/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();
    }
}