.gitignore

@@ -83,3 +83,4 @@ src/test/resources/output/javac/CompilerInput$Test.class
 src/test/resources/output/javac/CompilerInput.class
 src/test/resources/output/raupenpiler/CompilerInput.class
 src/test/resources/output/raupenpiler/CompilerInput$Test.class
+.idea/inspectionProfiles/Project_Default.xml

src/main/java/main/Main.java

@@ -20,13 +20,11 @@ import java.nio.file.Paths;
  * <p> <code> cd .\src\test\ </code>
  * <p> <code> make clean compile-raupenpiler </code>
  * <p> Start Raupenpiler using jar:
- * <p> <code> java.exe -jar path_to_jar\JavaCompiler-1.0-SNAPSHOT-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
+ * <p> <code> java.exe -jar path_to_jar\JavaCompiler-1.0-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
  * <p> Example (jar needs to be in the target directory, compile with make or mvn package first):
- * <code> java.exe -jar .\target\JavaCompiler-1.0-SNAPSHOT-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
+ * <code> java.exe -jar .\target\JavaCompiler-1.0-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
  */
 public class Main {
-
-
     public static void main(String[] args) throws Exception {
         if (args.length == 2) {
             // args[0] is the input file path

src/main/java/main/RaupenLogger.java

@@ -16,18 +16,18 @@ import java.util.List;
 import java.util.logging.*;
 
 /**
- Beispiel für Logging-Arten:
- <p><code>logger.severe("Schwerwiegender Fehler");</code>
- <p><code>logger.warning("Warnung");</code>
- <p><code>logger.info("Information");</code>
- <p><code>logger.config("Konfigurationshinweis");</code>
- <p><code>logger.fine("Fein");</code>
- <p><code>logger.finer("Feiner");</code>
- <p><code>logger.finest("Am feinsten");</code>
- <p>You may toggle the logging level of the console and file handlers by
- changing the level ALL/OFF/etc. in the constructor.
- <code>consoleHandler.setLevel(Level.OFF);</code>
- <code>fileHandler.setLevel(Level.ALL);</code>
+ * Beispiel für Logging-Arten:
+ * <p><code>logger.severe("Schwerwiegender Fehler");</code>
+ * <p><code>logger.warning("Warnung");</code>
+ * <p><code>logger.info("Information");</code>
+ * <p><code>logger.config("Konfigurationshinweis");</code>
+ * <p><code>logger.fine("Fein");</code>
+ * <p><code>logger.finer("Feiner");</code>
+ * <p><code>logger.finest("Am feinsten");</code>
+ * <p>You may toggle the logging level of the console and file handlers by
+ * changing the level ALL/OFF/etc. in the constructor.
+ * <code>consoleHandler.setLevel(Level.OFF);</code>
+ * <code>fileHandler.setLevel(Level.ALL);</code>
  */
 public class RaupenLogger {
 
@@ -172,9 +172,9 @@ public class RaupenLogger {
         }
         String indentString = " ".repeat(indent * 2);
         logger.info(indentString + abstractSyntaxTree.getClass());
+        //for (ASTNode child : abstractSyntaxTree.getChildren()) {
+        //    logAST(child, indent + 1);
+       // }
 
-        // for (ASTNode child : node.) {
-        // printAST(child, indent + 1);
-        // }
     }
 }

src/main/java/semantic/Scope.java

@@ -1,7 +1,7 @@
 package semantic;
 
 import ast.type.type.*;
-import semantic.exeptions.AlreadyDeclearedException;
+import semantic.exceptions.AlreadyDeclaredException;
 
 import java.util.HashMap;
 import java.util.Stack;
@@ -16,7 +16,7 @@ public class Scope {
 
     public void addLocalVar(String name, ITypeNode type) {
         if (this.contains(name)) {
-            throw new AlreadyDeclearedException("Variable " + name + " already exists in this scope");
+            throw new AlreadyDeclaredException("Variable " + name + " already exists in this scope");
         }
         localVars.peek().put(name, type);
     }

src/main/java/semantic/SemanticAnalyzer.java

@@ -24,7 +24,7 @@ import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
 import ast.statements.*;
 import ast.type.type.*;
 import semantic.context.Context;
-import semantic.exeptions.*;
+import semantic.exceptions.*;
 import typechecker.TypeCheckResult;
 
 public class SemanticAnalyzer implements SemanticVisitor {
@@ -116,7 +116,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 if (Objects.equals(otherMethod, methodNode))
                     break;
                 if (otherMethod.isSame(methodNode)) {
-                    errors.add(new AlreadyDeclearedException(
+                    errors.add(new AlreadyDeclaredException(
                             "Method " + methodNode.getIdentifier() + " is already defined in class "
                                     + currentClass.identifier));
                     valid = false;
@@ -129,8 +129,8 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 valid = valid && result.isValid();
                 try {
                     currentScope.addLocalVar(parameter.identifier, parameter.type);
-                } catch (AlreadyDeclearedException e) {
-                    errors.add(new AlreadyDeclearedException(parameter.identifier));
+                } catch (AlreadyDeclaredException e) {
+                    errors.add(new AlreadyDeclaredException(parameter.identifier));
                 }
 
             }
@@ -164,7 +164,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
     @Override
     public TypeCheckResult analyze(FieldNode toCheck) {
         if (currentFields.get(toCheck.identifier) != null) {
-            errors.add(new AlreadyDeclearedException("Already declared " + toCheck.identifier));
+            errors.add(new AlreadyDeclaredException("Already declared " + toCheck.identifier));
             return new TypeCheckResult(false, null);
         } else {
             currentFields.put(toCheck.identifier, toCheck.type);
@@ -361,7 +361,7 @@ public class SemanticAnalyzer implements SemanticVisitor {
         } else if(currentFields.get(unary.identifier) != null) {
             return  new TypeCheckResult(valid, currentFields.get(unary.identifier));
         } else {
-            errors.add(new NotDeclearedException("Var is not Decleared"));
+            errors.add(new NotDeclaredException("Var is not Declared"));
         }
         return new TypeCheckResult(valid, null);
     }

src/main/java/semantic/exceptions/AlreadyDeclaredException.java

@@ -0,0 +1,9 @@
+package semantic.exceptions;
+
+public class AlreadyDeclaredException extends RuntimeException {
+
+    public AlreadyDeclaredException(String message) {
+        super(message);
+    }
+
+}

src/main/java/semantic/exceptions/AlreadyDefinedException.java

@@ -1,4 +1,4 @@
-package semantic.exeptions;
+package semantic.exceptions;
 
 public class AlreadyDefinedException extends RuntimeException {
 

src/main/java/semantic/exceptions/MultipleReturnTypes.java

@@ -1,4 +1,4 @@
-package semantic.exeptions;
+package semantic.exceptions;
 
 public class MultipleReturnTypes extends RuntimeException {
 

src/main/java/semantic/exceptions/NotDeclaredException.java

@@ -0,0 +1,9 @@
+package semantic.exceptions;
+
+public class NotDeclaredException extends RuntimeException {
+
+    public NotDeclaredException(String message) {
+        super(message);
+    }
+
+}

src/main/java/semantic/exceptions/TypeMismatchException.java

@@ -1,4 +1,4 @@
-package semantic.exeptions;
+package semantic.exceptions;
 
 public class TypeMismatchException extends RuntimeException {
 

src/main/java/semantic/exceptions/UnknownException.java

@@ -0,0 +1,9 @@
+package semantic.exceptions;
+
+public class UnknownException extends RuntimeException {
+
+    public UnknownException(String message) {
+        super(message);
+    }
+
+}

src/main/java/semantic/exeptions/AlreadyDeclearedException.java

@@ -1,9 +0,0 @@
-package semantic.exeptions;
-
-public class AlreadyDeclearedException extends RuntimeException {
-
-    public AlreadyDeclearedException(String message) {
-        super(message);
-    }
-
-}

src/main/java/semantic/exeptions/NotDeclearedException.java

@@ -1,9 +0,0 @@
-package semantic.exeptions;
-
-public class NotDeclearedException extends RuntimeException {
-
-    public NotDeclearedException(String message) {
-        super(message);
-    }
-
-}

src/test/Makefile

@@ -10,20 +10,33 @@ compile-javac:
 compile-raupenpiler:
 	cd ../.. ; mvn -DskipTests install
 	cd ../.. ; mvn exec:java -Dexec.mainClass="main.Main"  -Dexec.args="'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' "
+	cp ../main/resources/output/CompilerInput.class .java/resources/output/raupenpiler
 
-test: test-javac test-raupenpiler
+test: compile-javac compile-raupenpiler test-javac test-raupenpiler
 
 test-javac:
-	#compile-javac
-	#java -cp .\resources\output\javac CompilerInput
+	# gleich wie bei raupenpiler, kann ich ohne funktionierenden Compiler nicht testen
+
 
 test-raupenpiler:
-	#java -cp .\resources\output\raupenpiler CompilerInput
+	# move the compiled class to the test/main folder
+	mv ../main/resources/output/CompilerInput.class .java/main/
+	# compile the test class
+	javac .java/main.EndToEndTester.java
+	# run the test class
+	java .java/main.EndToEndTester
+
+
 
 clean:
+	# clean output folders
+	rm -f ../main/resources/output/*.class
 	rm -f ./resources/output/javac/*.class
 	rm -f ./resources/output/raupenpiler/*.class
-	rm -f ./java/*.class
-	rm -f ../main/resources/output/*.class
+	# clean logs
 	rm -f ../main/resources/logs/*.log
+	# clean test/main folders from .class files for End-to-End tests
+	rm -f ./java/main/*.class
+	# clean javac output from featureTests
+	rm -f ./resources/input/featureTests/*.class
 

src/test/TestSpecs.md

@@ -78,8 +78,8 @@ Compiled Classfile
 
 wenn beides erfolgreich
 
-- Ergebnis vom eigenen Compiler mithilfe von main.TestCompilerOutput ausführen
-- (Ergebnis von javac mithilfe von main.TestCompilerOutput ausführen)
+- Ergebnis vom eigenen Compiler mithilfe von main.EndToEndTester ausführen
+- (Ergebnis von javac mithilfe von main.EndToEndTester ausführen)
 
 ### Andis Tipps:
 
@@ -89,4 +89,5 @@ wenn beides erfolgreich
 - mvn package
 - javac tester // tester compilen
 - java tester // tester ausführen
-- -> tester ist in unserem Fall main.TestCompilerOutput.java
+- -> tester ist in unserem Fall main.EndToEndTester.java
+- -> Hab ich alles umgesetzt

src/test/java/main/EmptyClassExample.java

@@ -1,6 +0,0 @@
-package main;
-
-public class EmptyClassExample {
-    private class Inner {
-    }
-} // -o für outout

src/test/java/main/EndToEndTester.java

@@ -3,18 +3,18 @@ package main;
 /**
  * This class is used to test the output of the compiler.
  *
- * <p>Im gleichen Ordner wie diese Datei (main.TestCompilerOutput.java) muss die selbst kompilierte CompilerInput.class Datei sein.
- * <br><strong>Hinweis:</strong> Diese muss man also vom Ordner <code> main/resources/output </code> in diesen Ordner hier (test/java) rein kopieren. (bis es eine bessere Lösung gibt)</p>
+ * <p>Im gleichen Ordner wie diese Datei (EndToEndTester.java) muss die selbst kompilierte CompilerInput.class Datei sein.
+ * <br><strong>Hinweis:</strong> Diese muss man also vom Ordner <code> main/resources/output </code> in diesen Ordner hier (test/java/main) rein kopieren. (bis es eine bessere Lösung gibt -> bin grad in der Make dran das alles hier automatisch zu machen)</p>
  *
  * <p>Die selbst kompilierte .class Datei wird dann hier drin geladen und eine Instanz von ihr erstellt, es können auch Methoden aufgerufen werden.
- * <p>Diese main.TestCompilerOutput.java Datei wird dann in <code> \src\test\java> </code>  mit <code>javac .\main.TestCompilerOutput.java</code> kompiliert und mit <code>java main.TestCompilerOutput</code> ausgeführt.
+ * <p>Diese EndToEndTester.java Datei wird dann in <code> \src\test\java> </code>  mit <code>javac .\main.EndToEndTester.java</code> kompiliert und mit <code>java main.EndToEndTester</code> ausgeführt.
  * Wenn unser Compiler funktioniert, sollten keine Errors kommen (sondern nur die Ausgaben, die wir in der CompilerInput.java Datei gemacht haben,
  * oder Methoden, die wir hier aufrufen).</p>
  *
  * <p><strong>PROBLEM:</strong> Hier kommen Errors, was eigentlich heißt, dass der Compiler nicht funktioniert, der Test sollte eigentlich passen.
  * <br><strong>DENN:</strong> Wenn ich statt unserem CompilerInput.class die CompilerInput.class von javac verwende (aus  <code> src/test/resources/output/javac </code>), dann funktioniert es.</p>
  */
-public class TestCompilerOutput {
+public class EndToEndTester {
     public static void main(String[] args) {
         try {
             // Try to load the class named "CompilerInput"

src/test/java/main/FailureTest.java

@@ -3,71 +3,45 @@ package main;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.CharStreams;
 import org.junit.jupiter.api.Test;
 
 import javax.tools.JavaCompiler;
 import javax.tools.ToolProvider;
 import java.io.File;
-import java.io.IOException;
-import java.nio.file.Paths;
-import java.util.Arrays;
-import java.util.List;
 
 public class FailureTest {
-    private static final List<String> TEST_FILES = Arrays.asList(
-            "src/main/test/resources/input/failureTests/TestClass1.java",
-            "src/main/test/resources/input/failureTests/TestClass2.java",
-            "src/main/test/resources/input/failureTests/TestClass3.java",
-            "src/main/test/resources/input/failureTests/TestClass4.java",
-            "src/main/test/resources/input/failureTests/TestClass5.java",
-            "src/main/test/resources/input/failureTests/TestClass6.java",
-            "src/main/test/resources/input/failureTests/TestClass7.java",
-            "src/main/test/resources/input/failureTests/TestClass8.java",
-            "src/main/test/resources/input/failureTests/TestClass9.java",
-            "src/main/test/resources/input/failureTests/TestClass10.java",
-            "src/main/test/resources/input/failureTests/TestClass11.java"
-    );
-
     /**
      * This test method checks if invalid Java files fail to compile as expected.
      * It uses the JavaCompiler from the ToolProvider to compile the files.
      * The test passes if all the files fail to compile.
      */
     @Test
-    public void invalidJavaFilesTest() {
+    public void areTestFilesActuallyFailTest() {
         // Get the system Java compiler
-        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
-
+        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
         // Assert that the compiler is available
-        assertNotNull(compiler, "Java Compiler is not available");
+        assertNotNull(javac, "Java Compiler is not available");
 
-        // Iterate over the test files
-        for (String fileName : TEST_FILES) {
-            // Create a File object for the current file
-            File file = new File(fileName);
+        String directoryPath = "src/test/resources/input/failureTests";
+        File folder = new File(directoryPath);
 
-            // Try to compile the file and get the result
-            // The run method returns 0 if the compilation was successful, and non-zero otherwise
-            int result = compiler.run(null, null, null, file.getPath());
+        if (folder.isDirectory()) {
+            File[] files = folder.listFiles((dir, name) -> name.endsWith(".java"));
 
-            // Assert that the compilation failed (i.e., the result is non-zero)
-            assertTrue(result != 0, "Expected compilation failure for " + fileName);
-        }
-    }
+            if (files != null) {
+                for (File file : files) {
+                    // Try to compile the file and get the result
+                    // The run method returns 0 if the compilation was successful, and non-zero otherwise
+                    int result = javac.run(null, null, null, file.getPath());
 
-    // schmeißt John Fehler, wenn namen doppelt sind?
-    // Input: ParseTree mit genanntem Fehler
-    // Output: Fehlermeldung
-    @Test
-    void typedASTTest() throws IOException {
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/main/EmptyClassExample.java"));
-            Main.compileFile(codeCharStream, "src/main/test/resources/output");
-        } catch (IOException e) {
-            System.err.println("Error reading the file: " + e.getMessage());
+                    // Assert that the compilation failed (i.e., the result is non-zero)
+                    assertTrue(result != 0, "Expected compilation failure for " + file.getName());
+                }
+            } else {
+                System.out.println("No files found in the directory.");
+            }
+        } else {
+            System.out.println("The provided path is not a directory.");
         }
     }
 }

src/test/java/main/FeatureTest.java

@@ -0,0 +1,46 @@
+package main;
+
+import org.junit.jupiter.api.Test;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import java.io.File;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class FeatureTest {
+    /**
+     * This test method checks if valid Java files compile successfully.
+     * It uses the JavaCompiler from the ToolProvider to compile the files.
+     * The test passes if all the files compile without errors.
+     */
+    @Test
+    public void areTestFilesActuallyValid() {
+        // Get the system Java compiler
+        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+        // Assert that the compiler is available
+        assertNotNull(javac, "Java Compiler is not available");
+
+        String directoryPath = "src/test/resources/input/featureTests";
+        File folder = new File(directoryPath);
+
+        if (folder.isDirectory()) {
+            File[] files = folder.listFiles((dir, name) -> name.endsWith(".java"));
+
+            if (files != null) {
+                for (File file : files) {
+                    // Try to compile the file and get the result
+                    // The run method returns 0 if the compilation was successful, and non-zero otherwise
+                    int result = javac.run(null, null, null, file.getPath());
+
+                    // Assert that the compilation succeeded (i.e., the result is zero)
+                    assertEquals(0, result, "Expected compilation success for " + file.getName());
+                }
+            } else {
+                System.out.println("No files found in the directory.");
+            }
+        } else {
+            System.out.println("The provided path is not a directory.");
+        }
+    }
+}

src/test/java/main/MainTest.java

@@ -7,14 +7,14 @@ import org.antlr.v4.runtime.CharStreams;
 import java.io.IOException;
 import java.nio.file.Paths;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
 
 /**
- * run: mvn test
+ * run every test: mvn test
+ * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
  */
 public class MainTest {
     @Test
-    void testEmptyClass() {
+    void test() {
         CharStream codeCharStream = null;
         try {
             codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/CompilerInput.java"));

src/test/java/parser/AstBuilderTest.java

@@ -0,0 +1,103 @@
+package parser;
+
+import ast.ClassNode;
+import ast.ProgramNode;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.junit.jupiter.api.Test;
+import parser.astBuilder.ASTBuilder;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class AstBuilderTest {
+
+    @Test
+    public void astBuilderTest() {
+        // ---------------- Leere Klasse nachgebaut ----------------
+
+        ProgramNode expectedASTEmptyClass = new ProgramNode();
+
+        // public class Name {}
+        ClassNode nameClass = new ClassNode("public", "Name");
+
+        expectedASTEmptyClass.addClass(nameClass);
+
+
+        // ---------------- Leere Klasse erzeugt ----------------
+
+        // init
+        CharStream inputCharStream = CharStreams.fromString("public class Name {}");
+        SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+        tokenStream.fill();
+
+        /* Parser -> Parsetree */
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTreeEmptyClass = parser.program(); // parse the input
+
+        /* AST builder -> AST */
+        ASTBuilder astBuilder = new ASTBuilder();
+        ProgramNode actualASTEmptyClass = (ProgramNode) new ASTBuilder().visit(parseTreeEmptyClass);
+
+
+        // ---------------- Vergleichen ----------------
+
+        String expectedASTasString = expectedASTEmptyClass.toString();
+        String actualASTasString = new ASTBuilder().visit(parseTreeEmptyClass).toString();
+
+        // Wie vergleiche ich das?
+        assertEquals(expectedASTasString, actualASTasString);
+        assertEquals(expectedASTEmptyClass, actualASTEmptyClass);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    // ---------------- Alter CompilerInput nachgebaut ----------------
+    // ProgramNode startNode = new ProgramNode();
+    // public class CompilerInput {}
+    // ClassNode compilerInputClass = new ClassNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), "CompilerInput");
+    // public int a;
+    //  compilerInputClass.addMember(new FieldNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), new BaseTypeNode(EnumTypeNode.INT), "a"));
+    // public static int testMethod(char x) { return 0; }
+      /*  compilerInputClass.addMember(
+                new MethodNode(
+                        new AccessTypeNode(EnumAccessTypeNode.PUBLIC),
+                        new BaseTypeNode(EnumTypeNode.INT),
+                        "testMethod",
+                        new ParameterListNode(List.of(new ParameterNode(new BaseTypeNode(EnumTypeNode.CHAR), "x"))),
+                        List.of(new ReturnStatementNode(new LiteralNode(0)))
+                        ));
+
+        ClassNode testClass = new ClassNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), "Test");
+        testClass.addMember(
+                new MethodNode(
+                        new AccessTypeNode(EnumAccessTypeNode.PUBLIC),
+                        new BaseTypeNode(EnumTypeNode.INT),
+                        "testMethod",
+                        new ParameterListNode(List.of(new ParameterNode(new BaseTypeNode(EnumTypeNode.CHAR), "x"), new ParameterNode(new BaseTypeNode(EnumTypeNode.INT), "a"))),
+                        List.of(new ReturnStatementNode(new LiteralNode(0)))
+                )
+        );
+
+       */
+
+    //compilerInputClass.addClass(testClass);
+
+    //  startNode.addClass(compilerInputClass);
+    // startNode.addClass(testClass);
+}

src/test/java/parser/ParserTest.java

@@ -4,7 +4,6 @@ import org.antlr.v4.runtime.*;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import parser.astBuilder.ASTBuilder;
 import parser.generated.SimpleJavaLexer;
 import parser.generated.SimpleJavaParser;
 
@@ -13,41 +12,13 @@ import static org.junit.jupiter.api.Assertions.*;
 import java.util.*;
 
 public class ParserTest {
+    /*
     @BeforeEach
     public void init() { // noch nicht benötigt
         String inputFilePath = "src/main/resources/input/CompilerInput.java";
         String outputDirectoryPath = "src/main/resources/output";
     }
-
-    /**
-     * This test method is used to test the scanner functionality of the SimpleJavaLexer.
-     * It creates a CharStream from a string representing a simple Java class declaration,
-     * and uses the SimpleJavaLexer to tokenize this input.
-     * It then compares the actual tokens and their types produced by the lexer to the expected tokens and their types.
      */
-    @Test
-    public void scannerTest() {
-        // Create a CharStream from a string representing a simple Java class declaration
-        CharStream inputCharStream = CharStreams.fromString("public class Name {}");
-
-        // Use the SimpleJavaLexer to tokenize the input
-        SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-        tokenStream.fill();
-
-        // Prepare the expected results
-        List<Token> actualTokens = tokenStream.getTokens();
-        List<String> expectedTokens = Arrays.asList("public", "class", "Name", "{", "}", "<EOF>");
-        List<String> expectedTokenTypes = Arrays.asList(null, null, "IDENTIFIER", null, null, "EOF");
-
-        // Compare the actual tokens and their types to the expected tokens and their types
-        assertEquals(expectedTokens.size(), actualTokens.size());
-        for (int i = 0; i < expectedTokens.size(); i++) {
-            assertEquals(expectedTokens.get(i), actualTokens.get(i).getText());
-            assertEquals(expectedTokenTypes.get(i), SimpleJavaLexer.VOCABULARY.getSymbolicName(actualTokens.get(i).getType()));
-        }
-    }
-
 
     @Test
     public void parserTest() {
@@ -63,38 +34,20 @@ public class ParserTest {
         ParseTree parseTree = parser.program(); // parse the input
 
         //Variante 1 (geht)
+        String expectedParseTreeAsString = "(program (classDeclaration public class Name { }))";
         String actualParseTreeAsString = parseTree.toStringTree(parser);
-        String expectedParseTreeAsString = "(program (classDeclaration (accessType public) class Name { }))";
 
-        assertEquals(actualParseTreeAsString, expectedParseTreeAsString);
+        assertEquals(expectedParseTreeAsString, actualParseTreeAsString);
 
-        //Variante 2 (geht nicht)
+        // Variante 2 (geht nicht)
         // - Sollte es gehen und es liegt am Parser? (keine Ahnung)  -> Bitte Fehler (actual und expected) durchlesen
-        Map<String, Object> actualTreeStructure = buildTreeStructure(parseTree, parser);
+        // ist die Methode parseStringToTree() korrekt? -> (glaub nicht)
         Map<String, Object> expectedTreeStructure = parseStringToTree(expectedParseTreeAsString);
+        Map<String, Object> actualTreeStructure = buildTreeStructure(parseTree, parser);
 
-        assertEquals(actualTreeStructure, expectedTreeStructure);
-
-
+        // assertEquals(expectedTreeStructure, actualTreeStructure);
     }
 
-    @Test
-    public void astBuilderTest() {
-        // TODO: Implement this test method
-
-
-
-
-        /* AST builder -> AST */
-        ASTBuilder astBuilder = new ASTBuilder();
-        //   ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        //String actualASTasString = new ASTBuilder().visit(parseTree).toString();
-
-        // ProgramNode actualAST = new ASTBuilder().visit(parseTree);
-        // ProgramNode expectedAST = new ProgramNode();
-        // expectedAST.add(new ProgramNode.ClassNode("Name", new ProgramNode()));
-    }
 
 
     // Helpers Variante 2.1
@@ -146,7 +99,7 @@ public class ParserTest {
         for (char ch : input.toCharArray()) {
             if (ch == '(') {
                 if (depth == 0) {
-                    if (currentToken.length() > 0) {
+                    if (!currentToken.isEmpty()) {
                         node.put("node", currentToken.toString().trim());
                         currentToken.setLength(0);
                     }
@@ -163,7 +116,7 @@ public class ParserTest {
                     currentToken.append(ch);
                 }
             } else if (Character.isWhitespace(ch) && depth == 0) {
-                if (currentToken.length() > 0) {
+                if (!currentToken.isEmpty()) {
                     node.put("node", currentToken.toString().trim());
                     currentToken.setLength(0);
                 }
@@ -172,7 +125,7 @@ public class ParserTest {
             }
         }
 
-        if (currentToken.length() > 0) {
+        if (!currentToken.isEmpty()) {
             node.put("node", currentToken.toString().trim());
         }
 

src/test/java/parser/ScannerTest.java

@@ -0,0 +1,45 @@
+package parser;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.Token;
+import org.junit.jupiter.api.Test;
+import parser.generated.SimpleJavaLexer;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class ScannerTest {
+
+    /**
+     * This test method is used to test the scanner functionality of the SimpleJavaLexer.
+     * It creates a CharStream from a string representing a simple Java class declaration,
+     * and uses the SimpleJavaLexer to tokenize this input.
+     * It then compares the actual tokens and their types produced by the lexer to the expected tokens and their types.
+     */
+    @Test
+    public void scannerTest() {
+        // Create a CharStream from a string representing a simple Java class declaration
+        CharStream inputCharStream = CharStreams.fromString("public class Name {}");
+
+        // Use the SimpleJavaLexer to tokenize the input
+        SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+        tokenStream.fill();
+
+        // Prepare the expected results
+        List<String> expectedTokens = Arrays.asList("public", "class", "Name", "{", "}", "<EOF>");
+        List<String> expectedTokenTypes = Arrays.asList("AccessModifier", "Class", "Identifier", "OpenCurlyBracket", "ClosedCurlyBracket", "EOF");
+        List<Token> actualTokens = tokenStream.getTokens();
+
+        // Compare the actual tokens and their types to the expected tokens and their types
+        assertEquals(expectedTokens.size(), actualTokens.size());
+        for (int i = 0; i < expectedTokens.size(); i++) {
+            assertEquals(expectedTokens.get(i), actualTokens.get(i).getText());
+            assertEquals(expectedTokenTypes.get(i), SimpleJavaLexer.VOCABULARY.getSymbolicName(actualTokens.get(i).getType()));
+        }
+    }
+}

src/test/java/semantic/EndToTAST.java

@@ -1,282 +0,0 @@
-package semantic;
-
-import ast.ASTNode;
-import ast.ProgramNode;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.CharStreams;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.tree.ParseTree;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import parser.astBuilder.ASTBuilder;
-import parser.generated.SimpleJavaLexer;
-import parser.generated.SimpleJavaParser;
-import semantic.exeptions.AlreadyDeclearedException;
-import semantic.exeptions.MultipleReturnTypes;
-import semantic.exeptions.NotDeclearedException;
-import semantic.exeptions.TypeMismatchException;
-
-import java.io.IOException;
-import java.nio.file.Paths;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-public class EndToTAST {
-
-    @BeforeEach
-    public void setup(){
-        SemanticAnalyzer.clearAnalyzer();
-    }
-
-    @Test
-    public void CorrectTest(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/CorrectTest.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program(); // parse the input
-
-        /* ------------------------- AST builder -> AST ------------------------- */
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-
-        assertEquals(SemanticAnalyzer.errors.size(), 0);
-        assertNotNull(tast);
-
-    }
-
-    @Test
-    public void notDecleared() {
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/NotDecleared.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program(); // parse the input
-
-        /* ------------------------- AST builder -> AST ------------------------- */
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(NotDeclearedException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void typeMismatch(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/TypeMismatchIntBool.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void parameterAlreadyDecleared(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/ParameterAlreadyDecleared.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(AlreadyDeclearedException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void fieldAlreadyDecleared(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/FieldAlreadyDecleared.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(AlreadyDeclearedException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void typeMismatchRefType(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/TypeMismatchRefType.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void correctRetType(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/CorrectRetType.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertTrue(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-    @Test
-    public void retTypeMismatch(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/retTypeMismatch.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(TypeMismatchException.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void multipleRetType(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/MultipleRetTypes.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-        assertInstanceOf(MultipleReturnTypes.class, SemanticAnalyzer.errors.getFirst());
-
-    }
-
-    @Test
-    public void wrongTypeInIfClause(){
-
-        CharStream codeCharStream = null;
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/semantic/endToTAST/WrongIfClause.java"));
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTree = parser.program();
-
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
-
-        ASTNode tast = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-
-        assertFalse(SemanticAnalyzer.errors.isEmpty());
-
-    }
-
-}

src/test/java/semantic/EndToTypedAstTest.java

@@ -0,0 +1,218 @@
+package semantic;
+
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.tree.ParseTree;
+
+import ast.ASTNode;
+import ast.ProgramNode;
+
+import parser.astBuilder.ASTBuilder;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class EndToTypedAstTest {
+    private static final Map<String, Class<?>> exceptionMap = new HashMap<>();
+
+    @Test
+    public void exceptionsTest() {
+        String directoryPath = "src/test/resources/input/typedAstExceptionsTests";
+        File folder = new File(directoryPath);
+
+        try {
+            loadCustomExceptions();
+            System.out.println("Custom exceptions loaded successfully.");
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to load custom exceptions", e);
+
+        }
+
+        if (folder.isDirectory()) {
+            File[] files = folder.listFiles((_, name) -> name.endsWith(".java"));
+            if (files != null) {
+                for (File file : files) {
+                    String expectedException = extractExpectedException(file);
+
+                    SemanticAnalyzer.clearAnalyzer();
+                    CharStream codeCharStream;
+                    try {
+                        codeCharStream = CharStreams.fromPath(Paths.get(file.getPath()));
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                    SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
+                    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+
+                    SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+                    ParseTree parseTree = parser.program();
+
+                    ASTBuilder astBuilder = new ASTBuilder();
+                    ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
+
+                    ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+                    if (expectedException != null) {
+                        System.out.println("Testing the file: " + file.getName());
+                        assertFalse(SemanticAnalyzer.errors.isEmpty(), "Expected an exception, but none was found.");
+                        assertInstanceOf(getExceptionClass(expectedException), SemanticAnalyzer.errors.getFirst());
+                    } else {
+                        System.out.println("No expected exception specified.");
+                        // If no expected exception is specified, you might want to add a different check
+                        // e.g., assertTrue(SemanticAnalyzer.errors.isEmpty(), "No exceptions expected, but some were found.");
+                    }
+                }
+            } else {
+                System.out.println("No files found in the directory.");
+            }
+        } else {
+            System.out.println("The provided path is not a directory.");
+        }
+    }
+
+    @Test
+    public void featureTest(){
+        String directoryPath = "src/test/resources/input/typedAstFeaturesTests";
+        File folder = new File(directoryPath);
+        if (folder.isDirectory()) {
+            File[] files = folder.listFiles((_, name) -> name.endsWith(".java"));
+            if (files != null) {
+                for (File file : files) {
+                    SemanticAnalyzer.clearAnalyzer();
+                    CharStream codeCharStream;
+                    try {
+                        codeCharStream = CharStreams.fromPath(Paths.get(file.getPath()));
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                    SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
+                    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+
+                    SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+                    ParseTree parseTree = parser.program();
+
+                    ASTBuilder astBuilder = new ASTBuilder();
+                    ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
+
+                    ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+                    System.out.println("Testing the file: " + file.getName());
+                    assertTrue(SemanticAnalyzer.errors.isEmpty());
+                    assertNotNull(typedAst);
+                }
+            } else {
+                System.out.println("No files found in the directory.");
+            }
+        } else {
+            System.out.println("The provided path is not a directory.");
+        }
+    }
+
+
+
+
+    // ------------------ Helpers ------------------
+    /**
+     * This method is used to extract the expected exception from a given file.
+     * It reads the file line by line and uses a regular expression to match the expected exception annotation.
+     * The expected exception annotation should be in the format: "// @expected: ExceptionName".
+     * If the expected exception annotation is found, it returns the name of the expected exception.
+     * If the expected exception annotation is not found, it returns null.
+     *
+     * @param file The file from which the expected exception is to be extracted.
+     * @return The name of the expected exception, or null if the expected exception annotation is not found.
+     */
+    private String extractExpectedException(File file) {
+        String annotationPattern = "//\\s*@expected:\\s*(\\S+)";
+        Pattern pattern = Pattern.compile(annotationPattern);
+        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                Matcher matcher = pattern.matcher(line);
+                if (matcher.find()) {
+                    return matcher.group(1);
+                }
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+ * This method is used to retrieve the Class object associated with a given exception name.
+ * It first prints the original exception name, then appends the package name to the exception name and prints it.
+ * It then retrieves the Class object from the exceptionMap using the fully qualified exception name.
+ * If the Class object is not found in the exceptionMap, it throws a RuntimeException.
+ *
+ * @param exceptionName The name of the exception for which the Class object is to be retrieved.
+ * @return The Class object associated with the given exception name.
+ * @throws RuntimeException If the Class object for the given exception name is not found in the exceptionMap.
+ */
+private Class<?> getExceptionClass(String exceptionName) {
+    System.out.println(exceptionName);
+    exceptionName = "semantic.exceptions." + exceptionName;
+    System.out.println(exceptionName);
+    Class<?> exceptionClass = exceptionMap.get(exceptionName);
+    if (exceptionClass == null) {
+        throw new RuntimeException("Exception class not found: " + exceptionName);
+    }
+    return exceptionClass;
+}
+
+    /**
+     * This method is used to load custom exceptions from a specified package.
+     * It first constructs the directory path from the package name and checks if the directory exists.
+     * If the directory does not exist, it throws an IllegalArgumentException.
+     * It then creates a URLClassLoader to load the classes from the directory.
+     * It iterates over all the files in the directory, and for each file, it constructs the class name and loads the class.
+     * If the loaded class is a subtype of Throwable, it adds the class to the exceptionMap.
+     *
+     * @throws Exception If any error occurs during class loading.
+     */
+    private static void loadCustomExceptions() throws Exception {
+        final String packName = "semantic.exceptions";
+        final String dirForMyClasses = "src/main/java/%s".formatted(packName.replace(".", "/"));
+        File folder = new File(dirForMyClasses);
+        if (!folder.isDirectory()) {
+            throw new IllegalArgumentException("The provided path is not a directory.");
+        }
+
+        URL[] urls = {folder.toURI().toURL()};
+        URLClassLoader classLoader;
+        try {
+            classLoader = new URLClassLoader(urls);
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to create class loader", e);
+        }
+
+        for (File file : Objects.requireNonNull(folder.listFiles())) {
+            String className = packName + "." + file.getName().replaceAll("\\.(?:class|java)$", "");
+            System.out.printf("Loading custom exception: %s (=> %s)", file.getName(), className);
+            Class<?> cls = classLoader.loadClass(className);
+
+            if (Throwable.class.isAssignableFrom(cls)) { // Check if the class is a subtype of Throwable
+                exceptionMap.put(className, cls);
+                System.out.println("Loaded custom exception: " + className);
+            }
+        }
+    }
+}

src/test/java/semantic/SemanticTest.java

@@ -1,18 +1,5 @@
 package semantic;
 
-import ast.*;
-import ast.members.FieldNode;
-import ast.members.MemberNode;
-import ast.members.MethodNode;
-import ast.parameters.ParameterNode;
-
-import org.junit.jupiter.api.Test;
-import semantic.exeptions.AlreadyDeclearedException;
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.*;
-
 public class SemanticTest {
 
 
@@ -35,7 +22,7 @@ public class SemanticTest {
 //        ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
 //
 //        assertEquals(1, SemanticAnalyzer.errors.size());
-//        assertInstanceOf(AlreadyDeclearedException.class, SemanticAnalyzer.errors.getFirst());
+//        assertInstanceOf(AlreadyDeclaredException.class, SemanticAnalyzer.errors.getFirst());
 //        assertNull(typedAst);
 //    }
 //

src/test/resources/input/AllFeaturesClassExample.java

@@ -1,5 +1,3 @@
-package resources;
-
 public class AllFeaturesClassExample {
     int a;
     boolean b;

src/test/resources/input/CombinedExample.java

@@ -1,5 +1,3 @@
-package resources;
-
 public class CombinedExample {
     int number;
     boolean flag;

src/test/resources/input/MoreFeaturesClassExample.java

@@ -1,5 +1,3 @@
-package resources;
-
 public class MoreFeaturesClassExample {
     int hallo;
     private class Inner {

src/test/resources/input/featureTests/BooleanOperations.java

@@ -1,5 +1,3 @@
-package resources.featureTests;
-
 public class BooleanOperations {
     boolean flag;
 

src/test/resources/input/featureTests/CharManipulation.java

@@ -1,5 +1,3 @@
-package resources.featureTests;
-
 public class CharManipulation {
     char letter;
 

src/test/resources/input/featureTests/ConditionalStatements.java

@@ -1,5 +1,3 @@
-package resources.featureTests;
-
 public class ConditionalStatements {
     int number;
 

src/test/resources/input/featureTests/EmptyClassExample.java

@@ -0,0 +1,2 @@
+public class EmptyClassExample {
+}

src/test/resources/input/featureTests/LoopExamples.java

@@ -1,5 +1,3 @@
-package resources.featureTests;
-
 public class LoopExamples {
     public static void main(String[] args) {
         // For loop example

src/test/resources/input/featureTests/MethodOverloading.java

@@ -1,5 +1,3 @@
-package resources.featureTests;
-
 public class MethodOverloading {
     public int add(int a, int b) {
         return a + b;

src/test/resources/input/typedAstExceptionsTests/FieldAlreadyDeclared.java

@@ -1,3 +1,4 @@
+// @expected: AlreadyDeclaredException
 public class Example {
 
     public int a;

src/test/resources/input/typedAstExceptionsTests/MultipleReturnTypes.java

@@ -1,3 +1,4 @@
+// @expected: MultipleReturnTypes
 public class Example {
 
     public static int testMethod(int x, char c){

src/test/resources/input/typedAstExceptionsTests/NotDeclared.java

@@ -1,3 +1,4 @@
+// @expected: NotDeclaredException
 public class Test {
     public static int testMethod(int x){
         int a = b;

src/test/resources/input/typedAstExceptionsTests/ParameterAlreadyDeclared.java

@@ -1,3 +1,4 @@
+// @expected: AlreadyDeclaredException
 public class Example {
 
     public static int testMethod(char a, int a){

src/test/resources/input/typedAstExceptionsTests/ReturnTypeMismatch.java

@@ -1,3 +1,4 @@
+// @expected: TypeMismatchException
 public class Example {
 
     public static int testMethod(char x){

src/test/resources/input/typedAstExceptionsTests/TypeMismatchIntBool.java

@@ -1,3 +1,4 @@
+// @expected: TypeMismatchException
 public class Test {
 
     public boolean b;

src/test/resources/input/typedAstExceptionsTests/TypeMismatchRefType.java

@@ -1,3 +1,4 @@
+// @expected: TypeMismatchException
 public class Test {
 
     public static int testMethod(ExampleA exampleA, ExampleB exampleB){

src/test/resources/input/typedAstExceptionsTests/WrongIfClause.java

@@ -1,3 +1,4 @@
+// @expected: TypeMismatchException
 public class Example {
 
     public static void testMethod(int x){