From 08f4661cb555569fced170e104facd23c33d3129 Mon Sep 17 00:00:00 2001 From: Viktor Platz Date: Tue, 16 May 2023 13:51:04 +0200 Subject: [PATCH 1/3] Test for AddSubVisitor --- src/test/interpreter/VisitorUnitTest.java | 58 +++++++++++++++++------ src/test/interpreter/utils/MockToken.java | 58 +++++++++++++++++++++++ 2 files changed, 101 insertions(+), 15 deletions(-) create mode 100644 src/test/interpreter/utils/MockToken.java diff --git a/src/test/interpreter/VisitorUnitTest.java b/src/test/interpreter/VisitorUnitTest.java index d285165..d34bf26 100644 --- a/src/test/interpreter/VisitorUnitTest.java +++ b/src/test/interpreter/VisitorUnitTest.java @@ -3,16 +3,22 @@ import interpreter.antlr.MineScriptParser; import interpreter.types.*; import interpreter.utils.MockTerminalNode; +import interpreter.utils.MockToken; +import org.antlr.v4.runtime.Token; +import org.jetbrains.annotations.NotNull; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.ValueSource; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.Spy; import org.mockito.junit.jupiter.MockitoExtension; +import java.util.Objects; import java.util.concurrent.atomic.AtomicReference; @ExtendWith(MockitoExtension.class) @@ -22,7 +28,8 @@ class VisitorUnitTest { @Spy private final Visitor spyVisitor = visitor; @Mock private MineScriptParser.AssignContext mockAssignContext; - @Mock private MineScriptParser.ExpressionContext mockExpressionContext; + @Mock private MineScriptParser.ExpressionContext mockExpressionContext1; + @Mock private MineScriptParser.ExpressionContext mockExpressionContext2; @Mock private MineScriptParser.BoolContext mockBoolContext; @Mock private MineScriptParser.AbsDirContext mockAbsDirContext; @Mock private MineScriptParser.RelDirContext mockRelDirContext; @@ -30,14 +37,17 @@ class VisitorUnitTest { @Mock private MineScriptParser.IdContext mockIdContext; @Mock private MineScriptParser.NegContext mockNegContext; @Mock private MineScriptParser.NotExprContext mockNotExprContext; + @Mock private MineScriptParser.AddSubContext mockAddSubContext; + + @ParameterizedTest @ValueSource(ints = {-1000, -10, 0, 10, 1000}) void visitAssignStoresCorrectNumber(int value) { // Mock functions ID(), expression(), and visit() Mockito.when(mockAssignContext.ID()).thenReturn(new MockTerminalNode("varName")); - Mockito.when(mockAssignContext.expression()).thenReturn(mockExpressionContext); - Mockito.when(spyVisitor.visit(mockExpressionContext)).thenReturn(new MSNumber(value)); + Mockito.when(mockAssignContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value)); // Call the visitAssign method on the spy MSType result = spyVisitor.visitAssign(mockAssignContext); @@ -53,8 +63,8 @@ void visitAssignStoresCorrectNumber(int value) { @Test void visitNotExprValidBoolReturnsNegatedBool() { - Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext); - Mockito.when(spyVisitor.visit(mockExpressionContext)).thenReturn(new MSBool(false)); + Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSBool(false)); MSType result = spyVisitor.visitNotExpr(mockNotExprContext); Assertions.assertTrue(((MSBool) result).getValue()); @@ -62,8 +72,8 @@ void visitNotExprValidBoolReturnsNegatedBool() { @Test void visitNotExprPassZeroReturnsTrue() { - Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext); - Mockito.when(spyVisitor.visit(mockExpressionContext)).thenReturn(new MSNumber(0)); + Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(0)); MSType result = spyVisitor.visitNotExpr(mockNotExprContext); Assertions.assertTrue(((MSBool) result).getValue()); @@ -72,8 +82,8 @@ void visitNotExprPassZeroReturnsTrue() { @ParameterizedTest @ValueSource(ints = {-1000, -100, 100, 1000}) void visitNotExprPassNonZeroNumberReturnsFalse(int value) { - Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext); - Mockito.when(spyVisitor.visit(mockExpressionContext)).thenReturn(new MSNumber(value)); + Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value)); MSType result = spyVisitor.visitNotExpr(mockNotExprContext); Assertions.assertFalse(((MSBool) result).getValue()); @@ -81,8 +91,8 @@ void visitNotExprPassNonZeroNumberReturnsFalse(int value) { @Test void visitNotExprInvalidTypeThrowsRuntimeException() { - Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext); - Mockito.when(spyVisitor.visit(mockExpressionContext)).thenReturn(new MSRelDir("right")); + Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSRelDir("right")); Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitNotExpr(mockNotExprContext)); } @@ -90,8 +100,8 @@ void visitNotExprInvalidTypeThrowsRuntimeException() { @ParameterizedTest @ValueSource(ints = {-1000, -10, 0, 10, 1000}) void visitNegNegatesNumber(int value) { - Mockito.when(mockNegContext.expression()).thenReturn(mockExpressionContext); - Mockito.when(spyVisitor.visit(mockExpressionContext)).thenReturn(new MSNumber(value)); + Mockito.when(mockNegContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value)); MSType result = spyVisitor.visitNeg(mockNegContext); Assertions.assertEquals(-value, ((MSNumber) result).getValue()); @@ -99,8 +109,8 @@ void visitNegNegatesNumber(int value) { @Test void visitNegInvalidTypeThrowsRuntimeException() { - Mockito.when(mockNegContext.expression()).thenReturn(mockExpressionContext); - Mockito.when(spyVisitor.visit(mockExpressionContext)).thenReturn(new MSBool(false)); + Mockito.when(mockNegContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSBool(false)); Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitNeg(mockNegContext)); } @@ -189,4 +199,22 @@ void visitNumberInvalidInputThrowsRuntimeException(){ Mockito.when(mockNumberContext.NUMBER()).thenReturn(new MockTerminalNode("abc")); Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitNumber(mockNumberContext)); } + + @ParameterizedTest + @CsvSource ({"1, 2, +", "2, 1, -", "0, 0, +", "-1, -2, +", "-2, -1, -"}) + void visitAddSubValidInputReturnsNumber(int value1, int value2, String operator){ + mockAddSubContext.op = new MockToken(operator); + Mockito.when(mockAddSubContext.expression(0)).thenReturn(mockExpressionContext1); + Mockito.when(mockAddSubContext.expression(1)).thenReturn(mockExpressionContext2); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value1)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(value2)); + + MSType result = spyVisitor.visitAddSub(mockAddSubContext); + if (operator.equals("+")){ + Assertions.assertEquals(value1 + value2, ((MSNumber) result).getValue()); + } else if (operator.equals("-")){ + Assertions.assertEquals(value1 - value2, ((MSNumber) result).getValue()); + } + } + } diff --git a/src/test/interpreter/utils/MockToken.java b/src/test/interpreter/utils/MockToken.java new file mode 100644 index 0000000..b28687f --- /dev/null +++ b/src/test/interpreter/utils/MockToken.java @@ -0,0 +1,58 @@ +package interpreter.utils; + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenSource; + +public record MockToken(String token) implements Token { + + @Override + public String getText() { + return token; + } + + @Override + public int getType() { + return 0; + } + + @Override + public int getLine() { + return 0; + } + + @Override + public int getCharPositionInLine() { + return 0; + } + + @Override + public int getChannel() { + return 0; + } + + @Override + public int getTokenIndex() { + return 0; + } + + @Override + public int getStartIndex() { + return 0; + } + + @Override + public int getStopIndex() { + return 0; + } + + @Override + public TokenSource getTokenSource() { + return null; + } + + @Override + public CharStream getInputStream() { + return null; + } +} From a33eeb9f30f74a99652cd5664f31465dcaf96f3e Mon Sep 17 00:00:00 2001 From: Viktor Platz Date: Wed, 17 May 2023 13:21:14 +0200 Subject: [PATCH 2/3] Test for AddSubVisitor, Comp, FuncCall, ParenExpr, etc --- src/test/interpreter/VisitorUnitTest.java | 183 ++++++++++++++++++++++ 1 file changed, 183 insertions(+) diff --git a/src/test/interpreter/VisitorUnitTest.java b/src/test/interpreter/VisitorUnitTest.java index d34bf26..6bbcc8e 100644 --- a/src/test/interpreter/VisitorUnitTest.java +++ b/src/test/interpreter/VisitorUnitTest.java @@ -18,6 +18,8 @@ import org.mockito.Spy; import org.mockito.junit.jupiter.MockitoExtension; +import java.util.ArrayList; +import java.util.List; import java.util.Objects; import java.util.concurrent.atomic.AtomicReference; @@ -38,6 +40,12 @@ class VisitorUnitTest { @Mock private MineScriptParser.NegContext mockNegContext; @Mock private MineScriptParser.NotExprContext mockNotExprContext; @Mock private MineScriptParser.AddSubContext mockAddSubContext; + @Mock private MineScriptParser.PowContext mockPowContext; + @Mock private MineScriptParser.ParenExprContext mockParenExprContext; + @Mock private MineScriptParser.CompContext mockCompContext; + @Mock private MineScriptParser.FuncCallContext mockFuncCallContext; + @Mock private MineScriptParser.Actual_parametersContext mockActualParametersContext; + @Mock private MineScriptParser.StatementsContext mockStatementsContext; @@ -217,4 +225,179 @@ void visitAddSubValidInputReturnsNumber(int value1, int value2, String operator) } } + @Test + void visitAddSubInvalidTypeThrowsRuntimeException(){ + mockAddSubContext.op = new MockToken("+"); + Mockito.when(mockAddSubContext.expression(0)).thenReturn(mockExpressionContext1); + Mockito.when(mockAddSubContext.expression(1)).thenReturn(mockExpressionContext2); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSBool(false)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(2)); + + Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitAddSub(mockAddSubContext)); + } + + @ParameterizedTest + @CsvSource ({"1, 2", "2, 1", "0, 0", "-1, 1", "-2, 2"}) + void visitPowValidInputReturnsNumber(int value1, int value2){ + Mockito.when(mockPowContext.expression(0)).thenReturn(mockExpressionContext1); + Mockito.when(mockPowContext.expression(1)).thenReturn(mockExpressionContext2); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value1)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(value2)); + + MSType result = spyVisitor.visitPow(mockPowContext); + Assertions.assertEquals(Math.pow(value1, value2), ((MSNumber) result).getValue()); + } + + @Test + void visitPowInvalidInputThrowsRuntimeException(){ + Mockito.when(mockPowContext.expression(0)).thenReturn(mockExpressionContext1); + Mockito.when(mockPowContext.expression(1)).thenReturn(mockExpressionContext2); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(1)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(-1)); + + Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitPow(mockPowContext)); + } + + @ParameterizedTest + @CsvSource ({"true, false", "false, false"}) + void visitPowInvalidTypeThrowsRuntimeException(boolean bool1, boolean bool2){ + Mockito.when(mockPowContext.expression(0)).thenReturn(mockExpressionContext1); + Mockito.when(mockPowContext.expression(1)).thenReturn(mockExpressionContext2); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSBool(bool1)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSBool(bool2)); + + Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitPow(mockPowContext)); + + } + + @ParameterizedTest + @CsvSource ({"1", "2", "0", "-1", "-2"}) + void visitParenExprValidInputReturnsNumber(int value){ + Mockito.when(mockParenExprContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value)); + + MSType result = spyVisitor.visitParenExpr(mockParenExprContext); + Assertions.assertEquals(value, ((MSNumber) result).getValue()); + } + + @ParameterizedTest + @ValueSource (booleans = {true, false}) + void visitParenExprValidInputReturnsBoolean(boolean value){ + Mockito.when(mockParenExprContext.expression()).thenReturn(mockExpressionContext1); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSBool(value)); + + MSType result = spyVisitor.visitParenExpr(mockParenExprContext); + Assertions.assertEquals(value, ((MSBool) result).getValue()); + } + + @ParameterizedTest + @CsvSource ({"1, 2, <", "2, 1, >", "0, 0, >=", "-1, 1, <", "-2, 2, <="}) + void visitCompValidInputReturnsTrue(int value1, int value2, String operator){ + mockCompContext.op = new MockToken(operator); + Mockito.when(mockCompContext.expression(0)).thenReturn(mockExpressionContext1); + Mockito.when(mockCompContext.expression(1)).thenReturn(mockExpressionContext2); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value1)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(value2)); + + MSType result = spyVisitor.visitComp(mockCompContext); + Assertions.assertEquals(true, ((MSBool) result).getValue()); + } + + @ParameterizedTest + @CsvSource ({"1, 2, >=", "2, 1, <", "0, 0, <", "-1, 1, >=", "-2, 2, >"}) + void visitCompValidInputReturnsFalse(int value1, int value2, String operator){ + mockCompContext.op = new MockToken(operator); + Mockito.when(mockCompContext.expression(0)).thenReturn(mockExpressionContext1); + Mockito.when(mockCompContext.expression(1)).thenReturn(mockExpressionContext2); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value1)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(value2)); + + MSType result = spyVisitor.visitComp(mockCompContext); + Assertions.assertEquals(false, ((MSBool) result).getValue()); + } + + @Test + void visitCompInvalidTypeThrowsException(){ + mockCompContext.op = new MockToken(">"); + Mockito.when(mockCompContext.expression(0)).thenReturn(mockExpressionContext1); + Mockito.when(mockCompContext.expression(1)).thenReturn(mockExpressionContext2); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSBool(true)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(14)); + + Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitComp(mockCompContext)); + } + + @Test + void visitFuncCallValidInputNoParamsReturnsNumber(){ + Mockito.when(mockFuncCallContext.actual_parameters()).thenReturn(mockActualParametersContext); + Mockito.when(mockFuncCallContext.ID()).thenReturn(new MockTerminalNode("testFunction")); + symbolTable.enterSymbol("testFunction", new MSFunction("testFunction", new ArrayList(), mockStatementsContext)); + + Mockito.when(spyVisitor.visit(mockStatementsContext)).thenReturn(new MSNumber(1)); + + MSType result = spyVisitor.visitFuncCall(mockFuncCallContext); + Assertions.assertEquals(1, ((MSNumber) result).getValue()); + } + @ParameterizedTest + @CsvSource ({"1", "2", "0", "-1", "-2", "123", "-123"}) + void visitFuncCallValidInputOneParamReturnsNumber(int value){ + + Mockito.when(mockFuncCallContext.ID()).thenReturn(new MockTerminalNode("testFunction")); + Mockito.when(mockFuncCallContext.actual_parameters()).thenReturn(mockActualParametersContext); + Mockito.when(mockFuncCallContext.actual_parameters().expression()).thenReturn(new ArrayList(){{add(mockExpressionContext1);}}); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value)); + + symbolTable.enterSymbol("testFunction", new MSFunction("testFunction", new ArrayList(){{add("Param1");}}, mockStatementsContext)); + + Mockito.when(spyVisitor.visit(mockStatementsContext)).thenReturn(new MSNumber(value)); + + MSType result = spyVisitor.visitFuncCall(mockFuncCallContext); + Assertions.assertEquals(value, ((MSNumber) result).getValue()); + } + + @ParameterizedTest + @CsvSource ({"1, 2", "2, 1", "0, 0", "-1, 1", "-2, 2", "123, 122", "123, 124", "123, 123"}) + void visitFuncCallValidInputTwoParamReturnsNumber(int value1, int value2){ + + Mockito.when(mockFuncCallContext.ID()).thenReturn(new MockTerminalNode("testFunction")); + Mockito.when(mockFuncCallContext.actual_parameters()).thenReturn(mockActualParametersContext); + Mockito.when(mockFuncCallContext.actual_parameters().expression()).thenReturn(new ArrayList(){{add(mockExpressionContext1); add(mockExpressionContext2);}}); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value1)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(value2)); + + symbolTable.enterSymbol("testFunction", new MSFunction("testFunction", new ArrayList(){{add("Param1"); add("Param2");}}, mockStatementsContext)); + + Mockito.when(spyVisitor.visit(mockStatementsContext)).thenReturn(new MSNumber(value1+value2)); + + MSType result = spyVisitor.visitFuncCall(mockFuncCallContext); + Assertions.assertEquals(value1+value2, ((MSNumber) result).getValue()); + } + + @ParameterizedTest + @CsvSource ({"1, 2", "2, 1", "0, 0", "-1, 1", "-2, 2"}) + void visitFuncCallInvalidInputThrowsException(int value1, int value2){ + + Mockito.when(mockFuncCallContext.ID()).thenReturn(new MockTerminalNode("testFunction")); + Mockito.when(mockFuncCallContext.actual_parameters()).thenReturn(mockActualParametersContext); + Mockito.when(mockFuncCallContext.actual_parameters().expression()).thenReturn(new ArrayList(){{add(mockExpressionContext1); add(mockExpressionContext2);}}); + Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value1)); + Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(value2)); + + symbolTable.enterSymbol("testFunction", new MSFunction("testFunction", new ArrayList(){{add("Param1");}}, mockStatementsContext)); + + Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitFuncCall(mockFuncCallContext)); + } + + @Test + void visitFuncCallInvalidFunction(){ + Mockito.when(mockFuncCallContext.ID()).thenReturn(new MockTerminalNode("testFunctionFake")); + Mockito.when(mockFuncCallContext.actual_parameters()).thenReturn(mockActualParametersContext); + symbolTable.enterSymbol("testFunction", new MSFunction("testFunction", new ArrayList(){{add("Param1"); }}, mockStatementsContext)); + + Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitFuncCall(mockFuncCallContext)); + } + + + + } From bdfaccf5c06afd91ce77e1c220a03a593740487d Mon Sep 17 00:00:00 2001 From: Viktor Platz <62332353+ViktorPlatz@users.noreply.github.com> Date: Wed, 17 May 2023 13:30:21 +0200 Subject: [PATCH 3/3] Update VisitorUnitTest.java --- src/test/interpreter/VisitorUnitTest.java | 39 +++++++---------------- 1 file changed, 11 insertions(+), 28 deletions(-) diff --git a/src/test/interpreter/VisitorUnitTest.java b/src/test/interpreter/VisitorUnitTest.java index 80c993c..052f59d 100644 --- a/src/test/interpreter/VisitorUnitTest.java +++ b/src/test/interpreter/VisitorUnitTest.java @@ -49,7 +49,6 @@ class VisitorUnitTest { @Mock private MineScriptParser.Actual_parametersContext mockActualParametersContext; @Mock private MineScriptParser.StatementsContext mockStatementsContext; @Mock private MineScriptParser.AndContext mockAndContext; - @Mock private MineScriptParser.AddSubContext mockAddSubContext; @Mock private MineScriptParser.OrContext mockOrContext; @Mock private MineScriptParser.MultDivModContext mockMultDivModContext; @Mock private MineScriptParser.IsIsNotContext mockIsIsNotContext; @@ -74,13 +73,8 @@ void visitAssignStoresCorrectNumber(int value) { Assertions.assertEquals(value, ((MSNumber) mockValue.get()).getValue()); Assertions.assertNull(result); } - - @Test - void visitNotExprValidBoolReturnsNegatedBool() { - Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext1); - Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSBool(false)); - } - + + @ParameterizedTest @ValueSource(booleans = {true, false}) void visitAssignStoresCorrectBoolean(boolean value) { @@ -145,6 +139,9 @@ void visitAssignStoresCorrectAbsDir(MSAbsDir.Direction value) { void visitNotExprPassZeroReturnsTrue() { Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext1); Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(0)); + + MSType result = spyVisitor.visitNotExpr(mockNotExprContext); + Assertions.assertTrue(((MSBool) result).getValue()); } void visitNotExprValidBoolReturnsNegatedBool() { Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext1); @@ -159,8 +156,11 @@ void visitNotExprValidBoolReturnsNegatedBool() { void visitNotExprPassNonZeroNumberReturnsFalse(int value) { Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext1); Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(value)); + + MSType result = spyVisitor.visitNotExpr(mockNotExprContext); + Assertions.assertFalse(((MSBool) result).getValue()); } - + @ValueSource(ints = {-1000, -100, 0, 100, 1000}) void visitNotExprPassNumberThrowsRuntimeException(int value) { Mockito.when(mockNotExprContext.expression()).thenReturn(mockExpressionContext); @@ -468,7 +468,7 @@ void visitFuncCallInvalidFunction(){ Assertions.assertThrows(RuntimeException.class, () -> spyVisitor.visitFuncCall(mockFuncCallContext)); } - + @Test void visitAndValidBoolsReturnsTrue(){ Mockito.when(mockAndContext.expression(0)).thenReturn(mockExpressionContext1); @@ -479,7 +479,7 @@ void visitAndValidBoolsReturnsTrue(){ MSType result = spyVisitor.visitAnd(mockAndContext); Assertions.assertTrue(((MSBool) result).getValue()); } - + @Test void visitAndBoolsTrueAndFalseReturnsFalse(){ Mockito.when(mockAndContext.expression(0)).thenReturn(mockExpressionContext1); @@ -499,23 +499,6 @@ void visitAndFalseWithShortCircuitReturnsFalse() { Assertions.assertFalse(((MSBool) result).getValue()); } - @ParameterizedTest - @CsvSource ({"1, 2, +", "2, 1, -", "0, 0, +", "-1, -2, +", "-2, -1, -"}) - void visitAddSubValidInputReturnsNumber(int left, int right, String operator){ - mockAddSubContext.op = new MockToken(operator); - Mockito.when(mockAddSubContext.expression(0)).thenReturn(mockExpressionContext1); - Mockito.when(mockAddSubContext.expression(1)).thenReturn(mockExpressionContext2); - Mockito.when(spyVisitor.visit(mockExpressionContext1)).thenReturn(new MSNumber(left)); - Mockito.when(spyVisitor.visit(mockExpressionContext2)).thenReturn(new MSNumber(right)); - - MSType result = spyVisitor.visitAddSub(mockAddSubContext); - if (operator.equals("+")){ - Assertions.assertEquals(left + right, ((MSNumber) result).getValue()); - } else if (operator.equals("-")){ - Assertions.assertEquals(left - right, ((MSNumber) result).getValue()); - } - } - @ParameterizedTest @CsvSource({"false, false", "false, true", "true, false", "true, true"}) void visitOrValidInputReturnsOrValue(boolean left, boolean right) {