diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index 712ab9d..35e8b50 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -6,6 +6,11 @@
+
+
+
+
+
diff --git a/pom.xml b/pom.xml
index 99e9904..e32826e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -44,6 +44,12 @@
3.26.0
test
+
+ org.mockito
+ mockito-core
+ 5.11.0
+ test
+
@@ -78,4 +84,11 @@
+
+
+ maven_central
+ Maven Central
+ https://repo.maven.apache.org/maven2/
+
+
\ No newline at end of file
diff --git a/src/test/java/main/E2E_Reflections_Test.java b/src/test/java/main/E2E_Reflections_Test.java
new file mode 100644
index 0000000..8b13819
--- /dev/null
+++ b/src/test/java/main/E2E_Reflections_Test.java
@@ -0,0 +1,70 @@
+package main;
+
+import ast.ASTNode;
+import ast.ProgramNode;
+import bytecode.ByteCodeGenerator;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.antlr.v4.runtime.CharStream;
+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 semantic.SemanticAnalyzer;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+public class E2E_Reflections_Test {
+
+
+ private CharStream mockInputCharStream;
+ private String outputDirectoryPath;
+
+ @BeforeEach
+ public void setUp() {
+ mockInputCharStream = mock(CharStream.class);
+ outputDirectoryPath = "path/to/output";
+ }
+
+ @Test
+ public void testCompileFile() throws Exception {
+ // Mock the dependencies
+ SimpleJavaLexer mockLexer = mock(SimpleJavaLexer.class);
+ CommonTokenStream mockTokenStream = mock(CommonTokenStream.class);
+ SimpleJavaParser mockParser = mock(SimpleJavaParser.class);
+ ParseTree mockParseTree = mock(ParseTree.class);
+ ASTBuilder mockASTBuilder = mock(ASTBuilder.class);
+ ASTNode mockASTNode = mock(ASTNode.class);
+ SemanticAnalyzer mockSemanticAnalyzer = mock(SemanticAnalyzer.class);
+ ASTNode mockTypedAST = mock(ASTNode.class);
+ ByteCodeGenerator mockByteCodeGenerator = mock(ByteCodeGenerator.class);
+
+ // Mock the behavior
+ when(mockLexer.nextToken()).thenReturn(null);
+ when(mockTokenStream.getTokens()).thenReturn(new ArrayList<>());
+ when(mockParser.program()).thenReturn((SimpleJavaParser.ProgramContext) mockParseTree);
+ when(mockASTBuilder.visit(mockParseTree)).thenReturn(mockASTNode);
+ when(mockSemanticAnalyzer.generateTast(mockASTNode)).thenReturn(mockTypedAST);
+
+ // Use reflection to invoke the compileFile method
+ Method compileFileMethod = main.Main.class.getDeclaredMethod("compileFile", CharStream.class, String.class);
+ compileFileMethod.setAccessible(true);
+
+ compileFileMethod.invoke(null, mockInputCharStream, outputDirectoryPath);
+
+ // Verify each step
+ verify(mockLexer, times(1)).nextToken();
+ verify(mockTokenStream, times(1)).getTokens();
+ verify(mockParser, times(1)).program();
+ verify(mockASTBuilder, times(1)).visit(mockParseTree);
+ verify(mockSemanticAnalyzer, times(1)).generateTast(mockASTNode);
+ verify(mockByteCodeGenerator, times(1)).visit((ProgramNode) mockTypedAST);
+ }
+}
+
diff --git a/src/test/java/semantic/Mocker.java b/src/test/java/semantic/Mocker.java
deleted file mode 100644
index 1e404af..0000000
--- a/src/test/java/semantic/Mocker.java
+++ /dev/null
@@ -1,103 +0,0 @@
-package semantic;
-
-import ast.*;
-import ast.block.BlockNode;
-import ast.member.FieldNode;
-import ast.member.MethodNode;
-import ast.parameter.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 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 BlockNode();
- methodNode.setType(new BaseType(TypeEnum.INT));
-
- methodNode.setIdentifier("testMethod");
-
- c.members.add(methodNode);
-
- MethodNode methodNode1 = new MethodNode();
- methodNode1.block = new 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 BlockNode();
- methodNode.setIdentifier("testMethod");
-
- c.members.add(methodNode);
-
- MethodNode methodNode1 = new MethodNode();
- methodNode1.block = new BlockNode();
- methodNode1.setIdentifier("testMethod1");
-
- c.members.add(methodNode1);
-
- p.classes.add(c);
-
- return p;
- }
-
-}
diff --git a/src/test/java/semantic/SemanticTest.java b/src/test/java/semantic/SemanticTest.java
deleted file mode 100644
index a4039ac..0000000
--- a/src/test/java/semantic/SemanticTest.java
+++ /dev/null
@@ -1,101 +0,0 @@
-package semantic;
-
-public class SemanticTest {
-
-
-// @Test
-// public void alreadyDeclaredLocalFieldVar() {
-// ProgramNode programNode = new ProgramNode();
-// List 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 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 parameterNodeList = new ArrayList<>();
-// ParameterNode parameterNode1 = new ParameterNode(new BaseTypeNode(EnumTypeNode.INT), "param1");
-// parameterNodeList.add(parameterNode1);
-// ParameterListNode parameterListNode = new ParameterListNode(parameterNodeList);
-//
-// List 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);
-//}
-}