run: mvn test
+ *
check results in console or target/surefire-reports
*/
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ InputFilesTest.class,
+ ScannerTest.class,
+ ParserTest.class,
+ SemanticTest.class,
+ EndToTypedAstTest.class
+})
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());
- }
- }
+ // This class remains empty, it is used only as a holder for the above annotations
}
-
-
diff --git a/src/test/java/semantic/SemanticTest.java b/src/test/java/semantic/SemanticTest.java
index f406580..ac7393f 100644
--- a/src/test/java/semantic/SemanticTest.java
+++ b/src/test/java/semantic/SemanticTest.java
@@ -1,5 +1,441 @@
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 {
+ @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
diff --git a/src/test/resources/input/combinedFeatureTests/AllFeaturesClassExample.class b/src/test/resources/input/combinedFeatureTests/AllFeaturesClassExample.class
deleted file mode 100644
index b59adc2b7e01f158236a1ad77e723a9172711fe4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 1093
zcmZ`%O-~b16g{sq(64DJUj=Cq0fn|8uyA3t8nl9Gg0jGnfE!=iNg14Wn(372o