cleaned a bit and added implementation in CodegeneratorTests which executes all the codeGen tests

pom.xml

@@ -81,6 +81,12 @@
             <version>4.13.1</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-launcher</artifactId>
+            <version>1.10.2</version>
+            <scope>test</scope>
+        </dependency>
         <!-- JUnit 5 end -->
         <dependency>
             <groupId>commons-cli</groupId>

src/test/java/CodegeneratorTests.java

@@ -1,15 +1,14 @@
-import de.maishai.Compiler;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.junit.runner.RunWith;
+import org.junit.platform.commons.support.HierarchyTraversalMode;
-import org.junit.runners.Suite;
+import org.junit.platform.commons.support.ReflectionSupport;
-import testResources.CodeGen.BytecodeTestUtil;
 import testResources.CodeGen.Features.*;
 
+import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class CodegeneratorTests {
 
@@ -30,21 +29,164 @@ public class CodegeneratorTests {
 //        });
 //    }
 
-//    @Test
+    @Test
-//    public void testBreak() {
+    public void runByteCodeBreakTests() {
-//        ByteCode_Break ByteCode_Break = new ByteCode_Break();
+        runByteCodeTests(ByteCode_Break.class);
-//        Assertions.assertTrue(ByteCode_Break.allTestsSuccessful());
+    }
-//    }
 
-//    @Test
+    @Test
-//    public void testClass() {
+    public void runByteCodeClassTests() {
-//        ByteCode_Class ByteCode_Class = new ByteCode_Class();
+        runByteCodeTests(ByteCode_Class.class);
-//        Assertions.assertTrue(ByteCode_Class.allTestsSuccessful());
+    }
-//    }
 
-//    @Test
+    @Test
-//    public void testClassObjects() {
+    public void runByteCodeClassObjectsTests() {
-//        ByteCode_ClassObjects ByteCode_ClassObjects = new ByteCode_ClassObjects();
+        runByteCodeTests(ByteCode_ClassObjects.class);
-//        Assertions.assertTrue(ByteCode_ClassObjects.allTestsSuccessful());
+    }
-//    }
+
-}
+    @Test
+    public void runByteCodeCommentTests() {
+        runByteCodeTests(ByteCode_Comment.class);
+    }
+
+    @Test
+    public void runByteCodeCompAssignTests() {
+        runByteCodeTests(ByteCode_CompAssign.class);
+    }
+
+    @Test
+    public void runByteCodeComplexCallsTests() {
+        runByteCodeTests(ByteCode_ComplexCalls.class);
+    }
+
+    @Test
+    public void runByteCodeConstructorTests() {
+        runByteCodeTests(ByteCode_Constructor.class);
+    }
+
+    @Test
+    public void runByteCodeContinueTests() {
+        runByteCodeTests(ByteCode_Continue.class);
+    }
+
+    @Test
+    public void runByteCodeDataTypesTests() {
+        runByteCodeTests(ByteCode_DataTypes.class);
+    }
+
+    @Test
+    public void runByteCodeFieldTests() {
+        runByteCodeTests(ByteCode_Field.class);
+    }
+
+    @Test
+    public void runByteCodeForTests() {
+        runByteCodeTests(ByteCode_For.class);
+    }
+
+    @Test
+    public void runByteCodeIfTests() {
+        runByteCodeTests(ByteCode_If.class);
+    }
+
+    @Test
+    public void runByteCodeLogicExprTests() {
+        runByteCodeTests(ByteCode_LogicExpr.class);
+    }
+
+    @Test
+    public void runByteCodeMainTests() {
+        runByteCodeTests(ByteCode_Main.class);
+    }
+
+    @Test
+    public void runByteCodeMethodTests() {
+        runByteCodeTests(ByteCode_Method.class);
+    }
+
+    @Test
+    public void runByteCodeMethodCallTests() {
+        runByteCodeTests(ByteCode_MethodCall.class);
+    }
+
+    @Test
+    public void runByteCodeMultipleClassesTests() {
+        runByteCodeTests(ByteCode_MultipleClasses.class);
+    }
+
+    @Test
+    public void runByteCodeOperatorsTests() {
+        runByteCodeTests(ByteCode_Operators.class);
+    }
+
+    @Test
+    public void runByteCodeOverloadedTests() {
+        runByteCodeTests(ByteCode_Overloaded.class);
+    }
+
+    @Test
+    public void runByteCodePrintTests() {
+        runByteCodeTests(ByteCode_Print.class);
+    }
+
+    @Test
+    public void runByteCodeReturnTests() {
+        runByteCodeTests(ByteCode_Return.class);
+    }
+
+    @Test
+    public void runByteCodeUnaryTests() {
+        runByteCodeTests(ByteCode_Unary.class);
+    }
+
+    @Test
+    public void runByteCodeVariableDefWithDeclTests() {
+        runByteCodeTests(ByteCode_VariableDefWithDecl.class);
+    }
+
+    @Test
+    public void runByteCodeWhileTests() {
+        runByteCodeTests(ByteCode_While.class);
+    }
+
+
+    private void runByteCodeTests(Class<?> testClass) {
+        List<String> failedTests = new ArrayList<>();
+
+        // Finde alle Methoden, die mit @Test annotiert sind
+        List<Method> testMethods = ReflectionSupport.findMethods(
+                testClass,
+                method -> method.isAnnotationPresent(Test.class),
+                HierarchyTraversalMode.TOP_DOWN
+        );
+
+        for (Method testMethod : testMethods) {
+            try {
+                // Erstelle eine Instanz der Testklasse
+                Object testInstance = ReflectionSupport.newInstance(testClass);
+
+                // Führe die Setup-Methode aus (falls vorhanden)
+                Optional<Method> setUpMethodOptional = ReflectionSupport.findMethod(testClass, "setUp");
+                if (setUpMethodOptional.isPresent()) {
+                    setUpMethodOptional.get().invoke(testInstance);
+                }
+
+                // Führe die Testmethode aus
+                testMethod.invoke(testInstance);
+            } catch (Exception e) {
+                if (e.getCause() != null) {
+                    failedTests.add(testMethod.getName() + ": " + e.getCause().getMessage());
+                } else {
+                    failedTests.add(testMethod.getName() + ": " + e.getMessage());
+                }
+            }
+        }
+
+            if (!failedTests.isEmpty()) {
+            failedTests.forEach(System.err::println);
+            Assertions.fail("Ein oder mehrere Tests sind fehlgeschlagen.");
+        } else {
+            System.out.println("Alle Tests sind erfolgreich.");
+        }
+    }
+}

src/test/java/ScannerParserTests.java

@@ -7,7 +7,7 @@ import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-class ScannerParserTests {
+public class ScannerParserTests {
 //
 //    @Test
 //    public void testPublicClass() {
@@ -74,146 +74,148 @@ class ScannerParserTests {
     // Feature Tests
 
     @Test
-    void testBreak() {
+    public void testBreak() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Break.java"));
         assertEquals(AST_Break.get(), resultAst);
     }
 
     @Test
-    void testClass() {
+    public void testClass() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Class.java"));
         assertEquals(AST_Class.get(), resultAst);
     }
 
     @Test
-    void testClassObjects() {
+    public void testClassObjects() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/ClassObjects.java"));
         assertEquals(AST_ClassObjects.get(), resultAst);
     }
     //TODO: nochmal drüberschauen, nachfragen wegen true/false bei FieldVarAccess
 
     @Test
-    void testComment() {
+    public void testComment() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Comment.java"));
         assertEquals(AST_Comment.get(), resultAst);
     }
 
     @Test
-    void testCompAssign() {
+    public void testCompAssign() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/CompAssign.java"));
         assertEquals(AST_CompAssign.get(), resultAst);
     }
 
     @Test
-    void testComplexCalls() {
+    public void testComplexCalls() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/ComplexCalls.java"));
         assertEquals(AST_ComplexCalls.get(), resultAst);
     }
 
     @Test
-    void testConstructor() {
+    public void testConstructor() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Constructor.java"));
         assertEquals(AST_Constructor.get(), resultAst);
     }
 
     @Test
-    void testContinue() {
+    public void testContinue() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Continue.java"));
         assertEquals(AST_Continue.get(), resultAst);
     }
 
     @Test
-    void testDataTypes() {
+    public void testDataTypes() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/DataTypes.java"));
         assertEquals(AST_DataTypes.get(), resultAst);
     }
 
     @Test
-    void testField() {
+    public void testField() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Field.java"));
         assertEquals(AST_Field.get(), resultAst);
     }
 
     @Test
-    void testFor() {
+    public void testFor() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/For.java"));
         assertEquals(AST_For.get(), resultAst);
     }
 
     @Test
-    void testIf() {
+    public void testIf() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/If.java"));
         assertEquals(AST_If.get(), resultAst);
     }
 
     @Test
-    void testLogicExpr() {
+    public void testLogicExpr() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/LogicExpr.java"));
         assertEquals(AST_LogicExpr.get(), resultAst);
     }
 
     @Test
-    void testMain() {
+    public void testMain() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Main.java"));
         assertEquals(AST_Main.get(), resultAst);
     }
 
     @Test
-    void testMethod() {
+    public void testMethod() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Method.java"));
         assertEquals(AST_Method.get(), resultAst);
     }
 
     @Test
-    void testMethodCall() {
+    public void testMethodCall() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/MethodCall.java"));
         assertEquals(AST_MethodCall.get(), resultAst);
     }
 
     @Test
-    void testMultipleClasses() {
+    public void testMultipleClasses() {
-        Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses.java"));
+        Program resultAst = Compiler.generateASTFromFiles(
+                List.of("src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses1.java",
+                        "src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses2.java"));
         assertEquals(AST_MultipleClasses.get(), resultAst);
     }
 
     @Test
-    void testOperators() {
+    public void testOperators() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Operators.java"));
         assertEquals(AST_Operators.get(), resultAst);
     }
 
     @Test
-    void testOverloaded() {
+    public void testOverloaded() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Overloaded.java"));
         assertEquals(AST_Overloaded.get(), resultAst);
     }
 
     @Test
-    void testPrint() {
+    public void testPrint() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Print.java"));
         assertEquals(AST_Print.get(), resultAst);
     }
 
     @Test
-    void testReturn() {
+    public void testReturn() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Return.java"));
         assertEquals(AST_Return.get(), resultAst);
     }
 
     @Test
-    void testUnary() {
+    public void testUnary() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Unary.java"));
         assertEquals(AST_Unary.get(), resultAst);
     }
 
     @Test
-    void testVariableDefWithDecl() {
+    public void testVariableDefWithDecl() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/VariableDefWithDecl.java"));
         assertEquals(AST_VariableDefWithDecl.get(), resultAst);
     }
 
     @Test
-    void testWhile() {
+    public void testWhile() {
         Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/While.java"));
         assertEquals(AST_While.get(), resultAst);
     }

src/test/java/TypingTests.java

@@ -1,15 +1,8 @@
 import de.maishai.Compiler;
 import de.maishai.typedast.typedclass.TypedProgram;
-import jdk.jshell.spi.ExecutionControl;
 import org.junit.jupiter.api.Test;
 import testResources.TypedAST.TypedASTFeatures.*;
 import testResources.AST.ASTFeatures.*;
-import testResources.AST.ASTMore.AbstractSyntax_ClassWithConstructor;
-import testResources.AST.ASTMore.AbstractSyntax_ClassWithField;
-import testResources.AST.ASTMore.AbstractSyntax_PublicClass;
-import testResources.TypedAST.TypedASTMore.TypedAbstractSyntax_ClassWithConstructor;
-import testResources.TypedAST.TypedASTMore.TypedAbstractSyntax_ClassWithField;
-import testResources.TypedAST.TypedASTMore.TypedAbstractSyntax_PublicClass;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
@@ -121,14 +114,12 @@ public class TypingTests {
         TypedProgram resultTypedAst = Compiler.generateTypedASTFromAst(AST_LogicExpr.get());
         assertEquals(TypedAST_LogicExpr.get(), resultTypedAst);
     }
-    // TODO: mit Operatoren verknüpfte Typen werden nicht korrekt ermittelt
 
     @Test
     public void testMain() {
         TypedProgram resultTypedAst = Compiler.generateTypedASTFromAst(AST_Main.get());
         assertEquals(TypedAST_Main.get(), resultTypedAst);
     }
-    // TODO: Wie soll das Resultat aussehen? Soll tatsächlich main auch als Methode aufgeführt werden?
 
     @Test
     public void testMethod() {
@@ -177,7 +168,6 @@ public class TypingTests {
         TypedProgram resultTypedAst = Compiler.generateTypedASTFromAst(AST_Unary.get());
         assertEquals(TypedAST_Unary.get(), resultTypedAst);
     }
-    // TODO: Typ von TypedUnary wird nicht ermittelt
 
     @Test
     public void testVariableDefWithDecl() {
@@ -191,9 +181,4 @@ public class TypingTests {
         assertEquals(TypedAST_While.get(), resultTypedAst);
     }
 
-    //TODO: Anschauen:  Konstruktor hat doch immer den Typ der Klasse?
-    //                  bei logischen Ausdrücken hat einer keinen boolschen Typ
-    //                  In Methoden und Konstruktoren werden Parameter zusätzlich als TypedLocalVariable aufgeführt, warum?
-    //                  bei TypedUnary wird nicht der Typ ermittelt
-
 }

src/test/java/testResources/AST/ASTFeatures/AST_MultipleClasses.java

@@ -11,18 +11,39 @@ public class AST_MultipleClasses {
         return new Program(
                 List.of(
                         new Class(
-                                "MultipleClasses",
+                                "MultipleClasses1",
                                 null,
                                 List.of(
                                         new Declaration(
                                                 "anotherClass",
-                                                Type.REFERENCE("AnotherClass")
+                                                Type.REFERENCE("MultipleClasses2")
+                                        )
+                                ),
+                                List.of(
+                                        new Method(
+                                                Type.INT,
+                                                "getIFromAnotherClass",
+                                                List.of(),
+                                                new Block(
+                                                        List.of(
+                                                                new Return(
+                                                                        new FieldVarAccess(
+                                                                                true,
+                                                                                new FieldVarAccess(
+                                                                                        true,
+                                                                                        null,
+                                                                                        "anotherClass"
+                                                                                ),
+                                                                                "i"
+                                                                        )
+                                                                )
+                                                        )
+                                                )
                                         )
                                 ),
-                                List.of(),
                                 List.of(
                                         new Constructor(
-                                                "MultipleClasses",
+                                                "MultipleClasses1",
                                                 List.of(),
                                                 new Block(
                                                         List.of(
@@ -33,7 +54,7 @@ public class AST_MultipleClasses {
                                                                                 "anotherClass"
                                                                         ),
                                                                         new New(
-                                                                                Type.REFERENCE("AnotherClass"),
+                                                                                Type.REFERENCE("MultipleClasses2"),
                                                                                 List.of()
                                                                         )
                                                                 )
@@ -43,18 +64,18 @@ public class AST_MultipleClasses {
                                 )
                         ),
                         new Class(
-                                "AnotherClass",
+                                "MultipleClasses2",
                                 null,
                                 List.of(
                                         new Declaration(
-                                                "multipleClasses",
+                                                "i",
-                                                Type.REFERENCE("MultipleClasses")
+                                                Type.INT
                                         )
                                 ),
                                 List.of(),
                                 List.of(
                                         new Constructor(
-                                                "AnotherClass",
+                                                "MultipleClasses2",
                                                 List.of(),
                                                 new Block(
                                                         List.of(
@@ -62,12 +83,9 @@ public class AST_MultipleClasses {
                                                                         new FieldVarAccess(
                                                                                 true,
                                                                                 null,
-                                                                                "multipleClasses"
+                                                                                "i"
                                                                         ),
-                                                                        new New(
+                                                                        new IntLiteral(4)
-                                                                                Type.REFERENCE("MultipleClasses"),
-                                                                                List.of()
-                                                                        )
                                                                 )
                                                         )
                                                 )

src/test/java/testResources/CodeGen/Features/ByteCode_Break.java

@@ -1,6 +1,5 @@
 package testResources.CodeGen.Features;
 
-import de.maishai.typedast.Type;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;

src/test/java/testResources/CodeGen/Features/ByteCode_ClassObjects.java

@@ -7,7 +7,7 @@ import testResources.CodeGen.BytecodeTestUtil;
 
 import java.util.List;
 
-class ByteCode_ClassObjects {
+public class ByteCode_ClassObjects {
 
     private BytecodeTestUtil util;
 
@@ -20,48 +20,47 @@ class ByteCode_ClassObjects {
         }
     }
 
-
     @Test
-    void testConstructorCount() {
+    public void testConstructorCount() {
         Assertions.assertEquals(2, util.getConstructorCount());
     }
 
     @Test
-    void testConstructor1() {
+    public void testConstructor1() {
         Assertions.assertEquals("ClassObjects", util.getConstructorNames().get(0));
         Assertions.assertEquals(0, util.getConstructorParameterCount(0));
     }
 
     @Test
-    void testConstructor2() {
+    public void testConstructor2() {
         Assertions.assertEquals("ClassObjects", util.getConstructorNames().get(1));
         Assertions.assertEquals(1, util.getConstructorParameterCount(1));
     }
 
 
     @Test
-    void testMethodCount() {
+    public void testMethodCount() {
         Assertions.assertEquals(1, util.getMethodCount());
     }
 
     @Test
-    void testMethodNames() {
+    public void testMethodNames() {
-        Assertions.assertEquals("objectsMethod", util.getMethodNames().get(0));
+        Assertions.assertTrue(util.getMethodNames().contains("objectsMethod"));
     }
 
     @Test
-    void testMethodReturnType() {
+    public void testMethodReturnType() {
         try {
-            Assertions.assertEquals("void", util.getMethodReturnType("objectsMethod", new Class<?>[]{}));
+            Assertions.assertEquals("void", util.getMethodReturnType("objectsMethod"));
         } catch (Exception e) {
             Assertions.fail();
         }
     }
 
     @Test
-    void testMethodParameters() {
+    public void testMethodParameters() {
         try {
-            Assertions.assertEquals(0, util.getMethodParameterCount("objectsMethod", new Class<?>[]{}));
+            Assertions.assertEquals(0, util.getMethodParameterCount("objectsMethod"));
         } catch (Exception e) {
             Assertions.fail();
         }
@@ -69,26 +68,26 @@ class ByteCode_ClassObjects {
 
 
     @Test
-    void testFieldCount() {
+    public void testFieldCount() {
         Assertions.assertEquals(3, util.getFieldCount());
     }
 
     @Test
-    void testFieldNames() {
+    public void testFieldNames() {
         Assertions.assertEquals("object", util.getFieldNames().get(0));
         Assertions.assertEquals("objectWithValue", util.getFieldNames().get(1));
         Assertions.assertEquals("integerValue", util.getFieldNames().get(2));
     }
 
     @Test
-    void testFieldTypes() {
+    public void testFieldTypes() {
         Assertions.assertEquals("ClassObjects", util.getFieldTypes().get(0));
         Assertions.assertEquals("ClassObjects", util.getFieldTypes().get(1));
         Assertions.assertEquals("int", util.getFieldTypes().get(2));
     }
 
     @Test
-    void testFieldValues() {
+    public void testFieldValues() {
         try {
             Assertions.assertNull(util.getFieldValue("object"));
             Assertions.assertNull(util.getFieldValue("objectWithValue"));
@@ -100,9 +99,9 @@ class ByteCode_ClassObjects {
 
 
     @Test
-    void testInvokeConstructor1() {
+    public void testInvokeConstructor1() {
         try {
-            Object constructor1ReturnValue = util.invokeConstructor(new Class<?>[]{}, new Object[]{});
+            Object constructor1ReturnValue = util.invokeConstructor(new Class<?>[]{});
             Assertions.assertEquals("ClassObjects", constructor1ReturnValue.getClass().getName());
             Assertions.assertNull(util.getFieldValueOfObject(constructor1ReturnValue, "object"));
             Assertions.assertNull(util.getFieldValueOfObject(constructor1ReturnValue, "objectWithValue"));
@@ -114,9 +113,9 @@ class ByteCode_ClassObjects {
     }
 
     @Test
-    void testInvokeConstructor2() {
+    public void testInvokeConstructor2() {
         try {
-            Object constructor2ReturnValue = util.invokeConstructor(new Class<?>[]{int.class}, new Object[]{2});
+            Object constructor2ReturnValue = util.invokeConstructor(new Class<?>[]{int.class}, 2);
             Assertions.assertEquals("ClassObjects", constructor2ReturnValue.getClass().getName());
             Assertions.assertNull(util.getFieldValueOfObject(constructor2ReturnValue, "object"));
             Assertions.assertNull(util.getFieldValueOfObject(constructor2ReturnValue, "objectWithValue"));
@@ -128,7 +127,7 @@ class ByteCode_ClassObjects {
     }
 
     @Test
-    void testInvokeMethod() {
+    public void testInvokeMethod() {
         try {
             Object fieldObject = util.getFieldValue("object");
             Object fieldObjectWithValue = util.getFieldValue("objectWithValue");

src/test/java/testResources/CodeGen/Features/ByteCode_If.java

@@ -1,7 +1,5 @@
 package testResources.CodeGen.Features;
 
-import de.maishai.typedast.Type;
-import de.maishai.typedast.typedclass.*;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -93,7 +91,7 @@ public class ByteCode_If {
         try {
             int returnValue = (int) util.invokeMethod("ifMethod",
                     new Class<?>[]{boolean.class, boolean.class}, true, true);
-            Assertions.assertEquals(1, returnValue);
+            Assertions.assertEquals(6, returnValue);
         } catch (Exception e) {
             Assertions.fail();
         }

src/test/java/testResources/CodeGen/Features/ByteCode_Operators.java

@@ -172,7 +172,7 @@ public class ByteCode_Operators {
     public void testDotBeforeLine() {
         try {
             Object result = util.invokeMethod("dotBeforeLine", new Class<?>[]{int.class, int.class}, new Object[]{5, 3});
-            Assertions.assertEquals(20, result);
+            Assertions.assertEquals(19, result);
         } catch (Exception e) {
             Assertions.fail();
         }

src/test/java/testResources/TypedAST/TypedASTFeatures/TypedAST_MultipleClasses.java

@@ -10,33 +10,33 @@ public class TypedAST_MultipleClasses {
         return new TypedProgram(
                 List.of(
                         new TypedClass(
-                                "MultipleClasses",
+                                "MultipleClasses1",
                                 List.of(
                                         new TypedDeclaration(
                                                 "anotherClass",
-                                                Type.REFERENCE("AnotherClass")
+                                                Type.REFERENCE("MultipleClasses2")
                                         )
                                 ),
                                 List.of(),
                                 List.of(
                                         new TypedConstructor(
-                                                "MultipleClasses",
+                                                "MultipleClasses1",
                                                 List.of(),
                                                 new TypedBlock(
                                                         List.of(),
                                                         List.of(
                                                                 new TypedAssignment(
                                                                         new TypedNew(
-                                                                                Type.REFERENCE("AnotherClass"),
+                                                                                Type.REFERENCE("MultipleClasses2"),
                                                                                 List.of()
                                                                         ),
                                                                         new TypedFieldVarAccess(
                                                                                 true,
                                                                                 null,
                                                                                 "anotherClass",
-                                                                                Type.REFERENCE("AnotherClass")
+                                                                                Type.REFERENCE("MultipleClasses2")
                                                                         ),
-                                                                        Type.REFERENCE("AnotherClass")
+                                                                        Type.REFERENCE("MultipleClasses2")
                                                                 )
                                                         ),
                                                         Type.VOID
@@ -48,36 +48,36 @@ public class TypedAST_MultipleClasses {
                                 null,
                                 null,
                                 null,
-                                Type.REFERENCE("MultipleClasses")
+                                Type.REFERENCE("MultipleClasses1")
                         ),
                         new TypedClass(
-                                "AnotherClass",
+                                "MultipleClasses2",
                                 List.of(
                                         new TypedDeclaration(
-                                                "multipleClasses",
+                                                "i",
-                                                Type.REFERENCE("MultipleClasses")
+                                                Type.INT
                                         )
                                 ),
                                 List.of(),
                                 List.of(
                                         new TypedConstructor(
-                                                "AnotherClass",
+                                                "MultipleClasses2",
                                                 List.of(),
                                                 new TypedBlock(
                                                         List.of(),
                                                         List.of(
                                                                 new TypedAssignment(
-                                                                        new TypedNew(
+                                                                        new TypedIntLiteral(
-                                                                                Type.REFERENCE("MultipleClasses"),
+                                                                                4,
-                                                                                List.of()
+                                                                                Type.INT
                                                                         ),
                                                                         new TypedFieldVarAccess(
                                                                                 true,
                                                                                 null,
-                                                                                "multipleClasses",
+                                                                                "i",
-                                                                                Type.REFERENCE("MultipleClasses")
+                                                                                Type.INT
                                                                         ),
-                                                                        Type.REFERENCE("MultipleClasses")
+                                                                        Type.INT
                                                                 )
                                                         ),
                                                         Type.VOID
@@ -89,7 +89,7 @@ public class TypedAST_MultipleClasses {
                                 null,
                                 null,
                                 null,
-                                Type.REFERENCE("AnotherClass")
+                                Type.REFERENCE("MultipleClasses2")
                         )
                 ),
                 null

src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses.java

@@ -1,15 +0,0 @@
-public class MultipleClasses {
-    AnotherClass anotherClass;
-
-    public MultipleClasses() {
-        this.anotherClass = new AnotherClass();
-    }
-}
-
-public class AnotherClass {
-    MultipleClasses multipleClasses;
-
-    public AnotherClass() {
-        this.multipleClasses = new MultipleClasses();
-    }
-}

src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses1.java

@@ -0,0 +1,11 @@
+public class MultipleClasses1 {
+    MultipleClasses2 anotherClass;
+
+    public MultipleClasses1() {
+        this.anotherClass = new MultipleClasses2();
+    }
+
+    public int getIFromAnotherClass() {
+        return this.anotherClass.i;
+    }
+}

src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses2.java

@@ -0,0 +1,7 @@
+public class MultipleClasses2 {
+    int i;
+
+    public MultipleClasses2() {
+        this.i = 4;
+    }
+}

src/test/testFiles/CodeGenFeatures/If.java

@@ -1,7 +1,11 @@
 public class If {
     public int ifMethod(boolean ifShouldRun, boolean elseIfShouldRun) {
         if (ifShouldRun) {
-            return 1;
+            if (ifShouldRun && elseIfShouldRun) {
+                return 6;
+            } else {
+                return 1;
+            }
         } else if (elseIfShouldRun) {
             return 2;
         } else {