package syntaxtreegenerator;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.HashMap;

import org.junit.BeforeClass;
import org.junit.Test;

import de.dhbwstuttgart.core.JavaTXCompiler;
import de.dhbwstuttgart.exceptions.NotImplementedException;
import de.dhbwstuttgart.syntaxtree.SourceFile;
import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;

/**
 * Unit-Tests für den 'SyntaxTreeGenerator' aus dem Package 'parser' nach Vorbild der Klasse 'TestComplete' aus dem Test-Package 'targetast'
 */
public class TestComplete {
    private static HashMap<String, File[]> javFiles = new HashMap<>();

    @BeforeClass
    public static void setUp() {
        final String testFileDirectory = "resources/bytecode/javFiles/";
        final String expectedASTDirectory = "resources/syntaxtreegenerator/";
        File dir = new File(testFileDirectory);
        for (File f : dir.listFiles(new JavFilter())) {
            String basefilename = f.getName().replace(".jav", "");
            javFiles.put(basefilename, new File[] { f, new File(expectedASTDirectory + basefilename + ".ast") });
        }
    }

    @Test
    public void applyLambdaTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("applyLambda")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("applyLambda")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for applyLambda.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for applyLambda.jav");
        }
    }

    @Test
    public void binaryInMethTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("BinaryInMeth")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("BinaryInMeth")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for BinaryInMeth.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for BinaryInMeth.jav");
        }
    }

    @Test
    public void classGenLamTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("ClassGenLam")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("ClassGenLam")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for ClassGenLam.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for ClassGenLam.jav");
        }
    }

    @Test
    public void facTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Fac")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Fac")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Fac.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Fac.jav");
        }
    }

    @Test
    public void facultyTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Faculty")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Faculty")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Faculty.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Faculty.jav");
        }
    }

    @Test
    public void fieldTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Field")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Field")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Field.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Field.jav");
        }
    }

    @Test
    public void fieldTph2Test() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("FieldTph2")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("FieldTph2")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for FieldTph2.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for FieldTph2.jav");
        }
    }

    @Test
    public void fieldTphConsMethTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("FieldTphConsMeth")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("FieldTphConsMeth")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for FieldTphConsMeth.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for FieldTphConsMeth.jav");
        }
    }

    @Test
    public void fieldTphMMethTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("FieldTphMMeth")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("FieldTphMMeth")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for FieldTphMMeth.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for FieldTphMMeth.jav");
        }
    }

    @Test
    public void genTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Gen")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Gen")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Gen.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Gen.jav");
        }
    }

    @Test
    public void idTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Id")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Id")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Id.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Id.jav");
        }
    }

    @Test
    public void infTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Inf")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Inf")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Inf.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Inf.jav");
        }
    }

    @Test
    public void kompTphTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("KompTph")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("KompTph")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for KompTph.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for KompTph.jav");
        }
    }

    @Test
    public void lambdaCaptureTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("LambdaCapture")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("LambdaCapture")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for LambdaCapture.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for LambdaCapture.jav");
        }
    }

    @Test
    public void lambdaTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Lambda")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Lambda")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Lambda.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Lambda.jav");
        }
    }

    @Test
    public void mathStrucIntegerTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("mathStrucInteger")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("mathStrucInteger")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for mathStrucInteger.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            assertTrue("An error occured while generating the AST for mathStrucInteger.jav", exc instanceof NotImplementedException);
        }
    }

    @Test
    public void mathStrucTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("mathStruc")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("mathStruc")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for mathStruc.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for mathStruc.jav");
        }
    }

    @Test
    public void matrixOPTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("MatrixOP")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("MatrixOP")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for MatrixOP.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for MatrixOP.jav");
        }
    }

    @Test
    public void matrixTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Matrix")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Matrix")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Matrix.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Matrix.jav");
        }
    }

    @Test
    public void mergeTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Merge")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Merge")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Merge.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Merge.jav");
        }
    }

    @Test
    public void overloadingSortingTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Sorting")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Sorting")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Sorting.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Sorting.jav");
        }
    }

    @Test
    public void overloadingTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Overloading")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Overloading")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Overloading.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Overloading.jav");
        }
    }

    @Test
    public void plusTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Plus")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Plus")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Plus.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Plus.jav");
        }
    }

    @Test
    public void relOpsTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("RelOps")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("RelOps")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for RelOps.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for RelOps.jav");
        }
    }

    @Test
    public void simpleCycleTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("SimpleCycle")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("SimpleCycle")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for SimpleCycle.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for SimpleCycle.jav");
        }
    }

    @Test
    public void subMatTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("SubMatrix")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("SubMatrix")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for SubMatrix.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for SubMatrix.jav");
        }
    }

    @Test
    public void tphTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Tph")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Tph")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Tph.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Tph.jav");
        }
    }

    @Test
    public void tph2Test() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Tph2")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Tph2")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Tph2.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Tph2.jav");
        }
    }

    @Test
    public void tph3Test() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Tph3")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Tph3")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Tph3.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Tph3.jav");
        }
    }

    @Test
    public void tph4Test() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Tph4")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Tph4")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Tph4.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Tph4.jav");
        }
    }

    @Test
    public void tph5Test() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Tph5")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Tph5")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Tph5.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Tph5.jav");
        }
    }

    @Test
    public void tph6Test() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Tph6")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Tph6")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Tph6.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Tph6.jav");
        }
    }

    @Test
    public void tph7Test() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Tph7")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Tph7")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Tph7.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Tph7.jav");
        }
    }

    @Test
    public void typedIdTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("TypedID")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("TypedID")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for TypedID.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for TypedID.jav");
        }
    }

    @Test
    public void vectorAddTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("VectorAdd")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("VectorAdd")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for VectorAdd.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for VectorAdd.jav");
        }
    }

    @Test
    public void vectorSuperTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("VectorSuper")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("VectorSuper")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for VectorSuper.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for VectorSuper.jav");
        }
    }

    @Test
    public void yTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Y")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Y")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Y.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Y.jav");
        }
    }

    @Test
    public void boxTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Box")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Box")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Box.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Box.jav");
        }
    }

    @Test
    public void cycleTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("Cycle")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("Cycle")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for Cycle.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for Cycle.jav");
        }
    }

    @Test
    public void olFunTest() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("OLFun")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("OLFun")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for OLFun.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for OLFun.jav");
        }
    }

    @Test
    public void olFun2Test() {
        try {
            FileInputStream fileIn = new FileInputStream(javFiles.get("OLFun2")[1]);
            String expectedAST = new String(fileIn.readAllBytes());
            fileIn.close();
            expectedAST = expectedAST.replaceAll("TPH [A-Z]+", "TPH");
            File srcfile = javFiles.get("OLFun2")[0];
            JavaTXCompiler compiler = new JavaTXCompiler(srcfile);
            String resultingAST = new String(ASTPrinter.print(compiler.sourceFiles.get(srcfile)));
            resultingAST = resultingAST.replaceAll("TPH [A-Z]+", "TPH");
            System.out.println("Expected:\n" + new String(expectedAST));
            System.out.println("Result:\n" + new String(resultingAST));
            assertEquals("Comparing expected and resulting AST for OLFun2.jav", expectedAST, resultingAST);
        } catch (Exception exc) {
            exc.printStackTrace();
            fail("An error occured while generating the AST for OLFun2.jav");
        }
    }
}

class JavFilter implements FileFilter {

    @Override
    public boolean accept(File pathname) {
        if (pathname.getName().contains(".jav"))
            return true;
        return false;
    }

}