Merge branch 'ParserAlterStand' into NewParser

This reverts commit b7affd75ae.

.idea/jarRepositories.xml

@@ -6,6 +6,11 @@
       <option name="name" value="Central Repository" />
       <option name="url" value="https://repo.maven.apache.org/maven2" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven_central" />
+      <option name="name" value="Maven Central" />
+      <option name="url" value="https://repo.maven.apache.org/maven2/" />
+    </remote-repository>
     <remote-repository>
       <option name="id" value="central" />
       <option name="name" value="Maven Central repository" />

.lib/Kurzdokumentation.md

@@ -0,0 +1,58 @@
+# Kurzdokumentation
+
+## Aufgabenverteilung
+
+### Maximilian Stahl und Jannik Rombach:
+- **Scanner**
+- **Parser**
+- **AST**
+- **AstBuilder**
+    - **Modul: ast**
+        - Alle
+    - **Modul: parser**
+        - Alle
+    - **Modul: visitor**
+        - Alle
+    - **Testmodul: parser**
+        - AstBuildertest.java
+        - Helper.java
+    - **Testfiles: singleFeatureTests**
+        - Alle
+
+### Johannes Ehlert:
+- **Semantische Analyse**
+    - **Modul: semantic**
+    - **Modul: typecheck**
+    - **Testmodul: parser**
+        - AstBuildertest.java
+    - **Testfiles: typedAstFeatureTests**
+        - Großteil
+    - **Testfiles: typedAstExceptionsTests**
+        - Großteil
+
+### David Große:
+- **Bytecodegenerator**
+    - **Modul: bytecode**
+        - Alle
+
+### Lucas Janker:
+- **Tests**
+    - **Modul: main**
+        - Alle
+    - **Testmodul: main**
+        - Alle
+    - **Testmodul: parser**
+        - ScannerTest.java
+        - ParserTest.java
+    - **Testmodul: semantic**
+    - **Testfiles: combinedFeatureTests**
+        - Alle
+    - **Testfiles: failureTests**
+        - Alle
+    - **Testfiles: Alle**
+        - Refactoring
+    - **Ordnerstrukturen**
+        - Großteil
+    - **Build**
+    - **Makefile**
+    - **Dokumentation**

pom.xml

@@ -20,7 +20,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.9.3</version> <!-- Change the version as needed -->
+            <version>5.11.0-M2</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -44,6 +44,18 @@
             <version>3.26.0</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.11.0-M2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.11.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -78,4 +90,11 @@
             </plugin>
         </plugins>
     </build>
+    <repositories>
+        <repository>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
+        </repository>
+    </repositories>
 </project>

src/main/java/ast/ASTNode.java

@@ -8,6 +8,7 @@ public interface ASTNode {
 
     //Todo: @BruderJohn & @i22007 Interface anwenden + geeignetetn Methodename.
 
+
     /*
     Typecheck:
     public TypeCheckResult acceptType(SemanticVisitor visitor);

src/main/java/ast/ClassNode.java

@@ -1,7 +1,6 @@
 package ast;
 
 import ast.type.AccessModifierNode;
-import ast.members.ConstructorNode;
 import ast.members.MemberNode;
 import ast.members.MethodNode;
 import bytecode.visitor.ClassVisitor;

src/main/java/ast/statementexpressions/methodcallstatementnexpressions/TargetNode.java

@@ -30,11 +30,6 @@ public class TargetNode implements ASTNode, Visitable {
         this.identifier = identifier;
     }
 
-    @Override
-    public void accept(MethodVisitor methodVisitor) {
-        methodVisitor.visit(this);
-    }
-
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
     }

src/main/java/bytecode/MethodCodeGen.java

@@ -39,12 +39,12 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     private Mapper mapper;
     private MethodVisitor methodVisitor;
 
-    private List<String> localVaribales;
+    private List<String> localVariables;
 
     public MethodCodeGen(ClassWriter classWriter) {
         this.classWriter = classWriter;
         mapper = new Mapper();
-        localVaribales = new ArrayList<>();
+        localVariables = new ArrayList<>();
     }
 
 
@@ -60,10 +60,10 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                         null);
 
         methodVisitor.visitCode();
-        localVaribales.add("this");
+        localVariables.add("this");
         // Add all method parameters to localVariables
         for (ParameterNode parameterNode : constructorNode.parameters) {
-            localVaribales.add(parameterNode.identifier);
+            localVariables.add(parameterNode.identifier);
         }
 
         methodVisitor.visitVarInsn(ALOAD, 0);
@@ -89,8 +89,8 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                 null);
 
         methodVisitor.visitCode();
-        localVaribales.add("this");
+        localVariables.add("this");
-        localVaribales.add("args");
+        localVariables.add("args");
 
         // Visit all statements
         for (IStatementNode statementNode : mainMethodNode.block.statements) {
@@ -110,10 +110,10 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
                 null);
 
         methodVisitor.visitCode();
-        localVaribales.add("this");
+        localVariables.add("this");
         // Add all method parameters to localVariables
         for (ParameterNode parameterNode : methodNode.parameters) {
-            localVaribales.add(parameterNode.identifier);
+            localVariables.add(parameterNode.identifier);
         }
 
         // Visit all statements
@@ -181,7 +181,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (dotSubstractionNode.value != null) {
             dotSubstractionNode.value.accept(this);
         } else if (dotSubstractionNode.identifier != null) {
-            methodVisitor.visitVarInsn(ILOAD, localVaribales.indexOf(dotSubstractionNode.identifier));
+            methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(dotSubstractionNode.identifier));
         } else if (dotSubstractionNode.memberAccess != null) {
             dotSubstractionNode.memberAccess.accept(this);
         } else if (dotSubstractionNode.methodCall != null) {
@@ -195,7 +195,6 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     public void visit(NonCalculationNode nonCalculationNode) {
         Label labelFalse = new Label();
         Label labelTrue = new Label();
-        // TODO: Null check
         switch (nonCalculationNode.operator) {
             case AND:
                 nonCalculationNode.unaryExpression.accept(this);
@@ -266,8 +265,10 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(MemberAccessNode memberAccessNode) {
-        if (memberAccessNode.thisExpr) {
+        // Only used to get, not to put
-            // methodVisitor.visitFieldInsn(PUTFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), );
+        if (memberAccessNode.thisExpr) { // Field
+            // methodVisitor.visitFieldInsn(GETFIELD, memberAccessNode.identifiers.get(0), memberAccessNode.identifiers.get(1), );
+        } else { // Object Attribut
         }
     }
 
@@ -296,7 +297,7 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (unaryNode.thisExp != null) {
             methodVisitor.visitVarInsn(ALOAD, 0); // this
         } else if (unaryNode.identifier != null) {
-            methodVisitor.visitVarInsn(ILOAD, localVaribales.indexOf(unaryNode.identifier));
+            methodVisitor.visitVarInsn(ILOAD, localVariables.indexOf(unaryNode.identifier));
         } else if (unaryNode.memberAccess != null) {
             unaryNode.memberAccess.accept(this);
         } else if (unaryNode.value != null) {
@@ -362,23 +363,23 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
             // Process expression
             localVariableDeclarationNode.expression.accept(this);
             // Store result of expression in variable
-            if (localVaribales.contains(localVariableDeclarationNode.identifier)) {
+            if (localVariables.contains(localVariableDeclarationNode.identifier)) {
                 if (localVariableDeclarationNode.type instanceof BaseType) {
-                    methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
+                    methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
                 } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
-                    methodVisitor.visitVarInsn(ASTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
+                    methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
                 }
             } else {
-                localVaribales.add(localVariableDeclarationNode.identifier);
+                localVariables.add(localVariableDeclarationNode.identifier);
                 if (localVariableDeclarationNode.type instanceof BaseType) {
-                    methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
+                    methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
                 } else if (localVariableDeclarationNode.type instanceof ReferenceType) {
-                    methodVisitor.visitVarInsn(ASTORE, localVaribales.indexOf(localVariableDeclarationNode.identifier));
+                    methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(localVariableDeclarationNode.identifier));
                 }
             }
         } else {
-            if (!localVaribales.contains(localVariableDeclarationNode.identifier)) {
+            if (!localVariables.contains(localVariableDeclarationNode.identifier)) {
-                localVaribales.add(localVariableDeclarationNode.identifier);
+                localVariables.add(localVariableDeclarationNode.identifier);
             }
         }
     }
@@ -389,43 +390,49 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         if (assignNode.expression instanceof IncrementNode) {
             IncrementNode incrementNode = (IncrementNode) assignNode.expression;
             if (incrementNode.crementType.equals(CrementType.PREFIX)) { // ++i
-                methodVisitor.visitIincInsn(localVaribales.indexOf(incrementNode.assignableExpression.identifier), 1);
+                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
                 assign(assignNode);
             } else if (incrementNode.crementType.equals(CrementType.SUFFIX)) { // Suffix: i++
                 assign(assignNode);
-                methodVisitor.visitIincInsn(localVaribales.indexOf(incrementNode.assignableExpression.identifier), 1);
+                methodVisitor.visitIincInsn(localVariables.indexOf(incrementNode.assignableExpression.identifier), 1);
             }
         } else if (assignNode.expression instanceof DecrementNode) {
             DecrementNode decrementNode = (DecrementNode) assignNode.expression;
             if (decrementNode.crementType.equals(CrementType.PREFIX)) {
-                methodVisitor.visitIincInsn(localVaribales.indexOf(decrementNode.assignableExpression.identifier), -1);
+                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), -1);
                 assign(assignNode);
             } else if (decrementNode.crementType.equals(CrementType.SUFFIX)) {
                 assign(assignNode);
-                methodVisitor.visitIincInsn(localVaribales.indexOf(decrementNode.assignableExpression.identifier), 1);
+                methodVisitor.visitIincInsn(localVariables.indexOf(decrementNode.assignableExpression.identifier), 1);
             }
         } else {
             assignNode.expression.accept(this);
+            assign(assignNode);
         }
     }
 
     private void assign(AssignNode assignNode) {
-        // Store result of expression in variable
         if (assignNode.assignable.memberAccess.thisExpr) {
-            // Global var
+            assignField(assignNode);
-            methodVisitor.visitVarInsn(ALOAD, 0);
-            if (assignNode.expression instanceof BaseType) {
-                //methodVisitor.visitFieldInsn(PUTFIELD, class name, var identifier, mapper.getTypeChar(((BaseTypeNode) type).enumType));
-            } else if (assignNode.expression instanceof ReferenceType) {
-                //methodVisitor.visitFieldInsn(PUTFIELD, class name, var identifier, "L"class name object +";");
-            }
         } else {
-            // Local var
+            assignLocalVar(assignNode);
-            if (assignNode.expression instanceof BaseType) {
+        }
-                methodVisitor.visitVarInsn(ISTORE, localVaribales.indexOf(assignNode.assignable.identifier));
+    }
-            } else if (assignNode.expression instanceof ReferenceType) {
+
-                methodVisitor.visitVarInsn(ASTORE, localVaribales.indexOf(assignNode.assignable.identifier));
+    private void assignLocalVar(AssignNode assignNode) {
-            }
+        if (assignNode.expression instanceof BaseType) {
+            methodVisitor.visitVarInsn(ISTORE, localVariables.indexOf(assignNode.assignable.identifier));
+        } else if (assignNode.expression instanceof ReferenceType) {
+            methodVisitor.visitVarInsn(ASTORE, localVariables.indexOf(assignNode.assignable.identifier));
+        }
+    }
+
+    private void assignField(AssignNode assignNode) {
+        if (assignNode.expression instanceof BaseType) {
+            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), mapper.getTypeChar((BaseType) assignNode.expression.getType()));
+        } else if (assignNode.expression instanceof ReferenceType) {
+            ReferenceType referenceType = (ReferenceType) assignNode.expression.getType();
+            methodVisitor.visitFieldInsn(PUTFIELD, assignNode.assignable.memberAccess.identifiers.get(0), assignNode.assignable.memberAccess.identifiers.get(1), "L"+referenceType.getIdentifier()+";");
         }
     }
 
@@ -433,13 +440,13 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
     public void visit(NewDeclarationNode newDeclarationNode) {
         methodVisitor.visitTypeInsn(NEW, newDeclarationNode.identifier);
         methodVisitor.visitInsn(DUP);
+        List<ParameterNode> parameterNodes = new ArrayList<>();
         for (IExpressionNode expressionNode : newDeclarationNode.expressions) {
             expressionNode.accept(this);
+            parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
         }
-        // TODO
+        methodVisitor.visitMethodInsn(INVOKESPECIAL, newDeclarationNode.identifier, "<init>", mapper.generateMethodDescriptor(new BaseType(TypeEnum.VOID),parameterNodes), false);
-        //methodVisitor.visitMethodInsn(INVOKESPECIAL, class name, "<init>", mapper.generateMethodDescriptor(), false);
+        localVariables.add(newDeclarationNode.identifier);
-        // TODO: kann ein Field auch definiert werden? Abfrage ob local var oder field
-        localVaribales.add(newDeclarationNode.identifier);
     }
 
     @Override
@@ -505,13 +512,6 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
         whileNode.expression.accept(this);
         methodVisitor.visitJumpInsn(IFEQ, endOfLoopLabel); // if condition is false, jump out of loop
 
-        // TODO: Unterscheidung bei increment/decrement der for Schleife
-        if (whileNode.block.statements.size() == 2) { // For loop
-            whileNode.block.statements.get(0).accept(this);
-
-        } else {
-            whileNode.block.statements.get(0).accept(this);
-        }
         whileNode.block.accept(this);
         methodVisitor.visitJumpInsn(GOTO, loopLabel);
 
@@ -520,16 +520,17 @@ public class MethodCodeGen implements bytecode.visitor.MethodVisitor {
 
     @Override
     public void visit(ChainedMethodNode chainedMethodNode) {
-
+        // TODO: Erstmal abwarten
     }
 
     @Override
     public void visit(MethodCallNode methodCallNode) {
-
+        List<ParameterNode> parameterNodes = new ArrayList<>();
-    }
+        for(IExpressionNode expressionNode : methodCallNode.parameters) {
-
+            expressionNode.accept(this);
-    @Override
+            parameterNodes.add(new ParameterNode(expressionNode.getType(), ""));
-    public void visit(TargetNode targetNode) {
+        }
-
+        // TODO: Klassenname und Returntype
+        //methodVisitor.visitMethodInsn(INVOKEVIRTUAL, classname, methodCallNode.identifier, mapper.generateMethodDescriptor(returntype, parameterNodes), false);
     }
 }

src/main/java/bytecode/visitor/MethodVisitor.java

@@ -46,7 +46,6 @@ public interface MethodVisitor {
     // statement expression
     void visit(ChainedMethodNode chainedMethodNode);
     void visit(MethodCallNode methodCallNode);
-    void visit(TargetNode targetNode);
 
     void visit(AssignNode assignNode);
     void visit(NewDeclarationNode newDeclarationNode);

src/main/java/main/Main.java

@@ -13,6 +13,7 @@ import org.antlr.v4.runtime.tree.ParseTree;
 
 import java.io.IOException;
 import java.nio.file.Paths;
+import java.util.Optional;
 
 
 /**
@@ -20,9 +21,9 @@ 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-jar-with-dependencies.jar 'path_to_input_file.java' 'path_to_output_directory' </code>
+ * <p> <code> java.exe -DgenJar=true_OR_false -DgenClass=true_OR_false -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-jar-with-dependencies.jar 'src/main/resources/input/CompilerInput.java' 'src/main/resources/output' </code>
+ * <code> java.exe -DgenJar=true -DgenClass=true -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 {
@@ -97,7 +98,11 @@ public class Main {
 
         /*------------------------- Bytecode Generator -> Bytecode -------------------------*/
         // Use the ByteCodeGenerator to generate bytecode from the typed AST and output it to the specified directory
-        ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator(outputDirectoryPath);
+
+        final boolean genJar = Optional.ofNullable(System.getProperty("genJar")).map(String::toLowerCase).map(Boolean::parseBoolean).orElse(true);
+        final boolean genClass = Optional.ofNullable(System.getProperty("genClass")).map(String::toLowerCase).map(Boolean::parseBoolean).orElse(true);
+
+        ByteCodeGenerator byteCodeGenerator = new ByteCodeGenerator(outputDirectoryPath, genJar, genClass);
         assert typedAst != null;
         byteCodeGenerator.visit((ProgramNode) typedAst);
         // Log the bytecode generation

src/test/Makefile

@@ -9,7 +9,7 @@ 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' "
+	cd ../.. ; mvn exec:java -DgenJar=true -DgenClass=true -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: compile-javac compile-raupenpiler test-javac test-raupenpiler
@@ -31,12 +31,15 @@ test-raupenpiler:
 clean:
 	# clean output folders
 	rm -f ../main/resources/output/*.class
+	rm -f ../main/resources/output/*.jar
 	rm -f ./resources/output/javac/*.class
 	rm -f ./resources/output/raupenpiler/*.class
 	# clean logs
 	rm -f ../main/resources/logs/*.log
 	# clean test/java/main folders from .class files for End-to-End tests
 	rm -f ./java/main/*.class
-	# clean javac output from featureTests
+	# clean javac output from combinedFeatureTests
-	rm -f ./resources/input/featureTests/*.class
+	rm -f ./resources/input/combinedFeatureTests/*.class
+	rm -f ./resources/input/singleFeatureTests/*.class
+	rm -f ./resources/input/typedAstFeatureTests/*.class
 

src/test/java/main/E2EReflectionsTest.java

@@ -0,0 +1,95 @@
+package main;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Test;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class E2EReflectionsTest {
+    @Test
+    public void AllFeaturesClassExampleTest(){
+        try {
+            Main.main(new String[]{"src/test/resources/input/combinedFeatureTests/AllFeaturesClassExample.java", "src/test/resources/output/raupenpiler"});
+            // Get the system Java compiler
+            JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+            // Assert that the compiler is available
+            assertNotNull(javac, "Java Compiler is not available");
+            javac.run(null, null, null, "src/test/resources/input/combinedFeatureTests/AllFeaturesClassExample.java");
+
+            Class<?> clazz = Class.forName("src.resources.input.combinedFeatureTests.AllFeaturesClassExample");
+            ClassLoader classLoader = getClass().getClassLoader();
+           // Class<?> clazz = classLoader.loadClass("main.AllFeaturesClassExample");
+
+            // Class Name
+            assertEquals("main.AllFeaturesClassExample", clazz.getName());
+
+            // Constructors
+            Constructor<?>[] actualConstructors = clazz.getDeclaredConstructors();
+            assertTrue(actualConstructors.length > 0, "No constructors found");
+
+            Constructor<?> expectedConstructor = clazz.getConstructor(int.class, boolean.class, char.class);
+
+            boolean constructorFound = false;
+            for (Constructor<?> constructor : actualConstructors) {
+                if (constructor.equals(expectedConstructor)) {
+                    constructorFound = true;
+                    break;
+                }
+            }
+            assertTrue(constructorFound, "Expected constructor not found in actual constructors");
+
+            // Methods
+            Method[] actualMethodNames = clazz.getDeclaredMethods();
+            assertTrue(actualMethodNames.length > 0);
+            for (Method method : actualMethodNames) {
+                System.out.println("Method: " + method.getName());
+            }
+
+            // Method Names
+            String[] expectedMethodNames = {
+                "controlStructures",
+                "logicalOperations",
+                "add",
+                "subtract",
+                "multiply",
+                "divide",
+                "modulo",
+                "main"
+            };
+
+            for (Method method : actualMethodNames) {
+                assertTrue(Arrays.asList(expectedMethodNames).contains(method.getName()));
+            }
+
+            // Fields
+            Field[] actualFields = clazz.getDeclaredFields();
+            assertTrue(actualFields.length > 0, "No fields found");
+
+            Field expectedField = clazz.getDeclaredField("c");
+            assertEquals(expectedField.getType(), char.class);
+
+            boolean fieldFound = false;
+            for (Field field : actualFields) {
+                if (field.equals(expectedField)) {
+                    fieldFound = true;
+                    break;
+                }
+            }
+            assertTrue(fieldFound, "Expected field not found in actual fields");
+
+
+
+        } catch (ClassNotFoundException | NoSuchFieldException | NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/test/java/main/FailureTest.java

@@ -1,48 +0,0 @@
-package main;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import org.junit.jupiter.api.Test;
-
-import javax.tools.JavaCompiler;
-import javax.tools.ToolProvider;
-import java.io.File;
-
-public class FailureTest {
-    /**
-     * 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 areTestFilesActuallyFailTest() {
-        // 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/failureTests";
-        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 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

@@ -1,46 +0,0 @@
-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/InputFilesTest.java

@@ -0,0 +1,104 @@
+package main;
+
+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.Files;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class InputFilesTest {
+
+    /**
+     * 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() throws IOException {
+        // Get the system Java compiler
+        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+        // Assert that the compiler is available
+        assertNotNull(javac, "Java Compiler is not available");
+
+        File folder1 = new File("src/test/resources/input/combinedFeatureTests");
+        File folder2 = new File("src/test/resources/input/singleFeatureTests");
+        File folder3 = new File("src/test/resources/input/typedAstFeatureTests");
+
+        List<File> files = getJavaFilesFromDirectory(folder1);
+        files.addAll(getJavaFilesFromDirectory(folder2));
+        files.addAll(getJavaFilesFromDirectory(folder3));
+
+        if (!files.isEmpty()) {
+            for (File file : files) {
+                // Try to compile the file and get the result
+                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 directories.");
+        }
+    }
+
+
+    /**
+     * 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 areTestFilesActuallyFails() throws IOException {
+        // Get the system Java compiler
+        JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+        // Assert that the compiler is available
+        assertNotNull(javac, "Java Compiler is not available");
+
+
+        File folder1 = new File("src/test/resources/input/failureTests");
+        File folder2 = new File("src/test/resources/input/typedAstExceptionsTest");
+
+        List<File> files = getJavaFilesFromDirectory(folder1);
+        files.addAll(getJavaFilesFromDirectory(folder2));
+
+
+        if (!files.isEmpty()) {
+            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 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.");
+        }
+
+    }
+
+    /**
+     * Helper method to get all .java files from a directory.
+     *
+     * @param directory the directory to search for .java files
+     * @return a list of .java files
+     * @throws IOException if an I/O error occurs
+     */
+    private List<File> getJavaFilesFromDirectory(File directory) throws IOException {
+        if (directory.isDirectory()) {
+            return Files.list(directory.toPath())
+                    .filter(path -> path.toString().endsWith(".java"))
+                    .map(java.nio.file.Path::toFile)
+                    .collect(Collectors.toList());
+        } else {
+            System.out.println("The provided path is not a directory: " + directory.getPath());
+            return List.of();
+        }
+    }
+}

src/test/java/main/MainTest.java

@@ -12,16 +12,11 @@ import java.nio.file.Paths;
  * run every test: mvn test
  * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
  */
+@Deprecated
 public class MainTest {
     @Test
     void test() {
-        CharStream codeCharStream = null;
+        System.out.println("MainTest");
-        try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/CompilerInput.java"));
-            Main.compileFile(codeCharStream, "src/main/test/resources/output");
-        } catch (IOException e) {
-            System.err.println("Error reading the file: " + e.getMessage());
-        }
     }
 }
 

src/test/java/main/ReflectionsTest.java

@@ -0,0 +1,145 @@
+package main;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+
+import org.antlr.v4.runtime.CharStream;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@Deprecated
+public class ReflectionsTest {
+
+    @Test
+    public void testSimpleJavaLexerClass() throws ClassNotFoundException, NoSuchMethodException {
+        Class<?> clazz = Class.forName("parser.generated.SimpleJavaLexer");
+
+        // Class Name
+        assertEquals("parser.generated.SimpleJavaLexer", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] actualConstructors = clazz.getDeclaredConstructors();
+        assertTrue(actualConstructors.length > 0, "No constructors found");
+
+        Constructor<?> expectedConstructor = clazz.getConstructor(CharStream.class);
+
+        boolean constructorFound = false;
+        for (Constructor<?> constructor : actualConstructors) {
+            if (constructor.equals(expectedConstructor)) {
+                constructorFound = true;
+                break;
+            }
+        }
+        assertTrue(constructorFound, "Expected constructor not found in actual constructors");
+
+
+
+        // Methods
+        Method[] actualMethodNames = clazz.getDeclaredMethods();
+        assertTrue(actualMethodNames.length > 0);
+        Arrays.stream(actualMethodNames).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        List<String> expectedMethodNames = Arrays.asList(
+                "getTokenNames",
+                "getVocabulary",
+                "getGrammarFileName",
+                "getRuleNames",
+                "getSerializedATN",
+                "getChannelNames",
+                "getModeNames",
+                "getATN",
+                "makeRuleNames",
+                "makeLiteralNames",
+                "makeSymbolicNames"
+        );
+
+        for (Method method : actualMethodNames) {
+            assertTrue(expectedMethodNames.contains(method.getName()));
+        }
+
+        for (String expectedMethodName : expectedMethodNames) {
+            boolean methodFound = false;
+            for (Method method : actualMethodNames) {
+                if (method.getName().equals(expectedMethodName)) {
+                    methodFound = true;
+                    break;
+                }
+            }
+            assertTrue(methodFound, "Expected method " + expectedMethodName + " not found in actual methods");
+        }
+
+
+        // Fields
+        Field[] actualFieldNames = clazz.getDeclaredFields();
+        assertTrue(actualFieldNames.length > 0);
+        Arrays.stream(actualFieldNames).forEach(field -> System.out.println("Field: " + field.getName()));
+
+        List<String> expectedFieldNames = Arrays.asList(
+                "_decisionToDFA",
+                "_sharedContextCache",
+                "channelNames",
+                "modeNames",
+                "ruleNames",
+                "_LITERAL_NAMES",
+                "_SYMBOLIC_NAMES",
+                "VOCABULARY",
+                "tokenNames",
+                "_serializedATN",
+                "_ATN"
+        );
+
+        for (Field field : actualFieldNames) {
+            assertTrue(expectedFieldNames.contains(field.getName()));
+        }
+    }
+
+    @Test
+    public void testSimpleJavaParserClass() throws ClassNotFoundException {
+        Class<?> clazz = Class.forName("parser.generated.SimpleJavaParser");
+
+        // Class Name
+        assertEquals("parser.generated.SimpleJavaParser", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+        assertTrue(constructors.length > 0);
+
+        // Methods
+        Method[] methods = clazz.getDeclaredMethods();
+        assertTrue(methods.length > 0);
+        Arrays.stream(methods).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        // Fields
+        Field[] fields = clazz.getDeclaredFields();
+        assertTrue(fields.length > 0);
+        Arrays.stream(fields).forEach(field -> System.out.println("Field: " + field.getName()));
+    }
+
+    @Test
+    public void testASTBuilderClass() throws ClassNotFoundException {
+        Class<?> clazz = Class.forName("parser.astBuilder.ASTBuilder");
+
+        // Class Name
+        assertEquals("parser.astBuilder.ASTBuilder", clazz.getName());
+
+        // Constructors
+        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
+        assertTrue(constructors.length > 0);
+
+        // Methods
+        Method[] methods = clazz.getDeclaredMethods();
+        assertTrue(methods.length > 0);
+        Arrays.stream(methods).forEach(method -> System.out.println("Method: " + method.getName()));
+
+        // Fields
+        Field[] fields = clazz.getDeclaredFields();
+        assertTrue(fields.length > 0);
+        Arrays.stream(fields).forEach(field -> System.out.println("Field: " + field.getName()));
+    }
+
+    // Similarly, you can add tests for SemanticAnalyzer and ByteCodeGenerator
+}

src/test/java/parser/AstBuilderTest.java

@@ -9,138 +9,126 @@ import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.expressions.unaryexpressions.UnaryNode;
 import ast.members.ConstructorNode;
 import ast.members.FieldNode;
-import ast.members.MemberNode;
 import ast.members.MethodNode;
 import ast.parameters.ParameterNode;
 import ast.statementexpressions.AssignNode;
 import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
 import ast.statements.BlockNode;
-import ast.statements.IStatementNode;
 import ast.statements.ReturnNode;
 import ast.type.AccessModifierNode;
 import ast.type.EnumValueNode;
 import ast.type.ValueNode;
 import ast.type.type.BaseType;
-import ast.type.type.ITypeNode;
 import ast.type.type.TypeEnum;
-import com.fasterxml.jackson.annotation.JsonFormat;
-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.DisplayName;
 import org.junit.jupiter.api.Test;
-import parser.astBuilder.ASTBuilder;
-import parser.generated.SimpleJavaLexer;
-import parser.generated.SimpleJavaParser;
-
-import java.io.IOException;
-import java.lang.reflect.Member;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 @DisplayName("Untyped Abstract Syntax Tree")
 class AstBuilderTest {
 
+    private final static String directoryPath = "src/test/resources/input/singleFeatureTests/";
+
     @Test
     @DisplayName("Empty Class Test")
-    public void emptyClassTest(){
+    public void emptyClassTest() {
-        ClassNode emptyClass = Helper.generateEmptyClass("TestClass");
+        ClassNode emptyClass = Helper.generateEmptyClass("EmptyClass");
         ProgramNode expected = new ProgramNode();
         expected.addClass(emptyClass);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/EmptyClass.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "EmptyClass.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Multiple Empty Classes Test")
     public void multipleEmptyClassesTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass1");
+        ClassNode class1 = Helper.generateEmptyClass("MultipleClasses");
         ClassNode class2 = Helper.generateEmptyClass("TestClass2");
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
         expected.addClass(class2);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/MultipleClasses.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "MultipleClasses.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Empty Class Test with Constructor")
     public void emptyClassWithConstructorTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("EmptyClassWithConstructor");
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/EmptyClassWithConstructor.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "EmptyClassWithConstructor.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Field Test")
     public void fieldTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("Field");
-        class1.addMember(new FieldNode(null, new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Field.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Field.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Field Test with Accessmodifier")
     public void fieldTestWithModifier() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("FieldWithAccessModifier");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/FieldWithAccessModifier.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "FieldWithAccessModifier.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
-    @DisplayName("Commments Ignore Test")
+    @DisplayName("Comments Ignore Test")
-    public void commmentsIgnoreTest(){
+    public void commentsIgnoreTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("Comments");
         class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a"));
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Comments.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Comments.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
-    @DisplayName("Constructor Paramerter Test")
+    @DisplayName("Constructor Parameter Test")
-    public void constructorParameterTest(){
+    public void constructorParameterTest() {
         BlockNode block = new BlockNode();
         block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", block);
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorParameter", block);
         constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
         constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ConstructorParameter");
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorParameter.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ConstructorParameter.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("This Dot Test")
-    public void thisDotTest(){
+    public void thisDotTest() {
         BlockNode block = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -152,23 +140,23 @@ class AstBuilderTest {
 
         block.addStatement(new AssignNode(assignable, expression));
         block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", block);
+        ConstructorNode constructor = new ConstructorNode("public", "ThisDot", block);
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ThisDot");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ThisDot.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ThisDot.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Constructor This Dot Test")
-    public void constructorThisDotTest(){
+    public void constructorThisDotTest() {
         BlockNode block = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -179,25 +167,25 @@ class AstBuilderTest {
 
         block.addStatement(new AssignNode(assignable, expression));
         block.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", block);
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorThisDot", block);
         constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ConstructorThisDot");
         class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorThisDot.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ConstructorThisDot.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Void Methoden Test")
-    public void voidMethodenTest(){
+    public void voidMethodenTest() {
-        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ClassNode class1 = Helper.generateEmptyClass("VoidMethod");
         BlockNode block = new BlockNode();
         block.addStatement(new ReturnNode(null));
         class1.addMember(new MethodNode("public", null, true, "test", block));
@@ -205,14 +193,14 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/VoidMethod.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "VoidMethod.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Constructor Method call Test")
-    public void constructorMethodCallTest(){
+    public void constructorMethodCallTest() {
         BlockNode blockCon = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -223,13 +211,13 @@ class AstBuilderTest {
 
         blockCon.addStatement(new AssignNode(assignable, expression));
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCall", blockCon);
 
         BlockNode blockMethod = new BlockNode();
         blockMethod.addStatement(new ReturnNode(new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))));
         MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod);
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ConstructorMethodCall");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
         class1.addMember(method);
@@ -237,14 +225,14 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorMethodCall.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ConstructorMethodCall.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Constructor Method call Parameters Test")
-    public void constructorMethodCallParametersTest(){
+    public void constructorMethodCallParametersTest() {
         BlockNode blockCon = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -257,7 +245,7 @@ class AstBuilderTest {
 
         blockCon.addStatement(new AssignNode(assignable, expression));
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCallParameters", blockCon);
         constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
 
         BlockNode blockMethod = new BlockNode();
@@ -265,7 +253,7 @@ class AstBuilderTest {
         MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod);
         method.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "ConstructorMethodCallParameters");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
         class1.addMember(method);
@@ -273,14 +261,14 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorMethodCallParameters.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "ConstructorMethodCallParameters.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Char Test")
-    public void charTest(){
+    public void charTest() {
         BlockNode blockCon = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -293,7 +281,7 @@ class AstBuilderTest {
 
         blockCon.addStatement(new AssignNode(assignable, expression));
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "Char", blockCon);
         constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a"));
 
         BlockNode blockMethod = new BlockNode();
@@ -301,7 +289,7 @@ class AstBuilderTest {
         MethodNode method = new MethodNode("public", new BaseType(TypeEnum.CHAR), false, "testMethod", blockMethod);
         method.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a"));
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "Char");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.CHAR), "a"));
         class1.addMember(constructor);
         class1.addMember(method);
@@ -309,14 +297,14 @@ class AstBuilderTest {
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Char.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Char.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Null Test")
-    public void nullTest(){
+    public void nullTest() {
         BlockNode blockCon = new BlockNode();
         MemberAccessNode memberAccess = new MemberAccessNode(true);
         memberAccess.addIdentifier("a");
@@ -325,65 +313,65 @@ class AstBuilderTest {
 
         blockCon.addStatement(new AssignNode(assignable, new UnaryNode(new ValueNode(EnumValueNode.NULL_VALUE, "null"))));
         blockCon.addStatement(new ReturnNode(null));
-        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+        ConstructorNode constructor = new ConstructorNode("public", "Null", blockCon);
 
-        ClassNode class1 = new ClassNode("public", "TestClass");
+        ClassNode class1 = new ClassNode("public", "Null");
         class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
         class1.addMember(constructor);
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Null.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Null.java");
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Self Reference Test")
-    public void selfReferneceTest(){
+    public void selfReferenceTest() {
 
         //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Variable Compare Test")
-    public void variableCompareTest(){
+    public void variableCompareTest() {
 
         //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Variable Calculation Test")
-    public void variableCalculationTest(){
+    public void variableCalculationTest() {
 
         //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Main Method Test")
-    public void mainMethodTest(){
+    public void mainMethodTest() {
 
         //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("While Test")
-    public void whileTest(){
+    public void whileTest() {
 
         //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Do While Test")
-    public void doWhileTest(){
+    public void doWhileTest() {
 
         //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("For Test")
-    public void forTest(){
+    public void forTest() {
 
         //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
@@ -391,26 +379,16 @@ class AstBuilderTest {
     //Noch nicht speziell Increment nur zum Development Testen per Debug
     @Test
     @DisplayName("Increment Test")
-    public void incrementTest(){
+    public void incrementTest() {
-        ClassNode classNode = Helper.generateEmptyClass("TestClass");
+        ClassNode classNode = Helper.generateEmptyClass("Increment");
         classNode.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(classNode);
 
-        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Increment.java");
+        ASTNode actual = Helper.generateAST(directoryPath + "Increment.java");
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
 
-
-
-
-
-
-
-
-
-
-
 }

src/test/java/semantic/BeginnToTAST.java

@@ -0,0 +1,45 @@
+package semantic;
+
+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 java.io.IOException;
+import java.nio.file.Paths;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class BeginnToTAST {
+
+    @Test
+    public void FieldTests() {
+        SemanticAnalyzer.clearAnalyzer();
+
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/johnsTests/FieldTests.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);
+
+        var result = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+    }
+
+}

src/test/java/semantic/EndToTypedAstTest.java

@@ -38,17 +38,14 @@ public class EndToTypedAstTest {
 
         CharStream codeCharStream = null;
         try {
-            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/typedAstFeaturesTests/CorrectTest.java"));
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/typedAstFeatureTests/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
+        ParseTree parseTree = parser.program();
-
-        /* ------------------------- AST builder -> AST ------------------------- */
         ASTBuilder astBuilder = new ASTBuilder();
         ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
 
@@ -115,7 +112,7 @@ public class EndToTypedAstTest {
 
     @Test
     public void featureTest() {
-        String directoryPath = "src/test/resources/input/typedAstFeaturesTests";
+        String directoryPath = "src/test/resources/input/typedAstFeatureTests";
         File folder = new File(directoryPath);
         if (folder.isDirectory()) {
             File[] files = folder.listFiles((_, name) -> name.endsWith(".java"));

src/test/java/semantic/SemanticTest.java

@@ -1,113 +1,443 @@
 package semantic;
 
+import ast.ASTNode;
+import ast.ClassNode;
+import ast.ProgramNode;
+import ast.expressions.IExpressionNode;
+import ast.expressions.unaryexpressions.MemberAccessNode;
+import ast.expressions.unaryexpressions.UnaryNode;
+import ast.members.ConstructorNode;
+import ast.members.FieldNode;
+import ast.members.MethodNode;
+import ast.parameters.ParameterNode;
+import ast.statementexpressions.AssignNode;
+import ast.statementexpressions.AssignableNode;
+import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
+import ast.statements.BlockNode;
+import ast.statements.ReturnNode;
+import ast.type.AccessModifierNode;
+import ast.type.EnumValueNode;
+import ast.type.ValueNode;
+import ast.type.type.BaseType;
+import ast.type.type.TypeEnum;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import parser.Helper;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class SemanticTest {
 
+    private final static String directoryPath = "src/test/resources/input/singleFeatureTests/";
 
-    public void test(){
+    @BeforeEach
+    public void setUp() {
+        SemanticAnalyzer.clearAnalyzer();
+    }
+
+    @Test
+    @DisplayName("Empty Class Test")
+    public void emptyClassTest() {
+        ClassNode emptyClass = Helper.generateEmptyClass("EmptyClass");
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(emptyClass);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+
+    @Test
+    @DisplayName("Multiple Empty Classes Test")
+    public void multipleEmptyClassesTest() {
+        ClassNode class1 = Helper.generateEmptyClass("MultipleClasses");
+        ClassNode class2 = Helper.generateEmptyClass("TestClass2");
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+        abstractSyntaxTree.addClass(class2);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+
+    @Test
+    @DisplayName("Empty Class Test with Constructor")
+    public void emptyClassWithConstructorTest() {
+        ClassNode class1 = Helper.generateEmptyClass("EmptyClassWithConstructor");
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Field Test")
+    public void fieldTest() {
+        ClassNode class1 = Helper.generateEmptyClass("Field");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Field Test with Accessmodifier")
+    public void fieldTestWithModifier() {
+        ClassNode class1 = Helper.generateEmptyClass("FieldWithAccessModifier");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Comments Ignore Test")
+    public void commentsIgnoreTest() {
+        ClassNode class1 = Helper.generateEmptyClass("Comments");
+        class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a"));
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Constructor Parameter Test")
+    public void constructorParameterTest() {
+        BlockNode block = new BlockNode();
+        block.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorParameter", block);
+        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        ClassNode class1 = new ClassNode("public", "ConstructorParameter");
+        class1.addMember(constructor);
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("This Dot Test")
+    public void thisDotTest() {
+        BlockNode block = new BlockNode();
+        MemberAccessNode memberAccess = new MemberAccessNode(true);
+        memberAccess.addIdentifier("a");
+
+        AssignableNode assignable = new AssignableNode(memberAccess);
+
+        ValueNode value = new ValueNode(EnumValueNode.INT_VALUE, "1");
+        IExpressionNode expression = new UnaryNode(value);
+
+        block.addStatement(new AssignNode(assignable, expression));
+        block.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "ThisDot", block);
+
+        ClassNode class1 = new ClassNode("public", "ThisDot");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(constructor);
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Constructor This Dot Test")
+    public void constructorThisDotTest() {
+        BlockNode block = new BlockNode();
+        MemberAccessNode memberAccess = new MemberAccessNode(true);
+        memberAccess.addIdentifier("a");
+
+        AssignableNode assignable = new AssignableNode(memberAccess);
+
+        IExpressionNode expression = new UnaryNode("a");
+
+        block.addStatement(new AssignNode(assignable, expression));
+        block.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorThisDot", block);
+        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+
+        ClassNode class1 = new ClassNode("public", "ConstructorThisDot");
+        class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(constructor);
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Void Methoden Test")
+    public void voidMethodenTest() {
+        ClassNode class1 = Helper.generateEmptyClass("VoidMethod");
+        BlockNode block = new BlockNode();
+        block.addStatement(new ReturnNode(null));
+        class1.addMember(new MethodNode("public", null, true, "test", block));
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Constructor Method call Test")
+    public void constructorMethodCallTest() {
+        BlockNode blockCon = new BlockNode();
+        MemberAccessNode memberAccess = new MemberAccessNode(true);
+        memberAccess.addIdentifier("a");
+
+        AssignableNode assignable = new AssignableNode(memberAccess);
+
+        IExpressionNode expression = new UnaryNode(new MethodCallNode(null, "testMethod"));
+
+        blockCon.addStatement(new AssignNode(assignable, expression));
+        blockCon.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCall", blockCon);
+
+        BlockNode blockMethod = new BlockNode();
+        blockMethod.addStatement(new ReturnNode(new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))));
+        MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod);
+
+        ClassNode class1 = new ClassNode("public", "ConstructorMethodCall");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(constructor);
+        class1.addMember(method);
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Constructor Method call Parameters Test")
+    public void constructorMethodCallParametersTest() {
+        BlockNode blockCon = new BlockNode();
+        MemberAccessNode memberAccess = new MemberAccessNode(true);
+        memberAccess.addIdentifier("a");
+
+        AssignableNode assignable = new AssignableNode(memberAccess);
+
+        MethodCallNode methodCall = new MethodCallNode(null, "testMethod");
+        methodCall.addExpression(new UnaryNode("a"));
+        IExpressionNode expression = new UnaryNode(methodCall);
+
+        blockCon.addStatement(new AssignNode(assignable, expression));
+        blockCon.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCallParameters", blockCon);
+        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+
+        BlockNode blockMethod = new BlockNode();
+        blockMethod.addStatement(new ReturnNode(new UnaryNode("a")));
+        MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod);
+        method.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+
+        ClassNode class1 = new ClassNode("public", "ConstructorMethodCallParameters");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(constructor);
+        class1.addMember(method);
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Char Test")
+    public void charTest() {
+        BlockNode blockCon = new BlockNode();
+        MemberAccessNode memberAccess = new MemberAccessNode(true);
+        memberAccess.addIdentifier("a");
+
+        AssignableNode assignable = new AssignableNode(memberAccess);
+
+        MethodCallNode methodCall = new MethodCallNode(null, "testMethod");
+        methodCall.addExpression(new UnaryNode("a"));
+        IExpressionNode expression = new UnaryNode(methodCall);
+
+        blockCon.addStatement(new AssignNode(assignable, expression));
+        blockCon.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "Char", blockCon);
+        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a"));
+
+        BlockNode blockMethod = new BlockNode();
+        blockMethod.addStatement(new ReturnNode(new UnaryNode("a")));
+        MethodNode method = new MethodNode("public", new BaseType(TypeEnum.CHAR), false, "testMethod", blockMethod);
+        method.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a"));
+
+        ClassNode class1 = new ClassNode("public", "Char");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.CHAR), "a"));
+        class1.addMember(constructor);
+        class1.addMember(method);
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Null Test")
+    public void nullTest() {
+        BlockNode blockCon = new BlockNode();
+        MemberAccessNode memberAccess = new MemberAccessNode(true);
+        memberAccess.addIdentifier("a");
+
+        AssignableNode assignable = new AssignableNode(memberAccess);
+
+        blockCon.addStatement(new AssignNode(assignable, new UnaryNode(new ValueNode(EnumValueNode.NULL_VALUE, "null"))));
+        blockCon.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "Null", blockCon);
+
+        ClassNode class1 = new ClassNode("public", "Null");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(constructor);
+
+        ProgramNode abstractSyntaxTree = new ProgramNode();
+        abstractSyntaxTree.addClass(class1);
+
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
+            runtimeException.printStackTrace();
+        }
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+        assertNotNull(typedAst);
+    }
+
+    @Test
+    @DisplayName("Self Reference Test")
+    public void selfReferenceTest() {
 
     }
 
-    public void test(int a, boolean b){
+    @Test
+    @DisplayName("Variable Compare Test")
+    public void variableCompareTest() {
 
     }
 
-    public void test(boolean b, int a){
+    @Test
+    @DisplayName("Variable Calculation Test")
+    public void variableCalculationTest() {
 
     }
 
-//    @Test
+    @Test
-//    public void alreadyDeclaredLocalFieldVar() {
+    @DisplayName("Main Method Test")
-//        ProgramNode programNode = new ProgramNode();
+    public void mainMethodTest() {
-//        List<ClassNode> classList = new ArrayList<>();
+
-//        AccessTypeNode accessTypeNode = new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
+    }
-//        ClassNode classNode = new ClassNode(accessTypeNode, "testClass");
+
-//
+    @Test
-//        SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
+    @DisplayName("While Test")
-//        ASTNode tast = semanticAnalyzer.generateTast(ast);
+    public void whileTest() {
-//
+
-//        MemberNode memberNode2 = new FieldNode(accessTypeNode, new BaseTypeNode(EnumTypeNode.INT), "testVar");
+    }
-//        classNode.members.add(memberNode2);
+
-//
+    @Test
-//        classList.add(classNode);
+    @DisplayName("Do While Test")
-//        programNode.classes = classList;
+    public void doWhileTest() {
-//
+
-//        ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
+    }
-//
+
-//        assertEquals(1, SemanticAnalyzer.errors.size());
+    @Test
-//        assertInstanceOf(AlreadyDeclaredException.class, SemanticAnalyzer.errors.getFirst());
+    @DisplayName("For Test")
-//        assertNull(typedAst);
+    public void forTest() {
-//    }
+
-//
+    }
-//    @Test
+
-//    public void shouldWorkWithNoError() {
+    @Test
-//        ProgramNode programNode = new ProgramNode();
+    @DisplayName("Increment Test")
-//        List<ClassNode> classList = new ArrayList<>();
+    public void incrementTest() {
-//        AccessTypeNode accessTypeNode = new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
+        ClassNode classNode = Helper.generateEmptyClass("Increment");
-//        ClassNode classNode = new ClassNode(accessTypeNode, "testClass");
+        classNode.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
-//
+
-//        SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
+        ProgramNode abstractSyntaxTree = new ProgramNode();
-//        ASTNode tast = semanticAnalyzer.generateTast(ast);
+        abstractSyntaxTree.addClass(classNode);
-//
+
-//        assertEquals(semanticAnalyzer.errors.size(), 0);
+        ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
-//        assertNotNull(tast);
+        for (Exception runtimeException : SemanticAnalyzer.errors) {
-//
+            runtimeException.printStackTrace();
-//        MemberNode memberNode3 = getMemberNode(accessTypeNode);
+        }
-//        classNode.members.add(memberNode3);
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
-//
+        assertNotNull(typedAst);
-//        classList.add(classNode);
+    }
-//        programNode.classes = classList;
+}
-//
-//        ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
-//
-//        assertEquals(0, SemanticAnalyzer.errors.size());
-//        assertEquals(programNode, typedAst);
-//    }
-//
-//    /**
-// * This method is used to create a MemberNode representing a method.
-// * It first creates a list of ParameterNodes and adds a ParameterNode to it.
-// * Then, it creates a ParameterListNode using the list of ParameterNodes.
-// * After that, it creates a list of StatementNodes and adds a StatementNode to it by calling the getStatementNode method.
-// * Finally, it creates a MethodNode using the provided AccessTypeNode, a BaseTypeNode representing the return type of the method,
-// * the method name, the ParameterListNode, and the list of StatementNodes, and returns this MethodNode.
-// *
-// * @param accessTypeNode The AccessTypeNode representing the access type of the method.
-// * @return The created MemberNode representing the method.
-// */
-//private static MemberNode getMemberNode(AccessTypeNode accessTypeNode) {
-//    List<ParameterNode> parameterNodeList = new ArrayList<>();
-//    ParameterNode parameterNode1 = new ParameterNode(new BaseTypeNode(EnumTypeNode.INT), "param1");
-//    parameterNodeList.add(parameterNode1);
-//    ParameterListNode parameterListNode = new ParameterListNode(parameterNodeList);
-//
-//    List<StatementNode> statementNodeList = new ArrayList<>();
-//
-//    StatementNode statementNode1 = getStatementNode();
-//    statementNodeList.add(statementNode1);
-//
-//    return new MethodNode(accessTypeNode, new BaseTypeNode(EnumTypeNode.INT), "testVar2", parameterListNode, statementNodeList);
-//}
-//
-//    /**
-// * This method is used to create a StatementNode for an assignment operation.
-// * It first creates two IdentifierExpressionNodes for 'this' and 'objectVar'.
-// * Then, it creates a BinaryExpressionNode to represent the operation 'this.objectVar'.
-// * After that, it creates a LiteralNode to represent the integer value 1.
-// * Finally, it creates another BinaryExpressionNode to represent the assignment operation 'this.objectVar = 1',
-// * and wraps this expression in an AssignmentStatementNode.
-// *
-// * @return The created AssignmentStatementNode representing the assignment operation 'this.objectVar = 1'.
-// */
-//private static StatementNode getStatementNode() {
-//    ExpressionNode expressionNodeObjectVariableLeft = new IdentifierExpressionNode("this");
-//    ExpressionNode expressionNodeObjectVariableRight = new IdentifierExpressionNode("objectVar");
-//
-//    ExpressionNode expressionNodeLeft = new BinaryExpressionNode(expressionNodeObjectVariableLeft, expressionNodeObjectVariableRight, ExpresssionOperator.DOT);
-//
-//    ExpressionNode expressionNodeRight = new LiteralNode(1);
-//
-//    BinaryExpressionNode expressionNode = new BinaryExpressionNode(expressionNodeLeft, expressionNodeRight, ExpresssionOperator.ASSIGNMENT);
-//
-//    return new AssignmentStatementNode(expressionNode);
-//}
-}

src/test/resources/input/CombinedExample.java

@@ -1,23 +0,0 @@
-public class CombinedExample {
-    int number;
-    boolean flag;
-    char letter;
-
-    public CombinedExample(int number, boolean flag, char letter) {
-        this.number = number;
-        this.flag = flag;
-        this.letter = letter;
-    }
-
-    public void displayValues() {
-        System.out.println("Number: " + number);
-        System.out.println("Flag: " + flag);
-        System.out.println("Letter: " + letter);
-    }
-
-    public static void main(String[] args) {
-        CombinedExample obj = new CombinedExample(10, true, 'X');
-        obj.displayValues();
-    }
-}
-

src/test/resources/input/CompilerInput.java

@@ -1,16 +0,0 @@
-public class CompilerInput {
-
-    public int a;
-
-    public static int testMethod(char x){
-        return 0;
-    }
-
-    public class Test {
-
-        public static int testMethod(char x, int a){
-            return 0;
-        }
-    }
-}
-

src/test/resources/input/MoreFeaturesClassExample.java

@@ -1,6 +0,0 @@
-public class MoreFeaturesClassExample {
-    int hallo;
-    private class Inner {
-        int hallo2;
-    }
-}

src/test/resources/input/combinedFeatureTests/AllFeaturesClassExample.java

@@ -4,63 +4,66 @@ public class AllFeaturesClassExample {
     char c;
 
     // Konstruktor
-    AllFeaturesClassExample(int a, boolean b, char c) {
+    public AllFeaturesClassExample(int a, boolean b, char c) {
         this.a = a;
         this.b = b;
         this.c = c;
     }
-    private class InnerClass {
-        void innerMethod() {
-            System.out.println("Inner class method");
-        }
-    }
 
     // Methode zur Demonstration von Kontrollstrukturen
     void controlStructures() {
         // if-else Anweisung
         if (a > 10) {
-            System.out.println("a ist größer als 10");
         } else {
-            System.out.println("a ist nicht größer als 10");
         }
 
         // while Schleife
         while (a > 0) {
-            System.out.println("a ist " + a);
             a--;
         }
-
+        int c = 0;
         // for Schleife
         for (int i = 0; i < 5; i++) {
-            System.out.println("for Schleife Iteration: " + i);
+            c++;
         }
 
-        // switch Anweisung
-        switch (c) {
-            case 'a':
-                System.out.println("c ist ein 'a'");
-                break;
-            case 'b':
-                System.out.println("c ist ein 'b'");
-                break;
-            default:
-                System.out.println("c ist nicht 'a' oder 'b'");
-        }
     }
 
     // Methode zur Arbeit mit logischen Operatoren
     void logicalOperations() {
         // Logische UND-Operation
         if (b && a > 5) {
-            System.out.println("a ist größer als 5 und b ist wahr");
         }
 
         // Logische ODER-Operation
         if (b || a < 5) {
-            System.out.println("b ist wahr oder a ist kleiner als 5");
         }
     }
 
+    int add(int a, int b) {
+        return a + b;
+    }
+
+    int subtract(int a, int b) {
+        return a - b;
+    }
+
+    int multiply(int a, int b) {
+        return a * b;
+    }
+
+    int divide(int a, int b) {
+        return a / b;
+    }
+
+    int modulo(int a, int b) {
+        return a % b;
+    }
+
+    boolean greaterThan(int a, int b) {
+        return a > b;
+    }
+
     public static void main(String[] args) {
         AllFeaturesClassExample obj = new AllFeaturesClassExample(12, true, 'a');
         obj.controlStructures();

src/test/resources/input/javaCases/ConstructorParameter.java

@@ -1,5 +0,0 @@
-class TestClass {
-    public TestClass(int a, int b){
-
-    }
-}

src/test/resources/input/javaCases/ConstructorThisDot.java

@@ -1,8 +0,0 @@
-class TestClass{
-
-    private int a;
-
-    public TestClass(int a){
-        this.a = a;
-    }
-}

src/test/resources/input/javaCases/EmptyClass.java

@@ -1 +0,0 @@
-class TestClass {}

src/test/resources/input/javaCases/EmptyClassWithConstructor.java

@@ -1,5 +0,0 @@
-public class TestClass {
-    public TestClass() {
-
-    }
-}

src/test/resources/input/javaCases/Field.java

@@ -1,3 +0,0 @@
-public class TestClass {
-    int a;
-}

src/test/resources/input/javaCases/FieldWithAccessModifier.java

@@ -1,3 +0,0 @@
-public class TestClass {
-    public int a;
-}

src/test/resources/input/javaCases/MultipleClasses.java

@@ -1,3 +0,0 @@
-class TestClass1 {}
-
-class TestClass2{}

src/test/resources/input/javaCases/Null.java

@@ -1,8 +0,0 @@
-class TestClass{
-
-    int a;
-
-    public TestClass(){
-        this.a = null;
-    }
-}

src/test/resources/input/javaCases/SelfReference.java

@@ -1,18 +0,0 @@
-class TestClass{
-
-    TestClass testClass;
-
-    int testMethod1() {
-        return this.testMethod2()
-    }
-
-    int testMethod2() {
-        return 1;
-    }
-
-    int testMehtod3(){
-        TestClass testClass1 = new TestClass();
-        return testClass1.testClass.testMethod1();
-    }
-
-}

src/test/resources/input/javaCases/VoidMethod.java

@@ -1,3 +0,0 @@
-class TestClass{
-    void test(){}
-}

src/test/resources/input/javaCases/variableCompareTest.java

@@ -1,30 +0,0 @@
-class TestClass{
-
-    boolean true(){
-        return true;
-    }
-
-    boolean false(){
-        return false();
-    }
-
-    boolean trueAndTrue(){
-        return true && true;
-    }
-
-    boolean trueAndFalse(){
-        return true && true;
-    }
-
-    boolean falseAndFalse(){
-        return false && false;
-    }
-
-    boolean trueOrFalse(){
-        return true || false;
-    }
-
-    boolean falseOrFalse(){
-        return false || false;
-    }
-}

src/test/resources/input/johnsTests/FieldTests.java

@@ -0,0 +1,5 @@
+public class Test{
+
+    int a = 10;
+
+}

src/test/resources/input/singleFeatureTests/Char.java

@@ -1,8 +1,8 @@
-class TestClass{
+class Char {
 
     char a;
 
-    public TestClass(char a){
+    public Char(char a){
         this.a = testMethod(a);
     }
 

src/test/resources/input/singleFeatureTests/Comments.java

@@ -3,6 +3,6 @@
     Mutliple Line Comment. Ignore
 
  */
-class TestClass{
+class Comments{
     private int a; // Ignore
 }

src/test/resources/input/singleFeatureTests/ConstructorMethodCall.java

@@ -1,8 +1,8 @@
-class TestClass {
+public class ConstructorMethodCall {
 
     int a;
 
-    public TestClass(){
+    public ConstructorMethodCall(){
         this.a = testMethod();
     }
 

src/test/resources/input/singleFeatureTests/ConstructorMethodCallParameters.java

@@ -1,8 +1,8 @@
-class TestClass {
+class ConstructorMethodCallParameters {
 
     int a;
 
-    public TestClass(int a){
+    public ConstructorMethodCallParameters(int a){
         this.a = testMethod(a);
     }
 

src/test/resources/input/singleFeatureTests/ConstructorParameter.java

@@ -0,0 +1,5 @@
+class ConstructorParameter {
+    public ConstructorParameter(int a, int b){
+
+    }
+}

src/test/resources/input/singleFeatureTests/ConstructorThisDot.java

@@ -0,0 +1,8 @@
+class ConstructorThisDot {
+
+    private int a;
+
+    public ConstructorThisDot(int a){
+        this.a = a;
+    }
+}

src/test/resources/input/singleFeatureTests/DoWhile.java

@@ -1,10 +1,10 @@
-class TestClass{
+class DoWhile{
 
-    public TestClass(){
+    public DoWhile(){
         int i = 0;
 
         do{
-            i++
+            i++;
         }while(i < 10);
     }
 }

src/test/resources/input/singleFeatureTests/EmptyClass.java

@@ -0,0 +1 @@
+class EmptyClass {}

src/test/resources/input/singleFeatureTests/EmptyClassWithConstructor.java

@@ -0,0 +1,5 @@
+public class EmptyClassWithConstructor {
+    public EmptyClassWithConstructor() {
+
+    }
+}

src/test/resources/input/singleFeatureTests/Field.java

@@ -0,0 +1,3 @@
+class Field {
+    int a;
+}

src/test/resources/input/singleFeatureTests/FieldWithAccessModifier.java

@@ -0,0 +1,3 @@
+public class FieldWithAccessModifier {
+    public int a;
+}

src/test/resources/input/singleFeatureTests/For.java

@@ -1,6 +1,6 @@
-class TestClass{
+class For{
 
-    public TestClass(){
+    public For(){
         for(int i = 0; i < 10; i++){
             int a;
         }

src/test/resources/input/singleFeatureTests/Increment.java

@@ -5,7 +5,7 @@ public class Increment {
     public void increment(int p) {
         test = p++;
 
-        for(int i = 1; i<=10, i++) {
+        for(int i = 1; i<=10; i++) {
             int a = 5;
         }
     }

src/test/resources/input/singleFeatureTests/MainMehod.java

@@ -1,4 +1,4 @@
-class TestClass{
+class MainMethod{
 
     public static void main(String[] args) {
     }

src/test/resources/input/singleFeatureTests/MultipleClasses.java

@@ -0,0 +1,3 @@
+class MultipleClasses {}
+
+class TestClass2{}

src/test/resources/input/singleFeatureTests/Null.java

@@ -0,0 +1,8 @@
+class Null{
+
+    int a;
+
+    public Null(){
+      //  this.a = null;
+    }
+}

src/test/resources/input/singleFeatureTests/SelfReference.java

@@ -0,0 +1,18 @@
+class SelfReference{
+
+    SelfReference selfReference;
+
+    int testMethod1() {
+        return this.testMethod2();
+    }
+
+    int testMethod2() {
+        return 1;
+    }
+
+    int testMehtod3(){
+        SelfReference selfReference1 = new SelfReference();
+        return selfReference1.selfReference.testMethod1();
+    }
+
+}

src/test/resources/input/singleFeatureTests/ThisDot.java

@@ -1,8 +1,8 @@
-class TestClass{
+class ThisDot {
 
     public int a;
 
-    public TestClass() {
+    public ThisDot() {
         this.a = 1;
     }
 }

src/test/resources/input/singleFeatureTests/VariableCalculationTest.java

@@ -1,4 +1,4 @@
-class TestClass{
+class VariableCalculationTest{
 
     int aPlusB(int a, int b){
         return a + b;

src/test/resources/input/singleFeatureTests/VariableCompareTest.java

@@ -0,0 +1,30 @@
+class VariableCompareTest{
+
+    boolean trueMethod(){
+        return true;
+    }
+
+    boolean falseMethod(){
+        return false;
+    }
+
+    boolean trueAndTrue(){
+        return trueMethod() && trueMethod();
+    }
+
+    boolean trueAndFalse(){
+        return trueMethod() && falseMethod();
+    }
+
+    boolean falseAndFalse(){
+        return falseMethod() && falseMethod();
+    }
+
+    boolean trueOrFalse(){
+        return trueMethod() || falseMethod();
+    }
+
+    boolean falseOrFalse(){
+        return falseMethod() || falseMethod();
+    }
+}

src/test/resources/input/singleFeatureTests/VoidMethod.java

@@ -0,0 +1,3 @@
+class VoidMethod{
+    void test(){}
+}

src/test/resources/input/singleFeatureTests/While.java

@@ -1,6 +1,6 @@
-class TestClass{
+class While{
 
-    public TestClass(){
+    public While(){
         int i = 10;
 
         while ( i > 0){

src/test/resources/input/typedAstFeatureTests/CallMethodFromObjekt.java

@@ -1,4 +1,4 @@
-public class Test {
+public class CallMethodFromObjekt {
 
     public int firstInt;
     public Car ca;
@@ -7,7 +7,6 @@ public class Test {
         return ca.getSpeed();
     }
 
-}
 
 public class Car{
 
@@ -17,4 +16,5 @@ public class Car{
         return speed;
     }
 
+}
 }

src/test/resources/input/typedAstFeatureTests/ChainedMethods.java

@@ -0,0 +1,29 @@
+public class Test {
+
+    public House h;
+
+    public int test(House h){
+        return h.getW().getSize();
+    }
+
+
+}
+
+public class House {
+
+    private Window w;
+
+    public Window getW(){
+        return w;
+    }
+
+}
+
+public class Window{
+
+    private int size;
+
+    public int getSize() {
+        return size;
+    }
+}

src/test/resources/input/typedAstFeatureTests/CorrectMemberAccess.java

@@ -1,4 +1,4 @@
-public class Test{
+public class CorrectMemberAccess{
 
     public Car c;
 
@@ -6,9 +6,8 @@ public class Test{
         return c.getSpeed();
     }
 
-}
 
-public class Car{
+private class Car{
 
     private int speed;
 
@@ -16,4 +15,5 @@ public class Car{
         return speed;
     }
 
+}
 }

src/test/resources/input/typedAstFeatureTests/CorrectMethodParameter.java

@@ -1,4 +1,4 @@
-public class Test{
+public class CorrectMethodParameter{
 
     public void test(int x){
 

src/test/resources/input/typedAstFeatureTests/CorrectNonCalcTest.java

@@ -1,4 +1,4 @@
-public class Test{
+public class CorrectNonCalcTest{
 
     public void test(boolean b){
         if(b == true){

src/test/resources/input/typedAstFeatureTests/CorrectReturnType.java

@@ -1,4 +1,4 @@
-public class Example {
+public class CorrectReturnType {
 
     public static int testMethod(int x){
         return x;

src/test/resources/input/typedAstFeatureTests/CorrectTest.java

@@ -0,0 +1,21 @@
+public class CorrectTest {
+    int a;
+    boolean b;
+    char c;
+
+    public void controlStructures(int adf, boolean bool) {
+        if (a > (10 + 8)) {
+        } else {
+        }
+
+
+        while (a > adf) {
+            a--;
+        }
+
+        for (int i = 0; i < 5; i++) {
+        }
+
+
+    }
+}

src/test/resources/input/typedAstFeatureTests/FullTest.java

@@ -1,5 +1,5 @@
 
-public class AllFeaturesClassExample {
+public class FullTest {
     int a;
     boolean b;
     char c;
@@ -18,7 +18,7 @@ public class AllFeaturesClassExample {
         }
 
 
-    }
+
 
 //    void logicalOperations() {
 //        // Logische UND-Operation
@@ -62,3 +62,4 @@ public class Car {
 
 }
 
+}

src/test/resources/input/typedAstFeatureTests/IfExpressionBoolean.java

@@ -1,4 +1,4 @@
-public class Car{
+public class IfExpressionBoolean{
 
     public void test(boolean boo){
 

src/test/resources/input/typedAstFeatureTests/IfReturn.java

@@ -1,4 +1,4 @@
-public class Car{
+public class IfReturn{
 
     public int getSpeed(boolean bool, int a, int b){
 

src/test/resources/input/typedAstFeatureTests/SelectRightOverloadedMethod.java

@@ -1,4 +1,4 @@
-public class Test{
+public class SelectRightOverloadedMethod{
 
     public int i;
     public boolean b;

src/test/resources/input/typedAstFeatureTests/ThisDotMethod.java

@@ -1,4 +1,4 @@
-public class Car{
+public class ThisDotMethod{
 
     private int speed;
 

src/test/resources/input/typedAstFeatureTests/VoidReturnTypeIF.java

@@ -1,4 +1,4 @@
-public class Car{
+public class VoidReturnTypeIF{
 
     private int speed;