From e6a2b0fe9dd77c0b39cd849dad0d4577c7c6520b Mon Sep 17 00:00:00 2001 From: Lucas <89882946+notbad3500@users.noreply.github.com> Date: Wed, 3 Jul 2024 15:58:02 +0200 Subject: [PATCH] Semantic Tests work --- src/test/java/main/MainTest.java | 9 +- src/test/java/main/ReflectionsTest.java | 2 +- src/test/java/parser/AstBuilderTest.java | 16 +- src/test/java/semantic/SemanticTest.java | 438 +++++++++++++++++++++++ 4 files changed, 442 insertions(+), 23 deletions(-) diff --git a/src/test/java/main/MainTest.java b/src/test/java/main/MainTest.java index 24389bc..54ab8be 100644 --- a/src/test/java/main/MainTest.java +++ b/src/test/java/main/MainTest.java @@ -12,16 +12,11 @@ import java.nio.file.Paths; * run every test: mvn test * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen */ +@Deprecated public class MainTest { @Test void test() { - CharStream codeCharStream = null; - try { - codeCharStream = CharStreams.fromPath(Paths.get("src/main/test/resources/CompilerInput.java")); - Main.compileFile(codeCharStream, "src/main/test/resources/output"); - } catch (IOException e) { - System.err.println("Error reading the file: " + e.getMessage()); - } + System.out.println("MainTest"); } } diff --git a/src/test/java/main/ReflectionsTest.java b/src/test/java/main/ReflectionsTest.java index d47d95a..3b4cffd 100644 --- a/src/test/java/main/ReflectionsTest.java +++ b/src/test/java/main/ReflectionsTest.java @@ -11,7 +11,7 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; - +@Deprecated public class ReflectionsTest { @Test diff --git a/src/test/java/parser/AstBuilderTest.java b/src/test/java/parser/AstBuilderTest.java index 2810e55..15403d3 100644 --- a/src/test/java/parser/AstBuilderTest.java +++ b/src/test/java/parser/AstBuilderTest.java @@ -9,34 +9,20 @@ import ast.expressions.unaryexpressions.MemberAccessNode; import ast.expressions.unaryexpressions.UnaryNode; import ast.members.ConstructorNode; import ast.members.FieldNode; -import ast.members.MemberNode; import ast.members.MethodNode; import ast.parameters.ParameterNode; import ast.statementexpressions.AssignNode; import ast.statementexpressions.AssignableNode; import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; import ast.statements.BlockNode; -import ast.statements.IStatementNode; import ast.statements.ReturnNode; import ast.type.AccessModifierNode; import ast.type.EnumValueNode; import ast.type.ValueNode; import ast.type.type.BaseType; -import ast.type.type.ITypeNode; import ast.type.type.TypeEnum; -import com.fasterxml.jackson.annotation.JsonFormat; -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.CharStreams; -import org.antlr.v4.runtime.CommonTokenStream; -import org.antlr.v4.runtime.tree.ParseTree; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import parser.astBuilder.ASTBuilder; -import parser.generated.SimpleJavaLexer; -import parser.generated.SimpleJavaParser; - -import java.io.IOException; -import java.lang.reflect.Member; import static org.assertj.core.api.Assertions.assertThat; @@ -343,7 +329,7 @@ class AstBuilderTest { @Test @DisplayName("Self Reference Test") - public void selfReferneceTest() { + public void selfReferenceTest() { //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected); } diff --git a/src/test/java/semantic/SemanticTest.java b/src/test/java/semantic/SemanticTest.java index f406580..db86fe9 100644 --- a/src/test/java/semantic/SemanticTest.java +++ b/src/test/java/semantic/SemanticTest.java @@ -1,5 +1,443 @@ package semantic; +import ast.ASTNode; +import ast.ClassNode; +import ast.ProgramNode; +import ast.expressions.IExpressionNode; +import ast.expressions.unaryexpressions.MemberAccessNode; +import ast.expressions.unaryexpressions.UnaryNode; +import ast.members.ConstructorNode; +import ast.members.FieldNode; +import ast.members.MethodNode; +import ast.parameters.ParameterNode; +import ast.statementexpressions.AssignNode; +import ast.statementexpressions.AssignableNode; +import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode; +import ast.statements.BlockNode; +import ast.statements.ReturnNode; +import ast.type.AccessModifierNode; +import ast.type.EnumValueNode; +import ast.type.ValueNode; +import ast.type.type.BaseType; +import ast.type.type.TypeEnum; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import parser.Helper; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class SemanticTest { + private final static String directoryPath = "src/test/resources/input/singleFeatureTests/"; + + @BeforeEach + public void setUp() { + SemanticAnalyzer.clearAnalyzer(); + } + + @Test + @DisplayName("Empty Class Test") + public void emptyClassTest() { + ClassNode emptyClass = Helper.generateEmptyClass("EmptyClass"); + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(emptyClass); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + + @Test + @DisplayName("Multiple Empty Classes Test") + public void multipleEmptyClassesTest() { + ClassNode class1 = Helper.generateEmptyClass("MultipleClasses"); + ClassNode class2 = Helper.generateEmptyClass("TestClass2"); + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + abstractSyntaxTree.addClass(class2); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + + @Test + @DisplayName("Empty Class Test with Constructor") + public void emptyClassWithConstructorTest() { + ClassNode class1 = Helper.generateEmptyClass("EmptyClassWithConstructor"); + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Field Test") + public void fieldTest() { + ClassNode class1 = Helper.generateEmptyClass("Field"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Field Test with Accessmodifier") + public void fieldTestWithModifier() { + ClassNode class1 = Helper.generateEmptyClass("FieldWithAccessModifier"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Comments Ignore Test") + public void commentsIgnoreTest() { + ClassNode class1 = Helper.generateEmptyClass("Comments"); + class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a")); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Constructor Parameter Test") + public void constructorParameterTest() { + BlockNode block = new BlockNode(); + block.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ConstructorParameter", block); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b")); + + ClassNode class1 = new ClassNode("public", "ConstructorParameter"); + class1.addMember(constructor); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("This Dot Test") + public void thisDotTest() { + BlockNode block = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + ValueNode value = new ValueNode(EnumValueNode.INT_VALUE, "1"); + IExpressionNode expression = new UnaryNode(value); + + block.addStatement(new AssignNode(assignable, expression)); + block.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ThisDot", block); + + ClassNode class1 = new ClassNode("public", "ThisDot"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Constructor This Dot Test") + public void constructorThisDotTest() { + BlockNode block = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + IExpressionNode expression = new UnaryNode("a"); + + block.addStatement(new AssignNode(assignable, expression)); + block.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ConstructorThisDot", block); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); + + ClassNode class1 = new ClassNode("public", "ConstructorThisDot"); + class1.addMember(new FieldNode(new AccessModifierNode("private"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Void Methoden Test") + public void voidMethodenTest() { + ClassNode class1 = Helper.generateEmptyClass("VoidMethod"); + BlockNode block = new BlockNode(); + block.addStatement(new ReturnNode(null)); + class1.addMember(new MethodNode("public", null, true, "test", block)); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Constructor Method call Test") + public void constructorMethodCallTest() { + BlockNode blockCon = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + IExpressionNode expression = new UnaryNode(new MethodCallNode(null, "testMethod")); + + blockCon.addStatement(new AssignNode(assignable, expression)); + blockCon.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCall", blockCon); + + BlockNode blockMethod = new BlockNode(); + blockMethod.addStatement(new ReturnNode(new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "1")))); + MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod); + + ClassNode class1 = new ClassNode("public", "ConstructorMethodCall"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + class1.addMember(method); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Constructor Method call Parameters Test") + public void constructorMethodCallParametersTest() { + BlockNode blockCon = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + MethodCallNode methodCall = new MethodCallNode(null, "testMethod"); + methodCall.addExpression(new UnaryNode("a")); + IExpressionNode expression = new UnaryNode(methodCall); + + blockCon.addStatement(new AssignNode(assignable, expression)); + blockCon.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "ConstructorMethodCallParameters", blockCon); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); + + BlockNode blockMethod = new BlockNode(); + blockMethod.addStatement(new ReturnNode(new UnaryNode("a"))); + MethodNode method = new MethodNode("public", new BaseType(TypeEnum.INT), false, "testMethod", blockMethod); + method.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a")); + + ClassNode class1 = new ClassNode("public", "ConstructorMethodCallParameters"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + class1.addMember(method); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Char Test") + public void charTest() { + BlockNode blockCon = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + MethodCallNode methodCall = new MethodCallNode(null, "testMethod"); + methodCall.addExpression(new UnaryNode("a")); + IExpressionNode expression = new UnaryNode(methodCall); + + blockCon.addStatement(new AssignNode(assignable, expression)); + blockCon.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "Char", blockCon); + constructor.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a")); + + BlockNode blockMethod = new BlockNode(); + blockMethod.addStatement(new ReturnNode(new UnaryNode("a"))); + MethodNode method = new MethodNode("public", new BaseType(TypeEnum.CHAR), false, "testMethod", blockMethod); + method.addParameter(new ParameterNode(new BaseType(TypeEnum.CHAR), "a")); + + ClassNode class1 = new ClassNode("public", "Char"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.CHAR), "a")); + class1.addMember(constructor); + class1.addMember(method); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Null Test") + public void nullTest() { + BlockNode blockCon = new BlockNode(); + MemberAccessNode memberAccess = new MemberAccessNode(true); + memberAccess.addIdentifier("a"); + + AssignableNode assignable = new AssignableNode(memberAccess); + + blockCon.addStatement(new AssignNode(assignable, new UnaryNode(new ValueNode(EnumValueNode.NULL_VALUE, "null")))); + blockCon.addStatement(new ReturnNode(null)); + ConstructorNode constructor = new ConstructorNode("public", "Null", blockCon); + + ClassNode class1 = new ClassNode("public", "Null"); + class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + class1.addMember(constructor); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(class1); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } + + @Test + @DisplayName("Self Reference Test") + public void selfReferenceTest() { + + } + + @Test + @DisplayName("Variable Compare Test") + public void variableCompareTest() { + + } + + @Test + @DisplayName("Variable Calculation Test") + public void variableCalculationTest() { + + } + + @Test + @DisplayName("Main Method Test") + public void mainMethodTest() { + + } + + @Test + @DisplayName("While Test") + public void whileTest() { + + } + + @Test + @DisplayName("Do While Test") + public void doWhileTest() { + + } + + @Test + @DisplayName("For Test") + public void forTest() { + + } + + @Test + @DisplayName("Increment Test") + public void incrementTest() { + ClassNode classNode = Helper.generateEmptyClass("Increment"); + classNode.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a")); + + ProgramNode abstractSyntaxTree = new ProgramNode(); + abstractSyntaxTree.addClass(classNode); + + ASTNode typedAst = SemanticAnalyzer.generateTast(abstractSyntaxTree); + for (Exception runtimeException : SemanticAnalyzer.errors) { + runtimeException.printStackTrace(); + } + assertTrue(SemanticAnalyzer.errors.isEmpty()); + assertNotNull(typedAst); + } } \ No newline at end of file