Merge remote-tracking branch 'origin/NewParser' into NewParser

src/main/java/ast/expressions/binaryexpressions/CalculationNode.java

@@ -20,10 +20,12 @@ public class CalculationNode extends BinaryNode {
     }
 
     private void setOperator(String operator) {
-        if(operator.equals("+")) {
-            this.operator = EnumLineOperator.PLUS;
-        } else if(operator.equals("-")) {
-            this.operator = EnumLineOperator.MINUS;
+        if(operator != null) {
+            if(operator.equals("+")) {
+                this.operator = EnumLineOperator.PLUS;
+            } else if(operator.equals("-")) {
+                this.operator = EnumLineOperator.MINUS;
+            }
         }
     }
 

src/test/java/parser/AstBuilderTest.java

@@ -1,22 +1,21 @@
 package parser;
 
-
 import ast.ASTNode;
 import ast.ClassNode;
 import ast.ProgramNode;
 import ast.expressions.IExpressionNode;
-import ast.expressions.binaryexpressions.EnumNonCalculationOperator;
+import ast.expressions.binaryexpressions.CalculationNode;
+import ast.expressions.binaryexpressions.DotNode;
+import ast.expressions.binaryexpressions.DotSubstractionNode;
 import ast.expressions.binaryexpressions.NonCalculationNode;
 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.members.*;
 import ast.parameters.ParameterNode;
 import ast.statementexpressions.AssignNode;
 import ast.statementexpressions.AssignableNode;
 import ast.statementexpressions.crementexpressions.CrementType;
+import ast.statementexpressions.crementexpressions.DecrementNode;
 import ast.statementexpressions.crementexpressions.IncrementNode;
 import ast.statementexpressions.NewDeclarationNode;
 import ast.statementexpressions.methodcallstatementnexpressions.MethodCallNode;
@@ -79,7 +78,7 @@ class AstBuilderTest {
     @DisplayName("Field Test")
     public void fieldTest() {
         ClassNode class1 = Helper.generateEmptyClass("TestClass");
-        class1.addMember(new FieldNode(null, new BaseType(TypeEnum.INT), "a"));
+        class1.addMember(new FieldNode(new AccessModifierNode("public"), new BaseType(TypeEnum.INT), "a"));
 
         ProgramNode expected = new ProgramNode();
         expected.addClass(class1);
@@ -377,36 +376,198 @@ class AstBuilderTest {
     @Test
     @DisplayName("Variable Compare Test")
     public void variableCompareTest(){
+        ClassNode class1 = Helper.generateEmptyClass("TestClass");
+        UnaryNode trueValue = new UnaryNode(new ValueNode(EnumValueNode.BOOLEAN_VALUE,"true"));
+        UnaryNode falseValue = new UnaryNode(new ValueNode(EnumValueNode.BOOLEAN_VALUE,"false"));
 
-        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+        BlockNode trueBlock = new BlockNode();
+        trueBlock.addStatement(new ReturnNode(trueValue));
+        MethodNode trueMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "trueMethod", trueBlock);
+
+        BlockNode falseBlock = new BlockNode();
+        falseBlock.addStatement(new ReturnNode(falseValue));
+        MethodNode falseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "falseMethod", falseBlock);
+
+        BlockNode trueAndTrueBlock = new BlockNode();
+        trueAndTrueBlock.addStatement(new ReturnNode(new NonCalculationNode(trueValue, "&&", trueValue)));
+        MethodNode trueAndTrueMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "trueAndTrueMethod", trueAndTrueBlock);
+
+        BlockNode trueAndFalseBlock = new BlockNode();
+        trueAndFalseBlock.addStatement(new ReturnNode(new NonCalculationNode(trueValue, "&&", falseValue)));
+        MethodNode trueAndFalseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "trueAndFalseMethod", trueAndFalseBlock);
+
+        BlockNode falseAndFalseBlock = new BlockNode();
+        falseAndFalseBlock.addStatement(new ReturnNode(new NonCalculationNode(falseValue, "&&", falseValue)));
+        MethodNode falseAndFalseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "falseAndFalseMethod", falseAndFalseBlock);
+
+        BlockNode trueOrTrueBlock = new BlockNode();
+        trueOrTrueBlock.addStatement(new ReturnNode(new NonCalculationNode(trueValue, "||", trueValue)));
+        MethodNode trueOrFalseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "trueOrTrueMethod", trueOrTrueBlock);
+
+        BlockNode falseOrFalseBlock = new BlockNode();
+        falseOrFalseBlock.addStatement(new ReturnNode(new NonCalculationNode(falseValue, "||", falseValue)));
+        MethodNode falseOrFalseMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "falseOrFalseMethod", falseOrFalseBlock);
+
+        class1.addMember(trueMethod);
+        class1.addMember(falseMethod);
+        class1.addMember(trueAndTrueMethod);
+        class1.addMember(trueAndFalseMethod);
+        class1.addMember(falseAndFalseMethod);
+        class1.addMember(trueOrFalseMethod);
+        class1.addMember(falseOrFalseMethod);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/variableCompare.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Variable Calculation Test")
     public void variableCalculationTest(){
+        ClassNode class1 = Helper.generateEmptyClass("TestClass");
 
-        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+        BlockNode aPlusBBlock = new BlockNode();
+        aPlusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "+", new DotNode(new DotSubstractionNode("b")))));
+        MethodNode aPlusBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aPlusB", aPlusBBlock);
+        aPlusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        aPlusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        BlockNode aMinusBBlock = new BlockNode();
+        aMinusBBlock.addStatement(new ReturnNode(new CalculationNode(new CalculationNode(new DotNode(new DotSubstractionNode("a"))), "-", new DotNode(new DotSubstractionNode("b")))));
+        MethodNode aMinusBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aMinusB", aMinusBBlock);
+        aMinusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        aMinusBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        BlockNode aTimeBBlock = new BlockNode();
+        aTimeBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "*", new DotSubstractionNode("b")))));
+        MethodNode aTimeBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aTimeB", aTimeBBlock);
+        aTimeBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        aTimeBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        BlockNode aDivBBlock = new BlockNode();
+        aDivBBlock.addStatement(new ReturnNode(new CalculationNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "/", new DotSubstractionNode("b")))));
+        MethodNode aDivBMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "aDivB", aDivBBlock);
+        aDivBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        aDivBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        BlockNode complexCalcBlock = new BlockNode();
+        complexCalcBlock.addStatement(new ReturnNode(new CalculationNode(null, null, new DotNode(new DotNode(new DotNode(new DotNode(new DotSubstractionNode("a")), "*", new DotSubstractionNode("b")), "/", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "1"))), "*", new DotSubstractionNode(new ValueNode(EnumValueNode.INT_VALUE, "3"))))));
+        MethodNode complexCalcMethod = new MethodNode("public", new BaseType(TypeEnum.INT), false, "complexCalc", complexCalcBlock);
+        complexCalcMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        complexCalcMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        BlockNode aSmallerBBlock = new BlockNode();
+        aSmallerBBlock.addStatement(new ReturnNode(new NonCalculationNode(new UnaryNode("a"), "<", new UnaryNode("b"))));
+        MethodNode aSmallerBMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "aSmallerB", aSmallerBBlock);
+        aSmallerBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        aSmallerBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        BlockNode aGreaterBBlock = new BlockNode();
+        aGreaterBBlock.addStatement(new ReturnNode(new NonCalculationNode(new UnaryNode("a"), ">", new UnaryNode("b"))));
+        MethodNode aGreaterBMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "aGreaterB", aGreaterBBlock);
+        aGreaterBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        aGreaterBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        BlockNode aEqualsBBlock = new BlockNode();
+        aEqualsBBlock.addStatement(new ReturnNode(new NonCalculationNode(new UnaryNode("a"), "==", new UnaryNode("b"))));
+        MethodNode aEqualsBMethod = new MethodNode("public", new BaseType(TypeEnum.BOOL), false, "aEqualsB", aEqualsBBlock);
+        aEqualsBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "a"));
+        aEqualsBMethod.addParameter(new ParameterNode(new BaseType(TypeEnum.INT), "b"));
+
+        class1.addMember(aPlusBMethod);
+        class1.addMember(aMinusBMethod);
+        class1.addMember(aTimeBMethod);
+        class1.addMember(aDivBMethod);
+        class1.addMember(complexCalcMethod);
+        class1.addMember(aSmallerBMethod);
+        class1.addMember(aGreaterBMethod);
+        class1.addMember(aEqualsBMethod);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/variableCalculation.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Main Method Test")
     public void mainMethodTest(){
+        ClassNode class1 = Helper.generateEmptyClass("TestClass");
 
-        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+        BlockNode block = new BlockNode();
+        block.addStatement(new ReturnNode(null));
+
+        class1.addMember(new MainMethodNode(block));
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/MainMethod.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("While Test")
     public void whileTest(){
+        NonCalculationNode condition = new NonCalculationNode(new UnaryNode("i"), ">", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "0")));
 
-        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+        BlockNode whileBlock = new BlockNode();
+        whileBlock.addStatement(new DecrementNode(CrementType.SUFFIX, new AssignableNode("i")));
+
+        WhileNode whileStatement = new WhileNode(condition, whileBlock);
+
+        BlockNode blockCon = new BlockNode();
+        blockCon.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "10"))));
+        blockCon.addStatement(whileStatement);
+        blockCon.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+
+        ClassNode class1 = new ClassNode("public", "TestClass");
+        class1.addMember(constructor);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/While.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
     @DisplayName("Do While Test")
     public void doWhileTest(){
+        NonCalculationNode condition = new NonCalculationNode(new UnaryNode("i"), "<", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "10")));
 
-        //assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
+        BlockNode whileBlock = new BlockNode();
+        whileBlock.addStatement(new IncrementNode(CrementType.SUFFIX, new AssignableNode("i")));
+
+        WhileNode whileStatement = new WhileNode(condition, whileBlock);
+
+        BlockNode blockDoWhile = new BlockNode();
+        blockDoWhile.addStatement(whileBlock);
+        blockDoWhile.addStatement(whileStatement);
+
+        BlockNode blockCon = new BlockNode();
+        blockCon.addStatement(new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "0"))));
+        blockCon.addStatement(blockDoWhile);
+        blockCon.addStatement(new ReturnNode(null));
+        ConstructorNode constructor = new ConstructorNode("public", "TestClass", blockCon);
+
+        ClassNode class1 = new ClassNode("public", "TestClass");
+        class1.addMember(constructor);
+
+        ProgramNode expected = new ProgramNode();
+        expected.addClass(class1);
+
+        ASTNode actual = Helper.generateAST("src/test/resources/input/javaCases/DoWhile.java");
+
+        assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
 
     @Test
@@ -414,7 +575,6 @@ class AstBuilderTest {
     public void forTest(){
         LocalVariableDeclarationNode forDeclaration = new LocalVariableDeclarationNode(new BaseType(TypeEnum.INT), "i", "=", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "0")));
 
-        NonCalculationNode condition = new NonCalculationNode(new UnaryNode("i"), "<", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "10")));
         AssignableNode assignable = new AssignableNode("i");
         IncrementNode increment = new IncrementNode(CrementType.SUFFIX, assignable);
 
@@ -424,7 +584,7 @@ class AstBuilderTest {
         whileBlock.addStatement(declaration);
         whileBlock.addStatement(increment);
 
-        WhileNode whileStatement = new WhileNode(condition, whileBlock);
+        WhileNode whileStatement = new WhileNode(new NonCalculationNode(new UnaryNode("i"), "<", new UnaryNode(new ValueNode(EnumValueNode.INT_VALUE, "10"))), whileBlock);
 
         BlockNode forStatement = new BlockNode();
         forStatement.addStatement(forDeclaration);
@@ -445,17 +605,4 @@ class AstBuilderTest {
 
         assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
     }
-
-
-
-
-
-
-
-
-
-
-
-
-
 }

src/test/resources/input/javaCases/DoWhile.java

@@ -4,7 +4,7 @@ class TestClass{
         int i = 0;
 
         do{
-            i++
+            i++;
         }while(i < 10);
     }
 }

src/test/resources/input/javaCases/variableCalculation.java

@@ -16,8 +16,8 @@ class TestClass{
         return a / b;
     }
 
-    int colmplexCalc (int a, int b){
-        return a * (b / 1);
+    int complexCalc (int a, int b){
+        return a * b / 1 * 3;
     }
 
     boolean aSmallerB (int a, int b){

src/test/resources/input/javaCases/variableCompare.java

@@ -0,0 +1,30 @@
+class TestClass{
+
+    boolean trueMethod() {
+        return true;
+    }
+
+    boolean falseMethod(){
+        return false;
+    }
+
+    boolean trueAndTrueMethod(){
+        return true && true;
+    }
+
+    boolean trueAndFalseMethod(){
+        return true && false;
+    }
+
+    boolean falseAndFalseMethod(){
+        return false && false;
+    }
+
+    boolean trueOrTrueMethod(){
+        return true || true;
+    }
+
+    boolean falseOrFalseMethod(){
+        return false || false;
+    }
+}

src/test/resources/input/javaCases/variableCompareTest.java

@@ -1,30 +0,0 @@
-class TestClass{
-
-    boolean true(){
-        return true;
-    }
-
-    boolean false(){
-        return false();
-    }
-
-    boolean trueAndTrue(){
-        return true && true;
-    }
-
-    boolean trueAndFalse(){
-        return true && true;
-    }
-
-    boolean falseAndFalse(){
-        return false && false;
-    }
-
-    boolean trueOrFalse(){
-        return true || false;
-    }
-
-    boolean falseOrFalse(){
-        return false || false;
-    }
-}