files = getJavaFilesFromDirectory(typedAstFeatureTests);
+
+ if (!files.isEmpty()) {
+ for (File file : files) {
+ // Try to compile the file and get the result
+ int result = javac.run(null, null, null, file.getPath());
+
+ // Assert that the compilation succeeded (i.e., the result is zero)
+ assertEquals(0, result, "Expected compilation success for " + file.getName());
+ }
+ } else {
+ System.out.println("No files found in the directories.");
+ }
+ }
+
+
+
/**
* This test method checks if invalid Java files fail to compile as expected.
diff --git a/src/test/java/main/MainTest.java b/src/test/java/main/MainTest.java
index 24389bc..890f4cd 100644
--- a/src/test/java/main/MainTest.java
+++ b/src/test/java/main/MainTest.java
@@ -1,28 +1,25 @@
package main;
-import org.junit.jupiter.api.Test;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.CharStreams;
-
-import java.io.IOException;
-import java.nio.file.Paths;
-
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import parser.ParserTest;
+import parser.ScannerTest;
+import semantic.EndToTypedAstTest;
+import semantic.SemanticTest;
/**
- * run every test: mvn test
- * Nutzen dieser Klasse: Eigentlich nicht vorhanden, in der Main gibts nichts zu testen
+ * This class is a test suite that runs all the test classes in the project.
+ * 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/main/ReflectionsTest.java b/src/test/java/main/ReflectionsTest.java
deleted file mode 100644
index d47d95a..0000000
--- a/src/test/java/main/ReflectionsTest.java
+++ /dev/null
@@ -1,145 +0,0 @@
-package main;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.List;
-
-import org.antlr.v4.runtime.CharStream;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-
-public class ReflectionsTest {
-
- @Test
- public void testSimpleJavaLexerClass() throws ClassNotFoundException, NoSuchMethodException {
- Class clazz = Class.forName("parser.generated.SimpleJavaLexer");
-
- // Class Name
- assertEquals("parser.generated.SimpleJavaLexer", clazz.getName());
-
- // Constructors
- Constructor[] actualConstructors = clazz.getDeclaredConstructors();
- assertTrue(actualConstructors.length > 0, "No constructors found");
-
- Constructor expectedConstructor = clazz.getConstructor(CharStream.class);
-
- boolean constructorFound = false;
- for (Constructor constructor : actualConstructors) {
- if (constructor.equals(expectedConstructor)) {
- constructorFound = true;
- break;
- }
- }
- assertTrue(constructorFound, "Expected constructor not found in actual constructors");
-
-
-
- // Methods
- Method[] actualMethodNames = clazz.getDeclaredMethods();
- assertTrue(actualMethodNames.length > 0);
- Arrays.stream(actualMethodNames).forEach(method -> System.out.println("Method: " + method.getName()));
-
- List expectedMethodNames = Arrays.asList(
- "getTokenNames",
- "getVocabulary",
- "getGrammarFileName",
- "getRuleNames",
- "getSerializedATN",
- "getChannelNames",
- "getModeNames",
- "getATN",
- "makeRuleNames",
- "makeLiteralNames",
- "makeSymbolicNames"
- );
-
- for (Method method : actualMethodNames) {
- assertTrue(expectedMethodNames.contains(method.getName()));
- }
-
- for (String expectedMethodName : expectedMethodNames) {
- boolean methodFound = false;
- for (Method method : actualMethodNames) {
- if (method.getName().equals(expectedMethodName)) {
- methodFound = true;
- break;
- }
- }
- assertTrue(methodFound, "Expected method " + expectedMethodName + " not found in actual methods");
- }
-
-
- // Fields
- Field[] actualFieldNames = clazz.getDeclaredFields();
- assertTrue(actualFieldNames.length > 0);
- Arrays.stream(actualFieldNames).forEach(field -> System.out.println("Field: " + field.getName()));
-
- List expectedFieldNames = Arrays.asList(
- "_decisionToDFA",
- "_sharedContextCache",
- "channelNames",
- "modeNames",
- "ruleNames",
- "_LITERAL_NAMES",
- "_SYMBOLIC_NAMES",
- "VOCABULARY",
- "tokenNames",
- "_serializedATN",
- "_ATN"
- );
-
- for (Field field : actualFieldNames) {
- assertTrue(expectedFieldNames.contains(field.getName()));
- }
- }
-
- @Test
- public void testSimpleJavaParserClass() throws ClassNotFoundException {
- Class clazz = Class.forName("parser.generated.SimpleJavaParser");
-
- // Class Name
- assertEquals("parser.generated.SimpleJavaParser", clazz.getName());
-
- // Constructors
- Constructor[] constructors = clazz.getDeclaredConstructors();
- assertTrue(constructors.length > 0);
-
- // Methods
- Method[] methods = clazz.getDeclaredMethods();
- assertTrue(methods.length > 0);
- Arrays.stream(methods).forEach(method -> System.out.println("Method: " + method.getName()));
-
- // Fields
- Field[] fields = clazz.getDeclaredFields();
- assertTrue(fields.length > 0);
- Arrays.stream(fields).forEach(field -> System.out.println("Field: " + field.getName()));
- }
-
- @Test
- public void testASTBuilderClass() throws ClassNotFoundException {
- Class clazz = Class.forName("parser.astBuilder.ASTBuilder");
-
- // Class Name
- assertEquals("parser.astBuilder.ASTBuilder", clazz.getName());
-
- // Constructors
- Constructor[] constructors = clazz.getDeclaredConstructors();
- assertTrue(constructors.length > 0);
-
- // Methods
- Method[] methods = clazz.getDeclaredMethods();
- assertTrue(methods.length > 0);
- Arrays.stream(methods).forEach(method -> System.out.println("Method: " + method.getName()));
-
- // Fields
- Field[] fields = clazz.getDeclaredFields();
- assertTrue(fields.length > 0);
- Arrays.stream(fields).forEach(field -> System.out.println("Field: " + field.getName()));
- }
-
- // Similarly, you can add tests for SemanticAnalyzer and ByteCodeGenerator
-}
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