Merge branch 'main' into Tests

src/main/java/ast/ClassNode.java

@@ -15,30 +15,20 @@ public class ClassNode implements ASTNode, Visitable {
     public AccessModifierNode accessType;
     public String identifier;
     public List<MemberNode> members = new ArrayList<>();
-    public boolean hasConstructor;
 
-    public ClassNode() {}
+    public ClassNode(){
+
+    }
 
     public ClassNode(String accessType, String identifier){
         this.accessType = new AccessModifierNode(accessType);
         this.identifier = identifier;
-        hasConstructor = false;
     }
 
     public void addMember(MemberNode member) {
-        if (member instanceof ConstructorNode) {
-            this.hasConstructor = true;
-        }
         members.add(member);
     }
 
-    public void ensureConstructor(){
-        if(!hasConstructor) {
-            ConstructorNode constructor = new ConstructorNode(new AccessModifierNode("public"), identifier);
-            members.addFirst(constructor);
-        }
-    }
-
     public List<MethodNode> getMethods(){
         List<MethodNode> methods = new ArrayList<>();
         for (MemberNode member : members) {

src/main/java/ast/expressions/IExpressionNode.java

@@ -8,4 +8,6 @@ public interface IExpressionNode extends ASTNode, Visitable {
 
     ITypeNode getType();
 
+    void setType(ITypeNode type);
+
 }

src/main/java/ast/expressions/binaryexpressions/BinaryNode.java

@@ -7,6 +7,8 @@ import typechecker.TypeCheckResult;
 
 public class BinaryNode implements IExpressionNode {
 
+    private ITypeNode typeNode;
+
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
         return visitor.analyze(this);
@@ -14,6 +16,11 @@ public class BinaryNode implements IExpressionNode {
 
     @Override
     public ITypeNode getType() {
-        return null;
+        return typeNode;
+    }
+
+    @Override
+    public void setType(ITypeNode type) {
+        this.typeNode = type;
     }
 }

src/main/java/ast/expressions/binaryexpressions/CalculationNode.java

@@ -8,6 +8,7 @@ public class CalculationNode extends BinaryNode {
     public CalculationNode calculationExpression;
     public EnumLineOperator operator;
     public DotNode dotExpression;
+    private ITypeNode typeNode;
 
     public CalculationNode(CalculationNode calculationExpression, String operator, DotNode dotExpression) {
         this.calculationExpression = calculationExpression;
@@ -32,9 +33,4 @@ public class CalculationNode extends BinaryNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public ITypeNode getType() {
-        return null;
-    }
-
 }

src/main/java/ast/expressions/binaryexpressions/DotNode.java

@@ -34,9 +34,4 @@ public class DotNode extends BinaryNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public ITypeNode getType() {
-        return null;
-    }
-
 }

src/main/java/ast/expressions/binaryexpressions/DotSubstractionNode.java

@@ -36,9 +36,4 @@ public class DotSubstractionNode extends BinaryNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public ITypeNode getType() {
-        return null;
-    }
-
 }

src/main/java/ast/expressions/binaryexpressions/NonCalculationNode.java

@@ -42,9 +42,4 @@ public class NonCalculationNode extends BinaryNode {
         return visitor.analyze(this);
     }
 
-    @Override
-    public ITypeNode getType() {
-        return null;
-    }
-
 }

src/main/java/ast/expressions/unaryexpressions/MemberAccessNode.java

@@ -1,13 +1,18 @@
 package ast.expressions.unaryexpressions;
 
 import ast.ASTNode;
+import ast.type.type.ITypeNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+import visitor.Visitable;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class MemberAccessNode implements ASTNode {
+public class MemberAccessNode implements ASTNode, Visitable {
     public Boolean thisExpr;
     public List<String> identifiers = new ArrayList<>();
+    private ITypeNode typeNode;
 
     public MemberAccessNode(Boolean thisExpr) {
         this.thisExpr = thisExpr;
@@ -17,4 +22,17 @@ public class MemberAccessNode implements ASTNode {
         identifiers.add(identifier);
     }
 
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
+
+    public ITypeNode getTypeNode() {
+        return typeNode;
+    }
+
+    public void setTypeNode(ITypeNode typeNode) {
+        this.typeNode = typeNode;
+    }
+
 }

src/main/java/ast/members/ConstructorNode.java

@@ -6,6 +6,7 @@ import ast.type.AccessModifierNode;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 public class ConstructorNode extends MethodNode  {
     public AccessModifierNode accessType;
@@ -13,11 +14,6 @@ public class ConstructorNode extends MethodNode  {
     public List<ParameterNode> parameters = new ArrayList<>();
     public BlockNode block;
 
-    public ConstructorNode(AccessModifierNode accessType, String identifier) {
-        this.accessType = accessType;
-        this.identifier = identifier;
-    }
-
     public ConstructorNode(String accessType, String identifier, BlockNode block) {
         this.accessType = new AccessModifierNode(accessType);
         this.identifier = identifier;
@@ -28,4 +24,18 @@ public class ConstructorNode extends MethodNode  {
         parameters.add(parameterNode);
     }
 
+    @Override
+    public boolean isSame(MethodNode methodNode) {
+        if (!(Objects.equals(this.identifier, methodNode.getIdentifier()))
+                || getParameters().size() != methodNode.getParameters().size()) {
+            return false;
+        }
+
+        for (int i = 0; i < this.getParameters().size(); i++) {
+            if (!this.getParameters().get(i).type.equals(methodNode.getParameters().get(i).type)) {
+                return false;
+            }
+        }
+        return true;
+    }
 }

src/main/java/ast/members/MainMethodNode.java

@@ -3,7 +3,6 @@ package ast.members;
 import ast.statements.BlockNode;
 
 public class MainMethodNode extends MethodNode {
-    public BlockNode block;
 
     public MainMethodNode(BlockNode block) {
         this.block = block;

src/main/java/ast/members/MethodNode.java

@@ -46,7 +46,7 @@ public class MethodNode implements MemberNode, Visitable {
         }
 
         for (int i = 0; i < this.getParameters().size(); i++) {
-            if (this.getParameters().get(i).type.equals(methodNode.getParameters().get(i).type)) {
+            if (!this.getParameters().get(i).type.equals(methodNode.getParameters().get(i).type)) {
                 return false;
             }
         }

src/main/java/ast/statementexpressions/AssignableNode.java

@@ -1,11 +1,13 @@
 package ast.statementexpressions;
 
 import ast.expressions.unaryexpressions.MemberAccessNode;
+import ast.type.type.ITypeNode;
 import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
 public class AssignableNode implements IStatementExpressionNode {
     public String identifier;
+    private ITypeNode typeNode;
 
     public MemberAccessNode memberAccess;
 
@@ -22,4 +24,12 @@ public class AssignableNode implements IStatementExpressionNode {
         return visitor.analyze(this);
     }
 
+    public ITypeNode getTypeNode() {
+        return typeNode;
+    }
+
+    public void setTypeNode(ITypeNode typeNode) {
+        this.typeNode = typeNode;
+    }
+
 }

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

@@ -3,8 +3,11 @@ package ast.statementexpressions.methodcallstatementnexpressions;
 import ast.ASTNode;
 import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.statementexpressions.NewDeclarationNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+import visitor.Visitable;
 
-public class TargetNode implements ASTNode {
+public class TargetNode implements ASTNode, Visitable {
     public Boolean thisTar;
     public MemberAccessNode memberAccess;
     public NewDeclarationNode newDeclaration;
@@ -25,4 +28,11 @@ public class TargetNode implements ASTNode {
     public TargetNode(String identifier) {
         this.identifier = identifier;
     }
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
+
+
 }

src/main/java/ast/statements/ElseNode.java

@@ -5,7 +5,7 @@ import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
 public class ElseNode implements IStatementNode {
-    BlockNode block;
+    public BlockNode block;
 
     public ElseNode(BlockNode block) {
         this.block = block;
@@ -14,6 +14,6 @@ public class ElseNode implements IStatementNode {
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
+        return visitor.analyze(this);
     }
 }

src/main/java/ast/statements/IfElseNode.java

@@ -8,9 +8,9 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class IfElseNode implements IStatementNode {
-    IfNode ifStatement;
-    List<IfNode> elseIfStatements = new ArrayList<>();
-    ElseNode elseStatement;
+    public IfNode ifStatement;
+    public List<IfNode> elseIfStatements = new ArrayList<>();
+    public ElseNode elseStatement;
 
     public IfElseNode(IfNode ifStatement, ElseNode elseNode) {
         this.ifStatement = ifStatement;
@@ -23,6 +23,6 @@ public class IfElseNode implements IStatementNode {
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
+        return visitor.analyze(this);
     }
 }

src/main/java/ast/statements/IfNode.java

@@ -6,8 +6,8 @@ import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
 public class IfNode implements IStatementNode {
-    IExpressionNode expression;
-    BlockNode block;
+    public IExpressionNode expression;
+    public BlockNode block;
 
     public IfNode(IExpressionNode expression, BlockNode block) {
         this.expression = expression;
@@ -16,6 +16,6 @@ public class IfNode implements IStatementNode {
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
+        return visitor.analyze(this);
     }
 }

src/main/java/ast/statements/WhileNode.java

@@ -6,8 +6,8 @@ import semantic.SemanticVisitor;
 import typechecker.TypeCheckResult;
 
 public class WhileNode implements IStatementNode {
-    IExpressionNode expression;
-    BlockNode block;
+    public IExpressionNode expression;
+    public BlockNode block;
 
     public WhileNode(IExpressionNode expression, BlockNode block) {
         this.expression = expression;
@@ -21,6 +21,6 @@ public class WhileNode implements IStatementNode {
 
     @Override
     public TypeCheckResult accept(SemanticVisitor visitor) {
-        return null;
+        return visitor.analyze(this);
     }
 }

src/main/java/ast/type/ValueNode.java

@@ -1,8 +1,11 @@
 package ast.type;
 
 import ast.ASTNode;
+import semantic.SemanticVisitor;
+import typechecker.TypeCheckResult;
+import visitor.Visitable;
 
-public class ValueNode implements ASTNode {
+public class ValueNode implements ASTNode, Visitable {
     public EnumValueNode valueType;
     public String value;
 
@@ -10,4 +13,10 @@ public class ValueNode implements ASTNode {
         this.valueType = valueType;
         this.value = value;
     }
+
+
+    @Override
+    public TypeCheckResult accept(SemanticVisitor visitor) {
+        return visitor.analyze(this);
+    }
 }

src/main/java/parser/astBuilder/ASTBuilder.java

@@ -44,11 +44,32 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitClassDeclaration(SimpleJavaParser.ClassDeclarationContext ctx) {
-        ClassNode classNode = new ClassNode(ctx.AccessModifier().getText(), ctx.Identifier().getText());
-        for (SimpleJavaParser.MemberDeclarationContext member : ctx.memberDeclaration()) {
-            classNode.addMember((MemberNode) visit(member));
+        ClassNode classNode;
+        if(ctx.AccessModifier() != null){
+            classNode = new ClassNode(ctx.AccessModifier().getText(), ctx.Identifier().getText());
         }
-        classNode.ensureConstructor();
+        else{
+            classNode = new ClassNode("public", ctx.Identifier().getText());
+        }
+
+        boolean hasConstructor = false;
+
+        for (SimpleJavaParser.MemberDeclarationContext member : ctx.memberDeclaration()) {
+            MemberNode memberNode = (MemberNode) visit(member);
+            if(memberNode != null) {
+                if(memberNode instanceof ConstructorNode){
+                    hasConstructor = true;
+                }
+                classNode.addMember(memberNode);
+            }
+        }
+
+        if(!hasConstructor){
+            BlockNode blockNode = new BlockNode();
+            blockNode.addStatement(new ReturnNode(null));
+            classNode.members.addFirst(new ConstructorNode("public", ctx.Identifier().getText(), blockNode));
+        }
+
         return classNode;
     }
 
@@ -72,29 +93,54 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
             return mainMethod;
         } else {
             if(ctx.type() != null) {
-                MethodNode methodNode = new MethodNode(ctx.AccessModifier().getText(), createTypeNode(ctx.type().getText()), false, ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
-                if(ctx.parameterList() != null) {
-                    for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
-                        methodNode.addParameter((ParameterNode) visit(parameter));
+                if(ctx.AccessModifier() != null) {
+                    MethodNode methodNode = new MethodNode(ctx.AccessModifier().getText(), createTypeNode(ctx.type().getText()), false, ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
+                    if(ctx.parameterList() != null) {
+                        for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
+                            methodNode.addParameter((ParameterNode) visit(parameter));
+                        }
                     }
+                    return methodNode;
+                } else {
+                    MethodNode methodNode = new MethodNode("public", createTypeNode(ctx.type().getText()), false, ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
+                    if(ctx.parameterList() != null) {
+                        for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
+                            methodNode.addParameter((ParameterNode) visit(parameter));
+                        }
+                    }
+                    return methodNode;
                 }
-                return methodNode;
             } else {
-                MethodNode methodNode = new MethodNode(ctx.AccessModifier().getText(), null, true, ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
-                if(ctx.parameterList() != null) {
-                    for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
-                        methodNode.addParameter((ParameterNode) visit(parameter));
+                if(ctx.AccessModifier() != null) {
+                    MethodNode methodNode = new MethodNode(ctx.AccessModifier().getText(), null, true, ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
+                    if(ctx.parameterList() != null) {
+                        for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
+                            methodNode.addParameter((ParameterNode) visit(parameter));
+                        }
                     }
+                    methodNode.block.addStatement(new ReturnNode(null));
+                    return methodNode;
+                } else {
+                    MethodNode methodNode = new MethodNode("public", null, true, ctx.Identifier().getText(), (BlockNode) visit(ctx.blockStatement()));
+                    if(ctx.parameterList() != null) {
+                        for(SimpleJavaParser.ParameterContext parameter : ctx.parameterList().parameter()) {
+                            methodNode.addParameter((ParameterNode) visit(parameter));
+                        }
+                    }
+                    methodNode.block.addStatement(new ReturnNode(null));
+                    return methodNode;
                 }
-                methodNode.block.addStatement(new ReturnNode(null));
-                return methodNode;
             }
         }
     }
 
     @Override
     public ASTNode visitFieldDeclaration(SimpleJavaParser.FieldDeclarationContext ctx) {
-        return new FieldNode(new AccessModifierNode(ctx.AccessModifier().getText()), createTypeNode(ctx.type().getText()), ctx.Identifier().getText());
+        if(ctx.AccessModifier() != null) {
+            return new FieldNode(new AccessModifierNode(ctx.AccessModifier().getText()), createTypeNode(ctx.type().getText()), ctx.Identifier().getText());
+        } else {
+            return new FieldNode(new AccessModifierNode("public"), createTypeNode(ctx.type().getText()), ctx.Identifier().getText());
+        }
     }
 
     @Override
@@ -184,10 +230,17 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
             crement = (IStatementNode) visit(ctx.statementExpression(i));
         }
 
-        BlockNode forBlock = (BlockNode) visit(ctx.blockStatement());
+        BlockNode forBlock = new BlockNode();
+
+        BlockNode forStatements = (BlockNode) visit(ctx.blockStatement());
+        if(forStatements != null) {
+            forBlock.addStatement((IStatementNode) forStatements);
+        }
 
         if(crement != null){
-            forBlock.addStatement((crement));
+            BlockNode forCrement = new BlockNode();
+            forCrement.addStatement((crement));
+            forBlock.addStatement(forCrement);
         }
 
         WhileNode While = new WhileNode(condition, forBlock);
@@ -259,7 +312,12 @@ public class ASTBuilder extends SimpleJavaBaseVisitor<ASTNode> {
 
     @Override
     public ASTNode visitMethodCall(SimpleJavaParser.MethodCallContext ctx) {
-        MethodCallNode methodCallStatementExpressionNode = new MethodCallNode((TargetNode) visit(ctx.target()), ctx.Identifier().getText());
+        MethodCallNode methodCallStatementExpressionNode;
+        if(ctx.target() != null) {
+            methodCallStatementExpressionNode = new MethodCallNode((TargetNode) visit(ctx.target()), ctx.Identifier().getText());
+        } else {
+            methodCallStatementExpressionNode = new MethodCallNode(null, ctx.Identifier().getText());
+        }
         for(SimpleJavaParser.ChainedMethodContext chainedMethod : ctx.chainedMethod()) {
             methodCallStatementExpressionNode.addChainedMethod((ChainedMethodNode) visit(chainedMethod));
         }

src/main/java/parser/generated/SimpleJavaBaseListener.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 
 import org.antlr.v4.runtime.ParserRuleContext;

src/main/java/parser/generated/SimpleJavaBaseVisitor.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor;
 

src/main/java/parser/generated/SimpleJavaLexer.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.CharStream;

src/main/java/parser/generated/SimpleJavaListener.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 

src/main/java/parser/generated/SimpleJavaParser.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.atn.*;
 import org.antlr.v4.runtime.dfa.DFA;

src/main/java/parser/generated/SimpleJavaVisitor.java

@@ -1,4 +1,4 @@
-// Generated from C:/Users/Maxi/Documents/DHBW/Compilerbau/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
+// Generated from C:/Users/janni/Desktop/NichtHaskell2.0/src/main/java/parser/grammar/SimpleJava.g4 by ANTLR 4.13.1
 package parser.generated;
 import org.antlr.v4.runtime.tree.ParseTreeVisitor;
 

src/main/java/semantic/SemanticAnalyzer.java

@@ -9,6 +9,7 @@ import java.util.Objects;
 import ast.*;
 import ast.expressions.IExpressionNode;
 import ast.expressions.binaryexpressions.*;
+import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.expressions.unaryexpressions.UnaryNode;
 import ast.members.ConstructorNode;
 import ast.members.FieldNode;
@@ -21,8 +22,13 @@ import ast.statementexpressions.NewDeclarationNode;
 import ast.statementexpressions.crementexpressions.DecrementNode;
 import ast.statementexpressions.crementexpressions.IncrementNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
+import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
 import ast.statements.*;
+import ast.type.AccessModifierNode;
+import ast.type.EnumAccessModifierNode;
+import ast.type.ValueNode;
 import ast.type.type.*;
+import com.sun.jdi.IntegerType;
 import semantic.context.Context;
 import semantic.exceptions.*;
 import typechecker.TypeCheckResult;
@@ -134,26 +140,20 @@ public class SemanticAnalyzer implements SemanticVisitor {
                 }
 
             }
-            // Check if this method is already declared
 
             currentMethodReturnType = methodNode.getType();
-            currentNullType = currentMethodReturnType; // Solange nicht in einem Assign oder Methoden-Aufruf dieser Typ
+            currentNullType = currentMethodReturnType;
 
-            ITypeNode resultType = new BaseType(TypeEnum.VOID);
-
-            // gesetzt ist, ist dieser der Rückgabewert der Methode
             var result = methodNode.block.accept(this);
             valid = valid && result.isValid();
             currentScope.popScope();
-            resultType = result.getType();
+            ITypeNode resultType = result.getType();
 
             if (resultType == null) {
                 resultType = new BaseType(TypeEnum.VOID);
             }
-            if (!resultType.equals(methodNode.getType())) {
-                errors.add(new TypeMismatchException("Method-Declaration " + methodNode.getIdentifier() + " with type "
-                        + methodNode.getType() + " has at least one Mismatching return Type:"));
-                valid = false;
+            if (methodNode.getType() == null) {
+                methodNode.setType(new BaseType(TypeEnum.VOID));
             }
 
             return new TypeCheckResult(valid, resultType);
@@ -174,43 +174,65 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(IfNode toCheck) {
+        toCheck.block.accept(this);
+
+        var resultExpression = toCheck.expression.accept(this);
+        if (resultExpression.isValid()) {
+            if (!resultExpression.getType().equals(new BaseType(TypeEnum.BOOL))) {
+                errors.add(new TypeMismatchException("Expression must be Boolean"));
+                return new TypeCheckResult(false, new BaseType(TypeEnum.VOID));
+            }
+        }
+
         return new TypeCheckResult(true, null);
     }
 
     @Override
     public TypeCheckResult analyze(ReturnNode toCheck) {
-
-        if(toCheck.expression != null){
+        if (toCheck.expression != null) {
             var result = toCheck.expression.accept(this);
+            if (result.isValid()) {
+                if (!result.getType().equals(currentMethodReturnType)) {
+                    errors.add(new TypeMismatchException("Mismatched return Type from method"));
+                }
+            }
             return new TypeCheckResult(true, result.getType());
-        } else {
-            return new TypeCheckResult(false, null);
+        } else if (toCheck.voidReturn) {
+            return new TypeCheckResult(true, new BaseType(TypeEnum.VOID));
         }
+        return new TypeCheckResult(true, null);
 
     }
 
     @Override
     public TypeCheckResult analyze(WhileNode toCheck) {
-        return null;
+        var expResult = toCheck.expression.accept(this);
+        var blockRes = toCheck.block.accept(this);
+        return new TypeCheckResult(expResult.isValid() && blockRes.isValid(), blockRes.getType());
     }
 
     @Override
     public TypeCheckResult analyze(ParameterNode toCheck) {
-
-
-        return new TypeCheckResult(true, null);
+        return new TypeCheckResult(true, toCheck.type);
     }
 
     @Override
     public TypeCheckResult analyze(BlockNode blockNode) {
         ITypeNode blockReturnType = null;
+        if (blockNode.statements.isEmpty()) {
+            return new TypeCheckResult(true, null);
+        }
         for (IStatementNode statementNode : blockNode.statements) {
             var result = statementNode.accept(this);
-            if(result.getType() != null){
-                if(blockReturnType == null){
-                    blockReturnType = result.getType();
-                } else {
-                    errors.add(new MultipleReturnTypes("There are multiple Return types"));
+            if(!(statementNode instanceof IncrementNode) && !(statementNode instanceof DecrementNode)){
+                if (result.getType() != null) {
+                    if (blockReturnType == null) {
+                        blockReturnType = result.getType();
+                    } else {
+                        if (!blockReturnType.equals(result.getType())) {
+                            errors.add(new MultipleReturnTypes("There are multiple Return types"));
+                        }
+                    }
                 }
             }
         }
@@ -219,20 +241,31 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(AssignableNode toCheck) {
-        return new TypeCheckResult(true, currentFields.get(toCheck.identifier));
+
+        if (toCheck.memberAccess != null) {
+            var result = toCheck.memberAccess.accept(this);
+            toCheck.setTypeNode(result.getType());
+            return result;
+        } else {
+            if (currentFields.get(toCheck.identifier) != null) {
+                var type = currentFields.get(toCheck.identifier);
+                toCheck.setTypeNode(type);
+                return new TypeCheckResult(true, type);
+            } else if (currentScope.getLocalVar(toCheck.identifier) != null) {
+                var type = currentScope.getLocalVar(toCheck.identifier);
+                return new TypeCheckResult(true, type);
+            }
+        }
+
+        return new TypeCheckResult(true, null);
 
     }
 
     @Override
     public TypeCheckResult analyze(ElseNode toCheck) {
-        return null;
+        return toCheck.block.accept(this);
     }
 
-    /*@Override
-    public TypeCheckResult analyze(ForNode toCheck) {
-        return null;
-    }*/
-
     @Override
     public TypeCheckResult analyze(AssignNode toCheck) {
         AssignableNode assignable = toCheck.assignable;
@@ -258,33 +291,61 @@ public class SemanticAnalyzer implements SemanticVisitor {
         currentNullType = lResult.getType();
         var rResult = rExpression.accept(this);
 
-        if (!Objects.equals(currentScope.getLocalVar(toCheck.assignable.identifier), rExpression.getType())) {
+        if (!Objects.equals(lResult.getType(), rResult.getType())) {
             errors.add(new TypeMismatchException(
                     "Mismatch types in Assign-Statement: cannot convert from \"" + lResult.getType() + "\" to \""
                             + rResult.getType() + "\""));
             valid = false;
         }
-//        else {
-//            toCheck.setType(assignable.getType());
-//        }
         valid = valid && lResult.isValid() && rResult.isValid();
         currentNullType = null;
         return new TypeCheckResult(valid, null); // return type is null to get the return type sufficently
     }
 
     @Override
-    public TypeCheckResult analyze(DecrementNode toCheck) {
-        return null;
+    public TypeCheckResult analyze(DecrementNode decrementNode) {
+        return decrementNode.assignableExpression.accept(this);
     }
 
     @Override
     public TypeCheckResult analyze(IfElseNode toCheck) {
-        return new TypeCheckResult(true, null);
+        var resultIf = toCheck.ifStatement.accept(this);
+        var resultElse = toCheck.elseStatement.accept(this);
+
+        return new TypeCheckResult(resultIf.isValid() && resultElse.isValid(), new BaseType(TypeEnum.VOID));
     }
 
     @Override
     public TypeCheckResult analyze(MethodCallNode toCheck) {
-        return null;
+
+        if (toCheck.target.identifier != null) {
+            var targetType = currentScope.getLocalVar(toCheck.target.identifier);
+            if (targetType == null) {
+                targetType = currentFields.get(toCheck.target.identifier);
+            }
+            if (targetType instanceof ReferenceType reference) {
+                var type = getTypeFromMethod(toCheck, reference);
+                if (type != null) {
+                    return new TypeCheckResult(true, type);
+                } else {
+                    return new TypeCheckResult(false, null);
+                }
+
+            }
+        } else {
+            if (toCheck.target.thisTar) {
+                var type = getTypeFromMethod(toCheck, new ReferenceType(currentClass.identifier));
+                if (type != null) {
+                    return new TypeCheckResult(true, type);
+                }
+            } else {
+                var result = toCheck.target.accept(this);
+                if (result.getType() instanceof ReferenceType reference) {
+                    return new TypeCheckResult(true, getTypeFromMethod(toCheck, reference));
+                }
+            }
+        }
+        return new TypeCheckResult(false, null);
     }
 
     @Override
@@ -295,6 +356,9 @@ public class SemanticAnalyzer implements SemanticVisitor {
             TypeCheckResult result = localVarDecl.expression.accept(this);
 
             var resultType = localVarDecl.expression.getType();
+            if (result.getType() != null) {
+                resultType = result.getType();
+            }
             valid = result.isValid() && valid;
 
             if (!Objects.equals(resultType, localVarDecl.type)) {
@@ -316,12 +380,17 @@ public class SemanticAnalyzer implements SemanticVisitor {
 
     @Override
     public TypeCheckResult analyze(NewDeclarationNode toCheck) {
+
+        if (context.containsClass(toCheck.identifier)) {
+            return new TypeCheckResult(true, new ReferenceType(toCheck.identifier));
+        }
+
         return null;
     }
 
     @Override
     public TypeCheckResult analyze(IncrementNode toCheck) {
-        return null;
+        return toCheck.assignableExpression.accept(this);
     }
 
     @Override
@@ -332,38 +401,223 @@ public class SemanticAnalyzer implements SemanticVisitor {
     @Override
     public TypeCheckResult analyze(CalculationNode calcNode) {
         if (calcNode.calculationExpression != null) {
-            calcNode.calculationExpression.accept(this);
+            var calcRes = calcNode.calculationExpression.accept(this);
+            if (calcNode.dotExpression != null) {
+                var dotRes = calcNode.dotExpression.accept(this);
+
+                switch (calcNode.operator) {
+                    case PLUS, MINUS:
+                        if (calcRes.getType() instanceof BaseType calcType && dotRes.getType() instanceof BaseType dotType &&
+                                calcType.getTypeEnum().equals(TypeEnum.INT) && dotType.getTypeEnum().equals(TypeEnum.INT)) {
+                            return new TypeCheckResult(true, new BaseType(TypeEnum.INT));
+                        }
+                        break;
+                    default:
+                }
+
+            } else {
+                return new TypeCheckResult(calcRes.isValid(), calcRes.getType());
+            }
+        } else if (calcNode.dotExpression != null) {
+            var dotRes = calcNode.dotExpression.accept(this);
+            return new TypeCheckResult(dotRes.isValid(), dotRes.getType());
+        }
+        return new TypeCheckResult(false, null);
+    }
+
+    @Override
+    public TypeCheckResult analyze(DotNode toCheck) {
+        if (toCheck.dotSubstractionExpression != null) {
+            return toCheck.dotSubstractionExpression.accept(this);
+        }
+        return new TypeCheckResult(false, null);
+    }
+
+    @Override
+    public TypeCheckResult analyze(DotSubstractionNode toCheck) {
+        if (toCheck.value != null) {
+            return toCheck.value.accept(this);
+        } else if (toCheck.memberAccess != null) {
+            return toCheck.memberAccess.accept(this);
+        } else if (toCheck.methodCall != null) {
+            return toCheck.methodCall.accept(this);
+        } else if (toCheck.identifier != null) {
+            if (currentScope.contains(toCheck.identifier)) {
+                return new TypeCheckResult(true, currentScope.getLocalVar(toCheck.identifier));
+            } else if (currentFields.get(toCheck.identifier) != null) {
+                return new TypeCheckResult(true, currentFields.get(toCheck.identifier));
+            }
+        } else if (toCheck.calculationExpression != null) {
+            return toCheck.calculationExpression.accept(this);
         }
         return null;
     }
 
     @Override
-    public TypeCheckResult analyze(DotNode toCheck) {
-        return null;
-    }
+    public TypeCheckResult analyze(NonCalculationNode nonCalculationNode) {
+        var expResult = nonCalculationNode.expression.accept(this);
+        var unaryResult = nonCalculationNode.unaryExpression.accept(this);
 
-    @Override
-    public TypeCheckResult analyze(DotSubstractionNode toCheck) {
-        return null;
-    }
+        switch (nonCalculationNode.operator) {
+            case LESS, LESS_EQUAL, GREATER, GREATER_EQUAL:
+                if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.INT) &&
+                        unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.INT)) {
+                    return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
+                } else {
+                    errors.add(new TypeMismatchException("Both types must be Integer"));
+                }
+                break;
+            case OR, AND:
+                if (expResult.getType() instanceof BaseType expResultType && expResultType.getTypeEnum().equals(TypeEnum.INT) &&
+                        unaryResult.getType() instanceof BaseType unaryResultType && unaryResultType.getTypeEnum().equals(TypeEnum.INT)) {
+                    return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
+                } else {
+                    errors.add(new TypeMismatchException("Both types must be Boolean"));
+                }
+                break;
+            case EQUAL, NOT_EQUAL:
+                if (expResult.getType() instanceof BaseType expResultType && unaryResult.getType() instanceof BaseType unaryResultType
+                        && Objects.equals(expResultType, unaryResultType)) {
+                    return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
+                } else {
+                    errors.add(new TypeMismatchException("Both types must be the same"));
+                }
 
-    @Override
-    public TypeCheckResult analyze(NonCalculationNode toCheck) {
-        return null;
+        }
+        return new TypeCheckResult(false, null);
     }
 
     @Override
     public TypeCheckResult analyze(UnaryNode unary) {
         var valid = true;
 
-        if (currentScope.contains(unary.identifier)) {
-            return  new TypeCheckResult(valid, currentScope.getLocalVar(unary.identifier));
-        } else if(currentFields.get(unary.identifier) != null) {
-            return  new TypeCheckResult(valid, currentFields.get(unary.identifier));
-        } else {
-            errors.add(new NotDeclaredException("Var is not Declared"));
+        if (unary.identifier != null) {
+            if (currentScope.contains(unary.identifier)) {
+                return new TypeCheckResult(valid, currentScope.getLocalVar(unary.identifier));
+            } else if (currentFields.get(unary.identifier) != null) {
+                return new TypeCheckResult(valid, currentFields.get(unary.identifier));
+            } else if (unary.statement != null) {
+                var result = unary.statement.accept(this);
+                unary.setType(result.getType());
+                return result;
+            } else {
+                errors.add(new NotDeclaredException("Var is not Declared"));
+            }
+        } else if (unary.statement != null) {
+            var result = unary.statement.accept(this);
+            return new TypeCheckResult(result.isValid(), result.getType());
+        } else if (unary.value != null) {
+            var result = unary.value.accept(this);
+            return new TypeCheckResult(result.isValid(), result.getType());
+        } else if (unary.memberAccess != null) {
+            var result = unary.memberAccess.accept(this);
+            return new TypeCheckResult(result.isValid(), result.getType());
+        } else if (unary.expression != null) {
+            var result = unary.expression.accept(this);
+            return new TypeCheckResult(result.isValid(), result.getType());
         }
-        return new TypeCheckResult(valid, null);
+
+        return new TypeCheckResult(false, null);
+    }
+
+    @Override
+    public TypeCheckResult analyze(MemberAccessNode memberAccessNode) {
+
+        ITypeNode currentType = null;
+
+        for (String s : memberAccessNode.identifiers) {
+            if (currentType == null) {
+                if (currentScope.getLocalVar(s) != null) {
+                    currentType = currentScope.getLocalVar(s);
+
+                } else if (currentFields.get(s) != null) {
+                    currentType = currentFields.get(s);
+                } else {
+                    errors.add(new NotDeclaredException(s + "Not Declared"));
+                    return new TypeCheckResult(false, null);
+                }
+
+            } else {
+                if (currentType instanceof ReferenceType reference) {
+                    var currentTypeClass = context.getClass(reference.getIdentifier());
+
+                    var currentField = currentTypeClass.getField(s);
+                    if (currentField.getAccessModifier().accessType == EnumAccessModifierNode.PUBLIC) {
+                        currentType = currentField.getType();
+                    } else {
+                        errors.add(new NotVisibleException("This field is not visible"));
+                        return new TypeCheckResult(false, null);
+                    }
+                }
+            }
+
+        }
+
+        return new TypeCheckResult(true, currentType);
+    }
+
+    @Override
+    public TypeCheckResult analyze(TargetNode targetNode) {
+
+        if (targetNode.memberAccess != null) {
+            return targetNode.memberAccess.accept(this);
+        }
+        return null;
+    }
+
+    @Override
+    public TypeCheckResult analyze(ValueNode valueNode) {
+
+        switch (valueNode.valueType) {
+            case INT_VALUE -> {
+                return new TypeCheckResult(true, new BaseType(TypeEnum.INT));
+            }
+            case CHAR_VALUE -> {
+                return new TypeCheckResult(true, new BaseType(TypeEnum.CHAR));
+            }
+            case BOOLEAN_VALUE -> {
+                return new TypeCheckResult(true, new BaseType(TypeEnum.BOOL));
+            }
+            default -> {
+                return new TypeCheckResult(false, null);
+            }
+        }
+    }
+
+    private ITypeNode getTypeFromMethod(MethodCallNode toCheck, ReferenceType reference) {
+        var classContext = context.getClass(reference.getIdentifier());
+
+        if (classContext == null) {
+            errors.add(new NotDeclaredException(toCheck.target.identifier + "is not Defined"));
+        } else {
+            var methods = classContext.getMethods();
+            for (var method : methods) {
+                if (toCheck.identifier.equals(method.getIdentifier())) {
+                    if (method.getParameters().size() == toCheck.parameters.size() && !(method instanceof ConstructorNode)) {
+                        boolean same = true;
+                        for (int i = 0; i < method.getParameters().size(); i++) {
+                            var result1 = method.getParameters().get(i).accept(this);
+                            var result2 = toCheck.parameters.get(i).accept(this);
+                            if (!Objects.equals(result1.getType(), result2.getType())) {
+                                same = false;
+                            }
+                        }
+                        if (same) {
+                            if (method.accesModifier.accessType == EnumAccessModifierNode.PUBLIC) {
+                                if (method.getType() == null) {
+                                    return new BaseType(TypeEnum.VOID);
+                                }
+                                return method.getType();
+                            } else {
+                                errors.add(new NotVisibleException("This Method is not Visible"));
+                            }
+                        }
+                    }
+                }
+            }
+            errors.add(new WrongOverloading("No Method found with this parameters"));
+        }
+        return null;
     }
 
 }

src/main/java/semantic/SemanticVisitor.java

@@ -2,6 +2,7 @@ package semantic;
 
 import ast.*;
 import ast.expressions.binaryexpressions.*;
+import ast.expressions.unaryexpressions.MemberAccessNode;
 import ast.expressions.unaryexpressions.UnaryNode;
 import ast.members.*;
 import ast.parameters.ParameterNode;
@@ -11,7 +12,9 @@ import ast.statementexpressions.NewDeclarationNode;
 import ast.statementexpressions.crementexpressions.DecrementNode;
 import ast.statementexpressions.crementexpressions.IncrementNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
+import ast.statementexpressions.methodcallstatementnexpressions.TargetNode;
 import ast.statements.*;
+import ast.type.ValueNode;
 import typechecker.TypeCheckResult;
 
 public interface SemanticVisitor {
@@ -38,8 +41,6 @@ public interface SemanticVisitor {
 
     TypeCheckResult analyze(ElseNode toCheck);
 
-    //TypeCheckResult analyze(ForNode toCheck);
-
     TypeCheckResult analyze(AssignNode toCheck);
 
     TypeCheckResult analyze(DecrementNode toCheck);
@@ -66,4 +67,10 @@ public interface SemanticVisitor {
 
     TypeCheckResult analyze(UnaryNode toCheck);
 
+    TypeCheckResult analyze(MemberAccessNode toCheck);
+
+    TypeCheckResult analyze(TargetNode toCheck);
+
+    TypeCheckResult analyze(ValueNode toCheck);
+
 }

src/main/java/semantic/context/ClassContext.java

@@ -2,11 +2,15 @@ package semantic.context;
 
 import ast.ClassNode;
 import ast.members.FieldNode;
+import ast.members.MethodNode;
+
+import java.util.ArrayList;
 import java.util.HashMap;
 
 public class ClassContext {
 
   private HashMap<String, FieldContext> fields;
+  private ArrayList<MethodNode> methods = new ArrayList<>();
 
   public ClassContext(ClassNode classNode) {
 
@@ -15,6 +19,8 @@ public class ClassContext {
     classNode.members.forEach(member -> {
       if(member instanceof FieldNode fieldNode) {
         fields.put(fieldNode.identifier, new FieldContext(fieldNode));
+      }else if(member instanceof MethodNode methodNode) {
+        methods.add(methodNode);
       }
     });
 
@@ -24,4 +30,8 @@ public class ClassContext {
     return fields.get(name);
   }
 
+  public ArrayList<MethodNode> getMethods() {
+    return methods;
+  }
+
 }

src/main/java/semantic/context/Context.java

@@ -21,4 +21,8 @@ public class Context {
     return classes.get(identifier);
   }
 
+  public boolean containsClass(String identifier) {
+    return classes.containsKey(identifier);
+  }
+
 }

src/main/java/semantic/context/FieldContext.java

@@ -18,4 +18,8 @@ public class FieldContext {
     return type;
   }
 
+  public AccessModifierNode getAccessModifier() {
+    return accessModifier;
+  }
+
 }

src/main/java/semantic/exceptions/NotVisibleException.java

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

src/main/java/semantic/exceptions/WrongOverloading.java

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

src/test/java/parser/AstBuilderTest.java

@@ -1,57 +1,405 @@
 package parser;
 
+
+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.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 static org.junit.jupiter.api.Assertions.assertEquals;
+import java.io.IOException;
+import java.lang.reflect.Member;
 
-public class AstBuilderTest {
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("Untyped Abstract Syntax Tree")
+class AstBuilderTest {
 
     @Test
-    public void astBuilderTest() {
-        // ---------------- Leere Klasse nachgebaut ----------------
+    @DisplayName("Empty Class Test")
+    public void emptyClassTest(){
+        ClassNode emptyClass = Helper.generateEmptyClass("TestClass");
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(emptyClass);
 
-        ProgramNode expectedASTEmptyClass = new ProgramNode();
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/EmptyClass.java");
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
 
-        // public class Name {}
-        ClassNode nameClass = new ClassNode("public", "Name");
+    @Test
+    @DisplayName("Multiple Empty Classes Test")
+    public void multipleEmptyClassesTest() {
+        ClassNode class1 = Helper.generateEmptyClass("TestClass1");
+        ClassNode class2 = Helper.generateEmptyClass("TestClass2");
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+        expected.addClass(class2);
 
-        expectedASTEmptyClass.addClass(nameClass);
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/MultipleClasses.java");
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
 
+    @Test
+    @DisplayName("Empty Class Test with Constructor")
+    public void emptyClassWithConstructorTest() {
+        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
 
-        // ---------------- Leere Klasse erzeugt ----------------
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/EmptyClassWithConstructor.java");
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
 
-        // init
-        CharStream inputCharStream = CharStreams.fromString("public class Name {}");
-        SimpleJavaLexer lexer = new SimpleJavaLexer(inputCharStream);
-        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
-        tokenStream.fill();
+    @Test
+    @DisplayName("Field Test")
+    public void fieldTest() {
+        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        class1.addMember(new FieldNode(null, new BaseType(TypeEnum.INT), "a"));
 
-        /* Parser -> Parsetree */
-        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
-        ParseTree parseTreeEmptyClass = parser.program(); // parse the input
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
 
-        /* AST builder -> AST */
-        ASTBuilder astBuilder = new ASTBuilder();
-        ProgramNode actualASTEmptyClass = (ProgramNode) new ASTBuilder().visit(parseTreeEmptyClass);
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Field.java");
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
 
+    @Test
+    @DisplayName("Field Test with Accessmodifier")
+    public void fieldTestWithModifier() {
+        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
 
-        // ---------------- Vergleichen ----------------
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
 
-        String expectedASTasString = expectedASTEmptyClass.toString();
-        String actualASTasString = new ASTBuilder().visit(parseTreeEmptyClass).toString();
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/FieldWithAccessModifier.java");
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
 
-        // Wie vergleiche ich das?
-        assertEquals(expectedASTasString, actualASTasString);
-        assertEquals(expectedASTEmptyClass, actualASTEmptyClass);
+    @Test
+    @DisplayName("Commments Ignore Test")
+    public void commmentsIgnoreTest(){
+        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        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");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("Constructor Paramerter Test")
+    public void constructorParameterTest(){
+        BlockNode block = new BlockNode();
+        block.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "TestClass", 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");
+        class1.addMember(constructor);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorParameter.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @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", "TestClass", block);
+
+        ClassNode class1 = new ClassNode("public", "TestClass");
+        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");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @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", "TestClass", block);
+        constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+
+        ClassNode class1 = new ClassNode("public", "TestClass");
+        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");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("Void Methoden Test")
+    public void voidMethodenTest(){
+        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        BlockNode block = new BlockNode();
+        block.addStatement(new ReturnNode(null));
+        class1.addMember(new MethodNode("public", null, true, "test", block));
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/VoidMethod.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @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", "TestClass", 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");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(constructor);
+        class1.addMember(method);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorMethodCall.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @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", "TestClass", 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", "TestClass");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(constructor);
+        class1.addMember(method);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/ConstructorMethodCallParameters.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @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", "TestClass", 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", "TestClass");
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.CHAR), "a"));
+        class1.addMember(constructor);
+        class1.addMember(method);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/Char.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @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", "TestClass", blockCon);
+
+        ClassNode class1 = new ClassNode("public", "TestClass");
+        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");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("Self Reference Test")
+    public void selfReferneceTest(){
+
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("Variable Compare Test")
+    public void variableCompareTest(){
+
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("Variable Calculation Test")
+    public void variableCalculationTest(){
+
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("Main Method Test")
+    public void mainMethodTest(){
+
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("While Test")
+    public void whileTest(){
+
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("Do While Test")
+    public void doWhileTest(){
+
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    @Test
+    @DisplayName("For Test")
+    public void forTest(){
+
+        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+    }
+
+    //Noch nicht speziell Increment nur zum Development Testen per Debug
+    @Test
+    @DisplayName("Increment Test")
+    public void incrementTest(){
+        ClassNode classNode = Helper.generateEmptyClass("TestClass");
+        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");
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
 
@@ -65,39 +413,4 @@ public class AstBuilderTest {
 
 
 
-
-
-    // ---------------- Alter CompilerInput nachgebaut ----------------
-    // ProgramNode startNode = new ProgramNode();
-    // public class CompilerInput {}
-    // ClassNode compilerInputClass = new ClassNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), "CompilerInput");
-    // public int a;
-    //  compilerInputClass.addMember(new FieldNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), new BaseTypeNode(EnumTypeNode.INT), "a"));
-    // public static int testMethod(char x) { return 0; }
-      /*  compilerInputClass.addMember(
-                new MethodNode(
-                        new AccessTypeNode(EnumAccessTypeNode.PUBLIC),
-                        new BaseTypeNode(EnumTypeNode.INT),
-                        "testMethod",
-                        new ParameterListNode(List.of(new ParameterNode(new BaseTypeNode(EnumTypeNode.CHAR), "x"))),
-                        List.of(new ReturnStatementNode(new LiteralNode(0)))
-                        ));
-
-        ClassNode testClass = new ClassNode(new AccessTypeNode(EnumAccessTypeNode.PUBLIC), "Test");
-        testClass.addMember(
-                new MethodNode(
-                        new AccessTypeNode(EnumAccessTypeNode.PUBLIC),
-                        new BaseTypeNode(EnumTypeNode.INT),
-                        "testMethod",
-                        new ParameterListNode(List.of(new ParameterNode(new BaseTypeNode(EnumTypeNode.CHAR), "x"), new ParameterNode(new BaseTypeNode(EnumTypeNode.INT), "a"))),
-                        List.of(new ReturnStatementNode(new LiteralNode(0)))
-                )
-        );
-
-       */
-
-    //compilerInputClass.addClass(testClass);
-
-    //  startNode.addClass(compilerInputClass);
-    // startNode.addClass(testClass);
 }

src/test/java/parser/Helper.java

@@ -0,0 +1,47 @@
+package parser;
+
+import ast.ASTNode;
+import ast.ClassNode;
+import ast.ProgramNode;
+import ast.members.ConstructorNode;
+import ast.members.MemberNode;
+import ast.statements.BlockNode;
+import ast.statements.ReturnNode;
+import ast.type.AccessModifierNode;
+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 parser.astBuilder.ASTBuilder;
+import parser.generated.SimpleJavaLexer;
+import parser.generated.SimpleJavaParser;
+
+import java.io.IOException;
+
+public class Helper {
+    public static ASTNode generateAST(String filePath) {
+        CharStream testFile = null;
+        try {
+            testFile = CharStreams.fromFileName(filePath);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(testFile);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+        tokenStream.fill();
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program();
+        ASTBuilder astBuilder = new ASTBuilder();
+
+        return astBuilder.visit(parseTree);
+    }
+
+    public static ClassNode generateEmptyClass(String className) {
+        BlockNode blockNode = new BlockNode();
+        blockNode.addStatement(new ReturnNode(null));
+        MemberNode constructor = new ConstructorNode("public",className, blockNode);
+        ClassNode classNode = new ClassNode("public", className);
+        classNode.addMember(constructor);
+        return classNode;
+    }
+}

src/test/java/semantic/EndToTypedAstTest.java

@@ -26,11 +26,37 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.junit.jupiter.api.Test;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 public class EndToTypedAstTest {
     private static final Map<String, Class<?>> exceptionMap = new HashMap<>();
 
+    @Test
+    public void testOnlyOneFile() {
+        SemanticAnalyzer.clearAnalyzer();
+
+        CharStream codeCharStream = null;
+        try {
+            codeCharStream = CharStreams.fromPath(Paths.get("src/test/resources/input/typedAstFeaturesTests/CorrectTest.java"));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        SimpleJavaLexer lexer = new SimpleJavaLexer(codeCharStream);
+        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
+
+        SimpleJavaParser parser = new SimpleJavaParser(tokenStream);
+        ParseTree parseTree = parser.program(); // parse the input
+
+        /* ------------------------- AST builder -> AST ------------------------- */
+        ASTBuilder astBuilder = new ASTBuilder();
+        ProgramNode abstractSyntaxTree = (ProgramNode) astBuilder.visit(parseTree);
+
+        var result = SemanticAnalyzer.generateTast(abstractSyntaxTree);
+
+        assertTrue(SemanticAnalyzer.errors.isEmpty());
+    }
+
     @Test
     public void exceptionsTest() {
         String directoryPath = "src/test/resources/input/typedAstExceptionsTests";
@@ -88,7 +114,7 @@ public class EndToTypedAstTest {
     }
 
     @Test
-    public void featureTest(){
+    public void featureTest() {
         String directoryPath = "src/test/resources/input/typedAstFeaturesTests";
         File folder = new File(directoryPath);
         if (folder.isDirectory()) {
@@ -115,6 +141,9 @@ public class EndToTypedAstTest {
                     ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree);
 
                     System.out.println("Testing the file: " + file.getName());
+                    for(Exception runtimeException : SemanticAnalyzer.errors){
+                        runtimeException.printStackTrace();
+                    }
                     assertTrue(SemanticAnalyzer.errors.isEmpty());
                     assertNotNull(typedAst);
                 }
@@ -127,9 +156,8 @@ public class EndToTypedAstTest {
     }
 
 
-
-
     // ------------------ Helpers ------------------
+
     /**
      * This method is used to extract the expected exception from a given file.
      * It reads the file line by line and uses a regular expression to match the expected exception annotation.
@@ -158,25 +186,25 @@ public class EndToTypedAstTest {
     }
 
     /**
- * This method is used to retrieve the Class object associated with a given exception name.
- * It first prints the original exception name, then appends the package name to the exception name and prints it.
- * It then retrieves the Class object from the exceptionMap using the fully qualified exception name.
- * If the Class object is not found in the exceptionMap, it throws a RuntimeException.
- *
- * @param exceptionName The name of the exception for which the Class object is to be retrieved.
- * @return The Class object associated with the given exception name.
- * @throws RuntimeException If the Class object for the given exception name is not found in the exceptionMap.
- */
-private Class<?> getExceptionClass(String exceptionName) {
-    System.out.println(exceptionName);
-    exceptionName = "semantic.exceptions." + exceptionName;
-    System.out.println(exceptionName);
-    Class<?> exceptionClass = exceptionMap.get(exceptionName);
-    if (exceptionClass == null) {
-        throw new RuntimeException("Exception class not found: " + exceptionName);
+     * This method is used to retrieve the Class object associated with a given exception name.
+     * It first prints the original exception name, then appends the package name to the exception name and prints it.
+     * It then retrieves the Class object from the exceptionMap using the fully qualified exception name.
+     * If the Class object is not found in the exceptionMap, it throws a RuntimeException.
+     *
+     * @param exceptionName The name of the exception for which the Class object is to be retrieved.
+     * @return The Class object associated with the given exception name.
+     * @throws RuntimeException If the Class object for the given exception name is not found in the exceptionMap.
+     */
+    private Class<?> getExceptionClass(String exceptionName) {
+        System.out.println(exceptionName);
+        exceptionName = "semantic.exceptions." + exceptionName;
+        System.out.println(exceptionName);
+        Class<?> exceptionClass = exceptionMap.get(exceptionName);
+        if (exceptionClass == null) {
+            throw new RuntimeException("Exception class not found: " + exceptionName);
+        }
+        return exceptionClass;
     }
-    return exceptionClass;
-}
 
     /**
      * This method is used to load custom exceptions from a specified package.

src/test/java/semantic/Mocker.java

@@ -1,102 +0,0 @@
-package semantic;
-
-import ast.*;
-import ast.members.FieldNode;
-import ast.members.MethodNode;
-import ast.parameters.ParameterNode;
-import ast.type.AccessModifierNode;
-import ast.type.type.*;
-
-public class Mocker {
-
-    public static ASTNode mockTwoSameFields(){
-        ProgramNode p = new ProgramNode();
-
-        ClassNode c = new ClassNode();
-        c.identifier = "testClass";
-
-        FieldNode f1 = new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a");
-
-        c.members.add(f1);
-
-        FieldNode f2 = new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a");
-
-        c.members.add(f2);
-
-        p.classes.add(c);
-        return p;
-    }
-
-    public static ASTNode mockSimpleMethod(){
-        ProgramNode p = new ProgramNode();
-
-        ClassNode c = new ClassNode();
-
-        MethodNode methodNode = new MethodNode();
-
-        //Parameter
-        ParameterNode parameterNode = new ParameterNode(new BaseType(TypeEnum.INT), "a");
-
-        methodNode.addParameter(parameterNode);
-
-        //Statements
-
-        //Block
-        methodNode.block = new ast.statements.BlockNode();
-
-        c.members.add(methodNode);
-
-        p.classes.add(c);
-
-        return p;
-    }
-
-    public static ASTNode mockTwoSameMethods(){
-        ProgramNode p = new ProgramNode();
-
-        ClassNode c = new ClassNode();
-
-        MethodNode methodNode = new MethodNode();
-        methodNode.block = new ast.statements.BlockNode();
-        methodNode.setType(new BaseType(TypeEnum.INT));
-
-        methodNode.setIdentifier("testMethod");
-
-        c.members.add(methodNode);
-
-        MethodNode methodNode1 = new MethodNode();
-        methodNode1.block = new ast.statements.BlockNode();
-        methodNode1.setType(new BaseType(TypeEnum.INT));
-
-        methodNode1.setIdentifier("testMethod");
-
-        c.members.add(methodNode1);
-
-        p.classes.add(c);
-
-        return p;
-    }
-
-    public static ASTNode mockTwoDifferentMethods(){
-        ProgramNode p = new ProgramNode();
-
-        ClassNode c = new ClassNode();
-
-        MethodNode methodNode = new MethodNode();
-        methodNode.block = new ast.statements.BlockNode();
-        methodNode.setIdentifier("testMethod");
-
-        c.members.add(methodNode);
-
-        MethodNode methodNode1 = new MethodNode();
-        methodNode1.block = new ast.statements.BlockNode();
-        methodNode1.setIdentifier("testMethod1");
-
-        c.members.add(methodNode1);
-
-        p.classes.add(c);
-
-        return p;
-    }
-
-}

src/test/java/semantic/SemanticTest.java

@@ -0,0 +1,113 @@
+package semantic;
+
+public class SemanticTest {
+
+
+    public void test(){
+
+    }
+
+    public void test(int a, boolean b){
+
+    }
+
+    public void test(boolean b, int a){
+
+    }
+
+//    @Test
+//    public void alreadyDeclaredLocalFieldVar() {
+//        ProgramNode programNode = new ProgramNode();
+//        List<ClassNode> classList = new ArrayList<>();
+//        AccessTypeNode accessTypeNode = new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
+//        ClassNode classNode = new ClassNode(accessTypeNode, "testClass");
+//
+//        SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
+//        ASTNode tast = semanticAnalyzer.generateTast(ast);
+//
+//        MemberNode memberNode2 = new FieldNode(accessTypeNode, new BaseTypeNode(EnumTypeNode.INT), "testVar");
+//        classNode.members.add(memberNode2);
+//
+//        classList.add(classNode);
+//        programNode.classes = classList;
+//
+//        ASTNode typedAst = SemanticAnalyzer.generateTast(programNode);
+//
+//        assertEquals(1, SemanticAnalyzer.errors.size());
+//        assertInstanceOf(AlreadyDeclaredException.class, SemanticAnalyzer.errors.getFirst());
+//        assertNull(typedAst);
+//    }
+//
+//    @Test
+//    public void shouldWorkWithNoError() {
+//        ProgramNode programNode = new ProgramNode();
+//        List<ClassNode> classList = new ArrayList<>();
+//        AccessTypeNode accessTypeNode = new AccessTypeNode(EnumAccessTypeNode.PUBLIC);
+//        ClassNode classNode = new ClassNode(accessTypeNode, "testClass");
+//
+//        SemanticAnalyzer semanticAnalyzer = new SemanticAnalyzer();
+//        ASTNode tast = semanticAnalyzer.generateTast(ast);
+//
+//        assertEquals(semanticAnalyzer.errors.size(), 0);
+//        assertNotNull(tast);
+//
+//        MemberNode memberNode3 = getMemberNode(accessTypeNode);
+//        classNode.members.add(memberNode3);
+//
+//        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/javaCases/Char.java

@@ -0,0 +1,12 @@
+class TestClass{
+
+    char a;
+
+    public TestClass(char a){
+        this.a = testMethod(a);
+    }
+
+    char testMethod(char a){
+        return a;
+    }
+}

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

@@ -0,0 +1,8 @@
+/*
+
+    Mutliple Line Comment. Ignore
+
+ */
+class TestClass{
+    private int a; // Ignore
+}

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

@@ -0,0 +1,12 @@
+class TestClass {
+
+    int a;
+
+    public TestClass(){
+        this.a = testMethod();
+    }
+
+    int testMethod(){
+        return 1;
+    }
+}

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

@@ -0,0 +1,12 @@
+class TestClass {
+
+    int a;
+
+    public TestClass(int a){
+        this.a = testMethod(a);
+    }
+
+    int testMethod(int a){
+        return a;
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,34 @@
+class TestClass{
+
+    int aPlusB(int a, int b){
+        return a + b;
+    }
+
+    int aMinusB(int a, int b){
+        return a - b;
+    }
+
+    int aTimeB(int a, int b){
+        return a * b;
+    }
+
+    int aDivB(int a, int b){
+        return a / b;
+    }
+
+    int colmplexCalc (int a, int b){
+        return a * (b / 1);
+    }
+
+    boolean aSmallerB (int a, int b){
+        return a < b;
+    }
+
+    boolean aGreaterB (int a, int b){
+        return a > b;
+    }
+
+    boolean aEqualsB (int a, int b){
+        return a == b;
+    }
+}

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

@@ -0,0 +1,30 @@
+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/typedAstExceptionsTests/BothTypesMustBeSame1.java

@@ -0,0 +1,9 @@
+// @expected: TypeMismatchException
+public class AllFeaturesClassExample {
+
+    public void controlStructures(int a, boolean bool) {
+        while (a > bool) {
+            a--;
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+// @expected: TypeMismatchException
+public class Test{
+
+    public void test(boolean b){
+        if(b == 2){
+
+        } else {
+
+        }
+
+    }
+
+}

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

@@ -0,0 +1,20 @@
+// @expected: NotVisibleException
+public class Test{
+
+    public Car c;
+
+    public int test(){
+        return c.speed;
+    }
+
+}
+
+public class Car{
+
+    private int speed;
+
+    public int getSpeed(){
+        return speed;
+    }
+
+}

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

@@ -0,0 +1,14 @@
+// @expected: TypeMismatchException
+public class Test{
+
+    public void test(int x){
+
+        if(x){
+
+        } else {
+
+        }
+
+    }
+
+}

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

@@ -0,0 +1,21 @@
+// @expected: NotVisibleException
+public class Test {
+
+    public int firstInt;
+    public Car ca;
+
+    public int speed(){
+        return ca.getSpeed();
+    }
+
+}
+
+public class Car{
+
+    private int speed;
+
+    private int getSpeed(){
+        return speed;
+    }
+
+}

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

@@ -0,0 +1,19 @@
+// @expected: WrongOverloading
+public class Test{
+
+    public void test(int x){
+
+        if(this.get()){
+
+        } else {
+
+        }
+
+    }
+    public boolean b;
+
+    public boolean get(int c){
+        return b;
+    }
+
+}

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

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

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

@@ -0,0 +1,22 @@
+// @expected: TypeMismatchException
+public class Test{
+
+    public int i;
+    public boolean b;
+
+    public int test(){
+
+        return this.test(i);
+
+    }
+
+    public void test(int a){
+
+    }
+
+    public int test(boolean bool){
+        int ret = 1;
+        return ret;
+    }
+
+}

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

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

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

@@ -0,0 +1,20 @@
+public class Test {
+
+    public int firstInt;
+    public Car ca;
+
+    public int speed(){
+        return ca.getSpeed();
+    }
+
+}
+
+public class Car{
+
+    private int speed;
+
+    public int getSpeed(){
+        return speed;
+    }
+
+}

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

@@ -0,0 +1,19 @@
+public class Test{
+
+    public Car c;
+
+    public int test(){
+        return c.getSpeed();
+    }
+
+}
+
+public class Car{
+
+    private int speed;
+
+    public int getSpeed(){
+        return speed;
+    }
+
+}

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

@@ -0,0 +1,18 @@
+public class Test{
+
+    public void test(int x){
+
+        if(this.get(x)){
+
+        } else {
+
+        }
+
+    }
+    public boolean b;
+
+    public boolean get(int c){
+        return b;
+    }
+
+}

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

@@ -0,0 +1,12 @@
+public class Test{
+
+    public void test(boolean b){
+        if(b == true){
+
+        } else {
+  
+        }
+
+    }
+
+}

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

@@ -1,18 +1,38 @@
-public class Example {
-
-    public int a;
-
-    public static int testMethod(int b, boolean bo){
-        a = b;
-        if(bo){
+public class AllFeaturesClassExample {
+    int a;
+    boolean b;
+    char c;
 
+    public void controlStructures(int adf, boolean bool) {
+        if (a > (10 + 8)) {
+        } else {
         }
-        return a;
+
+
+        while (a > adf) {
+            a--;
+        }
+
+        for (int i = 0; i < 5; i++) {
+        }
+
 
     }
 
-    public static void testMethod(int b){
+//    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");
+//        }
+//    }
 
+//    public static void main(String[] args) {
+//        AllFeaturesClassExample obj = new AllFeaturesClassExample(12, true, 'a');
+//        obj.controlStructures();
+//    }
 }

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

@@ -0,0 +1,64 @@
+
+public class AllFeaturesClassExample {
+    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++) {
+        }
+
+
+    }
+
+//    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");
+//        }
+//    }
+
+//    public static void main(String[] args) {
+//        AllFeaturesClassExample obj = new AllFeaturesClassExample(12, true, 'a');
+//        obj.controlStructures();
+//    }
+}
+
+public class Test {
+
+    public Car c;
+
+    public int test(boolean b, int x) {
+        if (b == true) {
+            return c.getSpeed();
+        } else {
+            return x;
+        }
+    }
+
+}
+
+public class Car {
+
+    private int speed;
+
+    public int getSpeed() {
+        return speed;
+    }
+
+}
+

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

@@ -0,0 +1,13 @@
+public class Car{
+
+    public void test(boolean boo){
+
+        if(boo){
+
+        } else {
+
+        }
+
+    }
+
+}

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

@@ -0,0 +1,13 @@
+public class Car{
+
+    public int getSpeed(boolean bool, int a, int b){
+
+        if(bool){
+            return a;
+        } else {
+            return b;
+        }
+
+    }
+
+}

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

@@ -0,0 +1,21 @@
+public class Test{
+
+    public int i;
+    public boolean b;
+
+    public int test(){
+
+        return this.test(b);
+
+    }
+
+    public void test(int a){
+
+    }
+
+    public int test(boolean bool){
+        int ret = 1;
+        return ret;
+    }
+
+}

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

@@ -0,0 +1,13 @@
+public class Car{
+
+    private int speed;
+
+    public int getSpeed(){
+        return speed;
+    }
+
+    public int test(){
+        return this.getSpeed();
+    }
+
+}

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

@@ -0,0 +1,13 @@
+public class Car{
+
+    private int speed;
+
+    public void getSpeed(boolean boo){
+        if(boo){
+
+        } else {
+
+        }
+    }
+
+}