diff --git a/pom.xml b/pom.xml index 5ef0e2f..b1569e4 100644 --- a/pom.xml +++ b/pom.xml @@ -81,6 +81,12 @@ 4.13.1 test + + org.junit.platform + junit-platform-launcher + 1.10.2 + test + commons-cli diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java index 3ab9a9e..bcc0a07 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedFieldVarAccess.java @@ -49,12 +49,20 @@ public class TypedFieldVarAccess implements TypedExpression { private Type checkFieldOrMethodType(TypedProgram typedProgram) { if (typedProgram.getCurrentClass().isThereField(name)) { - type = typedProgram.getCurrentClass().getFieldType(name); - return type; + return checkTypeField(typedProgram); } else if (typedProgram.getCurrentClass().isMethodOfCurrentClass(name)) { type = typedProgram.getCurrentClass().getMethodType(name); return type; } else if (recursiveOwnerChain instanceof TypedFieldVarAccess typedFieldVarAccess) { + + if (typedProgram.isClassWithNamePresent(recursiveOwnerChain.getType().getReference())) { + Type typeofFieldNameInClass = typedProgram.getTypeOfFieldNameInClass(recursiveOwnerChain.getType().getReference(), name); + if(typeofFieldNameInClass != null){ + return typeofFieldNameInClass; + }else{ + throw new RuntimeException("Field " + name + " not declared in class " + recursiveOwnerChain.getType().getReference()); + } + } type = typedProgram.getCurrentClass().getFieldType(typedFieldVarAccess.getName()); return type; } else { @@ -106,7 +114,15 @@ public class TypedFieldVarAccess implements TypedExpression { } return type; } - + private Type checkTypeField(TypedProgram typedProgram) { + if (recursiveOwnerChain != null) { + if (recursiveOwnerChain.getType() != null) { + return typedProgram.getTypeOfFieldNameInClass(recursiveOwnerChain.getType().getReference(), name); + } + } + type = typedProgram.getCurrentClass().getFieldType(name); + return type; + } @Override public void codeGen(MethodContext ctx) { if (recursiveOwnerChain != null) { diff --git a/src/main/java/de/maishai/typedast/typedclass/TypedProgram.java b/src/main/java/de/maishai/typedast/typedclass/TypedProgram.java index 5f8db1b..8a8571e 100644 --- a/src/main/java/de/maishai/typedast/typedclass/TypedProgram.java +++ b/src/main/java/de/maishai/typedast/typedclass/TypedProgram.java @@ -1,6 +1,7 @@ package de.maishai.typedast.typedclass; import de.maishai.ast.records.Program; +import de.maishai.typedast.Type; import lombok.AllArgsConstructor; import lombok.Getter; @@ -43,6 +44,12 @@ public class TypedProgram { } } + public boolean isClassWithNamePresent(String className) { + return typedClasses.stream().anyMatch(clas -> clas.getClassName().equals(className)); + } + public Type getTypeOfFieldNameInClass(String className, String fieldName) { + return typedClasses.stream().filter(clas -> clas.getClassName().equals(className)).findFirst().get().getFieldType(fieldName); + } public TypedClass getTypedClass(String className) { return typedClasses.stream().filter(clas -> clas.getClassName().equals(className)).findFirst().get(); } diff --git a/src/test/java/CodegeneratorTests.java b/src/test/java/CodegeneratorTests.java index d1f9b50..fcdc9fb 100644 --- a/src/test/java/CodegeneratorTests.java +++ b/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.runners.Suite; -import testResources.CodeGen.BytecodeTestUtil; +import org.junit.platform.commons.support.HierarchyTraversalMode; +import org.junit.platform.commons.support.ReflectionSupport; 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 -// public void testBreak() { -// ByteCode_Break ByteCode_Break = new ByteCode_Break(); -// Assertions.assertTrue(ByteCode_Break.allTestsSuccessful()); -// } + @Test + public void runByteCodeBreakTests() { + runByteCodeTests(ByteCode_Break.class); + } -// @Test -// public void testClass() { -// ByteCode_Class ByteCode_Class = new ByteCode_Class(); -// Assertions.assertTrue(ByteCode_Class.allTestsSuccessful()); -// } + @Test + public void runByteCodeClassTests() { + runByteCodeTests(ByteCode_Class.class); + } -// @Test -// public void testClassObjects() { -// ByteCode_ClassObjects ByteCode_ClassObjects = new ByteCode_ClassObjects(); -// Assertions.assertTrue(ByteCode_ClassObjects.allTestsSuccessful()); -// } -} + @Test + public void runByteCodeClassObjectsTests() { + runByteCodeTests(ByteCode_ClassObjects.class); + } + + @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 failedTests = new ArrayList<>(); + + // Finde alle Methoden, die mit @Test annotiert sind + List 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 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."); + } + } +} \ No newline at end of file diff --git a/src/test/java/NegativeTests.java b/src/test/java/NegativeTests.java new file mode 100644 index 0000000..f384b72 --- /dev/null +++ b/src/test/java/NegativeTests.java @@ -0,0 +1,23 @@ +import de.maishai.Compiler; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.List; + +public class NegativeTests { + + @Test + public void AddressingFieldWithoutThis() { + try { + Compiler.generateByteCodeFilesFromFiles(List.of("src/test/testFiles/Negative/AddressingFieldWithoutThis.java")); + Assertions.fail(); + } catch (Exception e) { + Assertions.assertTrue(true); + } + } + + @Test + public void PublicMissingInClass() { + Compiler.generateByteCodeFilesFromFiles(List.of("src/test/testFiles/Negative/PublicMissingInClass.java")); + } +} diff --git a/src/test/java/ScannerParserTests.java b/src/test/java/ScannerParserTests.java index 83f65b8..03e6145 100644 --- a/src/test/java/ScannerParserTests.java +++ b/src/test/java/ScannerParserTests.java @@ -75,146 +75,148 @@ public class ScannerParserTests { @Test public void testBreak() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Break.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Break.java")); assertEquals(AST_Break.get(), resultAst); } @Test public void testClass() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Class.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Class.java")); assertEquals(AST_Class.get(), resultAst); } @Test public void testClassObjects() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/ClassObjects.java")); + 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 public void testComment() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Comment.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Comment.java")); assertEquals(AST_Comment.get(), resultAst); } @Test public void testCompAssign() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/CompAssign.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/CompAssign.java")); assertEquals(AST_CompAssign.get(), resultAst); } @Test public void testComplexCalls() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/ComplexCalls.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/ComplexCalls.java")); assertEquals(AST_ComplexCalls.get(), resultAst); } @Test public void testConstructor() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Constructor.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Constructor.java")); assertEquals(AST_Constructor.get(), resultAst); } @Test public void testContinue() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Continue.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Continue.java")); assertEquals(AST_Continue.get(), resultAst); } @Test public void testDataTypes() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/DataTypes.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/DataTypes.java")); assertEquals(AST_DataTypes.get(), resultAst); } @Test public void testField() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Field.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Field.java")); assertEquals(AST_Field.get(), resultAst); } @Test public void testFor() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/For.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/For.java")); assertEquals(AST_For.get(), resultAst); } @Test public void testIf() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/If.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/If.java")); assertEquals(AST_If.get(), resultAst); } @Test public void testLogicExpr() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/LogicExpr.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/LogicExpr.java")); assertEquals(AST_LogicExpr.get(), resultAst); } @Test public void testMain() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Main.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Main.java")); assertEquals(AST_Main.get(), resultAst); } @Test public void testMethod() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Method.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Method.java")); assertEquals(AST_Method.get(), resultAst); } @Test public void testMethodCall() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/MethodCall.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/MethodCall.java")); assertEquals(AST_MethodCall.get(), resultAst); } @Test public void testMultipleClasses() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/MultipleClasses1.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 public void testOperators() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Operators.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Operators.java")); assertEquals(AST_Operators.get(), resultAst); } @Test public void testOverloaded() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Overloaded.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Overloaded.java")); assertEquals(AST_Overloaded.get(), resultAst); } @Test public void testPrint() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Print.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Print.java")); assertEquals(AST_Print.get(), resultAst); } @Test public void testReturn() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Return.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Return.java")); assertEquals(AST_Return.get(), resultAst); } @Test public void testUnary() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/Unary.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/Unary.java")); assertEquals(AST_Unary.get(), resultAst); } @Test public void testVariableDefWithDecl() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/VariableDefWithDecl.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/VariableDefWithDecl.java")); assertEquals(AST_VariableDefWithDecl.get(), resultAst); } @Test public void testWhile() { - Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/JavaTestfilesFeatures/While.java")); + Program resultAst = Compiler.generateASTFromFiles(List.of("src/test/testFiles/ASTandTypedASTFeatures/While.java")); assertEquals(AST_While.get(), resultAst); } } diff --git a/src/test/java/TypingTests.java b/src/test/java/TypingTests.java index fd8663f..31d23bd 100644 --- a/src/test/java/TypingTests.java +++ b/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 - } diff --git a/src/test/java/testResources/AST/ASTFeatures/AST_MultipleClasses.java b/src/test/java/testResources/AST/ASTFeatures/AST_MultipleClasses.java index 6a6a309..8c8ab2b 100644 --- a/src/test/java/testResources/AST/ASTFeatures/AST_MultipleClasses.java +++ b/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", - Type.REFERENCE("MultipleClasses") + "i", + 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( - Type.REFERENCE("MultipleClasses"), - List.of() - ) + new IntLiteral(4) ) ) ) diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Break.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Break.java index 79de113..f505759 100644 --- a/src/test/java/testResources/CodeGen/Features/ByteCode_Break.java +++ b/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; diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_ClassObjects.java b/src/test/java/testResources/CodeGen/Features/ByteCode_ClassObjects.java index 13019e5..53bb847 100644 --- a/src/test/java/testResources/CodeGen/Features/ByteCode_ClassObjects.java +++ b/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() { - Assertions.assertEquals("objectsMethod", util.getMethodNames().get(0)); + public void testMethodNames() { + 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"); diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_If.java b/src/test/java/testResources/CodeGen/Features/ByteCode_If.java index bc11677..1134ffe 100644 --- a/src/test/java/testResources/CodeGen/Features/ByteCode_If.java +++ b/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(); } diff --git a/src/test/java/testResources/CodeGen/Features/ByteCode_Operators.java b/src/test/java/testResources/CodeGen/Features/ByteCode_Operators.java index cac74c8..1a5e910 100644 --- a/src/test/java/testResources/CodeGen/Features/ByteCode_Operators.java +++ b/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(); } diff --git a/src/test/java/testResources/TypedAST/TypedASTFeatures/TypedAST_MultipleClasses.java b/src/test/java/testResources/TypedAST/TypedASTFeatures/TypedAST_MultipleClasses.java index 68f9a6d..f5ec567 100644 --- a/src/test/java/testResources/TypedAST/TypedASTFeatures/TypedAST_MultipleClasses.java +++ b/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", - Type.REFERENCE("MultipleClasses") + "i", + Type.INT ) ), List.of(), List.of( new TypedConstructor( - "AnotherClass", + "MultipleClasses2", List.of(), new TypedBlock( List.of(), List.of( new TypedAssignment( - new TypedNew( - Type.REFERENCE("MultipleClasses"), - List.of() + new TypedIntLiteral( + 4, + Type.INT ), new TypedFieldVarAccess( true, null, - "multipleClasses", - Type.REFERENCE("MultipleClasses") + "i", + 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 diff --git a/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses.java b/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses.java deleted file mode 100644 index 84c63bf..0000000 --- a/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses.java +++ /dev/null @@ -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(); - } -} \ No newline at end of file diff --git a/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses1.java b/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses1.java new file mode 100644 index 0000000..a86a301 --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses2.java b/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses2.java new file mode 100644 index 0000000..43f2228 --- /dev/null +++ b/src/test/testFiles/ASTandTypedASTFeatures/MultipleClasses2.java @@ -0,0 +1,7 @@ +public class MultipleClasses2 { + int i; + + public MultipleClasses2() { + this.i = 4; + } +} \ No newline at end of file diff --git a/src/test/testFiles/CodeGenFeatures/If.java b/src/test/testFiles/CodeGenFeatures/If.java index 53b929f..b35c7c5 100644 --- a/src/test/testFiles/CodeGenFeatures/If.java +++ b/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 { diff --git a/src/test/testFiles/Negative/AddressingFieldWithoutThis.java b/src/test/testFiles/Negative/AddressingFieldWithoutThis.java new file mode 100644 index 0000000..58d012e --- /dev/null +++ b/src/test/testFiles/Negative/AddressingFieldWithoutThis.java @@ -0,0 +1,6 @@ +public class AddressingFieldWithoutThis { + int x; + public AddressingFieldWithoutThis() { + x = 5; + } +} \ No newline at end of file diff --git a/src/test/testFiles/Negative/PublicMissingInClass.class b/src/test/testFiles/Negative/PublicMissingInClass.class new file mode 100644 index 0000000..635c6f1 Binary files /dev/null and b/src/test/testFiles/Negative/PublicMissingInClass.class differ diff --git a/src/test/testFiles/Negative/PublicMissingInClass.java b/src/test/testFiles/Negative/PublicMissingInClass.java new file mode 100644 index 0000000..ebc6b33 --- /dev/null +++ b/src/test/testFiles/Negative/PublicMissingInClass.java @@ -0,0 +1,2 @@ +class PublicMissingInClass { +} \ No newline at end of file