From 95b06122f747d3cd081f8d8be10e4095d6c8457d Mon Sep 17 00:00:00 2001 From: Roman Dandali Date: Tue, 14 Sep 2021 01:49:06 +0300 Subject: [PATCH 1/6] Created Calculator class and calculate method in SimpleCalculator interface --- src/main/java/core/basesyntax/Calculator.java | 25 ++ src/main/java/core/basesyntax/HelloWorld.java | 8 - .../basesyntax/IllegalOperationException.java | 7 + .../core/basesyntax/SimpleCalculator.java | 5 + .../java/core/basesyntax/CalculatorTest.java | 278 ++++++++++++++++++ .../java/core/basesyntax/HelloWorldTest.java | 8 - 6 files changed, 315 insertions(+), 16 deletions(-) create mode 100644 src/main/java/core/basesyntax/Calculator.java delete mode 100644 src/main/java/core/basesyntax/HelloWorld.java create mode 100644 src/main/java/core/basesyntax/IllegalOperationException.java create mode 100644 src/main/java/core/basesyntax/SimpleCalculator.java create mode 100644 src/test/java/core/basesyntax/CalculatorTest.java delete mode 100644 src/test/java/core/basesyntax/HelloWorldTest.java diff --git a/src/main/java/core/basesyntax/Calculator.java b/src/main/java/core/basesyntax/Calculator.java new file mode 100644 index 00000000..5d769899 --- /dev/null +++ b/src/main/java/core/basesyntax/Calculator.java @@ -0,0 +1,25 @@ +package core.basesyntax; + +public class Calculator implements SimpleCalculator { + + @Override + public double calculate(double firstValue, double secondValue, char operation) { + switch (operation) { + case '+': + return firstValue + secondValue; + case '-': + return firstValue - secondValue; + case '*': + return firstValue * secondValue; + case '/': + if (secondValue == 0) { + throw new RuntimeException("Can`t division by zero"); + } + return firstValue / secondValue; + case '^': + return Math.pow(firstValue, secondValue); + default: + throw new IllegalOperationException("Illegal operation"); + } + } +} diff --git a/src/main/java/core/basesyntax/HelloWorld.java b/src/main/java/core/basesyntax/HelloWorld.java deleted file mode 100644 index 97db782b..00000000 --- a/src/main/java/core/basesyntax/HelloWorld.java +++ /dev/null @@ -1,8 +0,0 @@ -package core.basesyntax; - -/** - * Feel free to remove this class and create your own. - */ -public class HelloWorld { - -} diff --git a/src/main/java/core/basesyntax/IllegalOperationException.java b/src/main/java/core/basesyntax/IllegalOperationException.java new file mode 100644 index 00000000..5e945ad4 --- /dev/null +++ b/src/main/java/core/basesyntax/IllegalOperationException.java @@ -0,0 +1,7 @@ +package core.basesyntax; + +public class IllegalOperationException extends RuntimeException { + public IllegalOperationException(String message) { + super(message); + } +} diff --git a/src/main/java/core/basesyntax/SimpleCalculator.java b/src/main/java/core/basesyntax/SimpleCalculator.java new file mode 100644 index 00000000..985d7d3c --- /dev/null +++ b/src/main/java/core/basesyntax/SimpleCalculator.java @@ -0,0 +1,5 @@ +package core.basesyntax; + +public interface SimpleCalculator { + double calculate(double firstValue, double secondValue, char operation); +} diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java new file mode 100644 index 00000000..2e421900 --- /dev/null +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -0,0 +1,278 @@ +package core.basesyntax; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class CalculatorTest { + private static final double A_POSITIVE = 1.23; + private static final double B_POSITIVE = 12.345; + private static final double A_NEGATIVE = -123.456; + private static final double B_NEGATIVE = -5.0; + private static final byte ZERO = 0; + private static final char ADDITION = '+'; + private static final char SUBTRACTION = '-'; + private static final char MULTIPLICATION = '*'; + private static final char DIVISION = '/'; + private static final char EXPONENTIATION = '^'; + private SimpleCalculator calculator; + + @BeforeEach + void setUp() { + calculator = new Calculator(); + } + + @Test + void calculate_additionPositiveOperands_ok() { + double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, ADDITION); + double expected = A_POSITIVE + B_POSITIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_additionNegativeOperands_ok() { + double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, ADDITION); + double expected = A_NEGATIVE + B_NEGATIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithFirstNegativeOperand_ok() { + double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, ADDITION); + double expected = A_NEGATIVE + A_POSITIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_additionMinOperands_ok() { + double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, ADDITION); + double expected = Double.MIN_VALUE + Double.MIN_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_additionMaxValuesOperands_ok() { + double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, ADDITION); + double expected = Double.MAX_VALUE + Double.MAX_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_additionMaxAndMinOperands_ok() { + double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, ADDITION); + double expected = Double.MAX_VALUE + Double.MIN_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionPositiveOperands_ok() { + double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, SUBTRACTION); + double expected = A_POSITIVE - B_POSITIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionNegativeOperands_ok() { + double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, SUBTRACTION); + double expected = A_NEGATIVE - B_NEGATIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionWithFirstNegativeOperand_ok() { + double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, SUBTRACTION); + double expected = A_NEGATIVE - A_POSITIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionWithSecondNegativeOperand_ok() { + double actual = calculator.calculate(A_POSITIVE, A_NEGATIVE, SUBTRACTION); + double expected = A_POSITIVE - A_NEGATIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionMinOperands_ok() { + double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, SUBTRACTION); + double expected = Double.MIN_VALUE - Double.MIN_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionMaxOperands_ok() { + double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, SUBTRACTION); + double expected = Double.MAX_VALUE - Double.MAX_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionMinAndMaxOperands_ok() { + double actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, SUBTRACTION); + double expected = Double.MIN_VALUE - Double.MAX_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_multiplicationPositiveOperands_ok() { + double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, MULTIPLICATION); + double expected = A_POSITIVE * B_POSITIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_multiplicationNegativeOperands_ok() { + double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, MULTIPLICATION); + double expected = A_NEGATIVE * B_NEGATIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_multiplicationWithFirstNegativeOperand_ok() { + double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, MULTIPLICATION); + double expected = A_NEGATIVE * A_POSITIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_multiplicationMinOperands_ok() { + double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, MULTIPLICATION); + double expected = Double.MIN_VALUE * Double.MIN_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_multiplicationMaxValuesOperands_ok() { + double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, MULTIPLICATION); + double expected = Double.MAX_VALUE * Double.MAX_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_multiplicationMaxAndMinOperands_ok() { + double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, MULTIPLICATION); + double expected = Double.MAX_VALUE * Double.MIN_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_divisionPositiveOperands_ok() { + double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, DIVISION); + double expected = A_POSITIVE / B_POSITIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_divisionNegativeOperands_ok() { + double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, DIVISION); + double expected = A_NEGATIVE / B_NEGATIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_divisionWithFirstNegativeOperand_ok() { + double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, DIVISION); + double expected = A_NEGATIVE / A_POSITIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_divisionWithSecondNegativeOperand_ok() { + double actual = calculator.calculate(A_POSITIVE, A_NEGATIVE, DIVISION); + double expected = A_POSITIVE / A_NEGATIVE; + assertEquals(expected, actual); + } + + @Test + void calculate_divisionMinOperands_ok() { + double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, DIVISION); + double expected = Double.MIN_VALUE / Double.MIN_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_divisionMaxOperands_ok() { + double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, DIVISION); + double expected = Double.MAX_VALUE / Double.MAX_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_divisionMinAndMaxOperands_ok() { + double actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, DIVISION); + double expected = Double.MIN_VALUE / Double.MAX_VALUE; + assertEquals(expected, actual); + } + + @Test + void calculate_divisionByZero_notOk() { + assertThrows(RuntimeException.class, () -> { + calculator.calculate(A_POSITIVE, ZERO, DIVISION); + }); + } + + @Test + void calculate_exponentiationPositiveToPositiveValue_ok() { + double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, EXPONENTIATION); + double expected = Math.pow(A_POSITIVE, B_POSITIVE); + assertEquals(expected, actual); + } + + @Test + void calculate_exponentiationNegativeToPositiveValue_ok() { + double actual = calculator.calculate(A_NEGATIVE, B_POSITIVE, EXPONENTIATION); + double expected = Math.pow(A_NEGATIVE, B_POSITIVE); + assertEquals(expected, actual); + } + + @Test + void calculate_exponentiationPositiveToNegativeValue_ok() { + double actual = calculator.calculate(A_POSITIVE, B_NEGATIVE, EXPONENTIATION); + double expected = Math.pow(A_POSITIVE, B_NEGATIVE); + assertEquals(expected, actual); + } + + @Test + void calculate_exponentiationNegativeToNegativeValue_ok() { + double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, EXPONENTIATION); + double expected = Math.pow(A_NEGATIVE, B_NEGATIVE); + assertEquals(expected, actual); + } + + @Test + void calculate_exponentiationPositiveValueToZero_ok() { + double actual = calculator.calculate(A_POSITIVE, ZERO, EXPONENTIATION); + double expected = Math.pow(A_POSITIVE, ZERO); + assertEquals(expected, actual); + } + + @Test + void calculate_exponentiationNegativeValueToZero_ok() { + double actual = calculator.calculate(A_NEGATIVE, ZERO, EXPONENTIATION); + double expected = Math.pow(A_NEGATIVE, ZERO); + assertEquals(expected, actual); + } + + @Test + void calculate_exponentiationZeroToPositiveValue_ok() { + double actual = calculator.calculate(ZERO, A_POSITIVE, EXPONENTIATION); + double expected = Math.pow(ZERO, A_POSITIVE); + assertEquals(expected, actual); + } + + @Test + void calculate_exponentiationZeroToNegativeValue_ok() { + double actual = calculator.calculate(ZERO, A_NEGATIVE, EXPONENTIATION); + double expected = Math.pow(ZERO, A_NEGATIVE); + assertEquals(expected, actual); + } + + @Test + void calculate_illegalOperation_notOk() { + assertThrows(IllegalOperationException.class, () -> { + calculator.calculate(A_POSITIVE, B_NEGATIVE, '%'); + }); + } +} diff --git a/src/test/java/core/basesyntax/HelloWorldTest.java b/src/test/java/core/basesyntax/HelloWorldTest.java deleted file mode 100644 index 9a90d822..00000000 --- a/src/test/java/core/basesyntax/HelloWorldTest.java +++ /dev/null @@ -1,8 +0,0 @@ -package core.basesyntax; - -/** - * Feel free to remove this class and create your own. - */ -public class HelloWorldTest { - -} From 1ca2e9ab788646f13e6bb5fe7a4c01a34c3364d6 Mon Sep 17 00:00:00 2001 From: Roman Dandali Date: Tue, 14 Sep 2021 11:27:51 +0300 Subject: [PATCH 2/6] fixed name methods --- .../java/core/basesyntax/CalculatorTest.java | 68 +++++++++---------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java index 2e421900..1b1b743a 100644 --- a/src/test/java/core/basesyntax/CalculatorTest.java +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -25,182 +25,182 @@ void setUp() { } @Test - void calculate_additionPositiveOperands_ok() { + void calculate_additionPositiveOperands_Ok() { double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, ADDITION); double expected = A_POSITIVE + B_POSITIVE; assertEquals(expected, actual); } @Test - void calculate_additionNegativeOperands_ok() { + void calculate_additionNegativeOperands_Ok() { double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, ADDITION); double expected = A_NEGATIVE + B_NEGATIVE; assertEquals(expected, actual); } @Test - void calculate_additionWithFirstNegativeOperand_ok() { + void calculate_additionWithFirstNegativeOperand_Ok() { double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, ADDITION); double expected = A_NEGATIVE + A_POSITIVE; assertEquals(expected, actual); } @Test - void calculate_additionMinOperands_ok() { + void calculate_additionMinOperands_Ok() { double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, ADDITION); double expected = Double.MIN_VALUE + Double.MIN_VALUE; assertEquals(expected, actual); } @Test - void calculate_additionMaxValuesOperands_ok() { + void calculate_additionMaxValuesOperands_Ok() { double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, ADDITION); double expected = Double.MAX_VALUE + Double.MAX_VALUE; assertEquals(expected, actual); } @Test - void calculate_additionMaxAndMinOperands_ok() { + void calculate_additionMaxAndMinOperands_Ok() { double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, ADDITION); double expected = Double.MAX_VALUE + Double.MIN_VALUE; assertEquals(expected, actual); } @Test - void calculate_subtractionPositiveOperands_ok() { + void calculate_subtractionPositiveOperands_Ok() { double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, SUBTRACTION); double expected = A_POSITIVE - B_POSITIVE; assertEquals(expected, actual); } @Test - void calculate_subtractionNegativeOperands_ok() { + void calculate_subtractionNegativeOperands_Ok() { double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, SUBTRACTION); double expected = A_NEGATIVE - B_NEGATIVE; assertEquals(expected, actual); } @Test - void calculate_subtractionWithFirstNegativeOperand_ok() { + void calculate_subtractionWithFirstNegativeOperand_Ok() { double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, SUBTRACTION); double expected = A_NEGATIVE - A_POSITIVE; assertEquals(expected, actual); } @Test - void calculate_subtractionWithSecondNegativeOperand_ok() { + void calculate_subtractionWithSecondNegativeOperand_Ok() { double actual = calculator.calculate(A_POSITIVE, A_NEGATIVE, SUBTRACTION); double expected = A_POSITIVE - A_NEGATIVE; assertEquals(expected, actual); } @Test - void calculate_subtractionMinOperands_ok() { + void calculate_subtractionMinOperands_Ok() { double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, SUBTRACTION); double expected = Double.MIN_VALUE - Double.MIN_VALUE; assertEquals(expected, actual); } @Test - void calculate_subtractionMaxOperands_ok() { + void calculate_subtractionMaxOperands_Ok() { double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, SUBTRACTION); double expected = Double.MAX_VALUE - Double.MAX_VALUE; assertEquals(expected, actual); } @Test - void calculate_subtractionMinAndMaxOperands_ok() { + void calculate_subtractionMinAndMaxOperands_Ok() { double actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, SUBTRACTION); double expected = Double.MIN_VALUE - Double.MAX_VALUE; assertEquals(expected, actual); } @Test - void calculate_multiplicationPositiveOperands_ok() { + void calculate_multiplicationPositiveOperands_Ok() { double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, MULTIPLICATION); double expected = A_POSITIVE * B_POSITIVE; assertEquals(expected, actual); } @Test - void calculate_multiplicationNegativeOperands_ok() { + void calculate_multiplicationNegativeOperands_Ok() { double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, MULTIPLICATION); double expected = A_NEGATIVE * B_NEGATIVE; assertEquals(expected, actual); } @Test - void calculate_multiplicationWithFirstNegativeOperand_ok() { + void calculate_multiplicationWithFirstNegativeOperand_Ok() { double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, MULTIPLICATION); double expected = A_NEGATIVE * A_POSITIVE; assertEquals(expected, actual); } @Test - void calculate_multiplicationMinOperands_ok() { + void calculate_multiplicationMinOperands_Ok() { double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, MULTIPLICATION); double expected = Double.MIN_VALUE * Double.MIN_VALUE; assertEquals(expected, actual); } @Test - void calculate_multiplicationMaxValuesOperands_ok() { + void calculate_multiplicationMaxValuesOperands_Ok() { double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, MULTIPLICATION); double expected = Double.MAX_VALUE * Double.MAX_VALUE; assertEquals(expected, actual); } @Test - void calculate_multiplicationMaxAndMinOperands_ok() { + void calculate_multiplicationMaxAndMinOperands_Ok() { double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, MULTIPLICATION); double expected = Double.MAX_VALUE * Double.MIN_VALUE; assertEquals(expected, actual); } @Test - void calculate_divisionPositiveOperands_ok() { + void calculate_divisionPositiveOperands_Ok() { double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, DIVISION); double expected = A_POSITIVE / B_POSITIVE; assertEquals(expected, actual); } @Test - void calculate_divisionNegativeOperands_ok() { + void calculate_divisionNegativeOperands_Ok() { double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, DIVISION); double expected = A_NEGATIVE / B_NEGATIVE; assertEquals(expected, actual); } @Test - void calculate_divisionWithFirstNegativeOperand_ok() { + void calculate_divisionWithFirstNegativeOperand_Ok() { double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, DIVISION); double expected = A_NEGATIVE / A_POSITIVE; assertEquals(expected, actual); } @Test - void calculate_divisionWithSecondNegativeOperand_ok() { + void calculate_divisionWithSecondNegativeOperand_Ok() { double actual = calculator.calculate(A_POSITIVE, A_NEGATIVE, DIVISION); double expected = A_POSITIVE / A_NEGATIVE; assertEquals(expected, actual); } @Test - void calculate_divisionMinOperands_ok() { + void calculate_divisionMinOperands_Ok() { double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, DIVISION); double expected = Double.MIN_VALUE / Double.MIN_VALUE; assertEquals(expected, actual); } @Test - void calculate_divisionMaxOperands_ok() { + void calculate_divisionMaxOperands_Ok() { double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, DIVISION); double expected = Double.MAX_VALUE / Double.MAX_VALUE; assertEquals(expected, actual); } @Test - void calculate_divisionMinAndMaxOperands_ok() { + void calculate_divisionMinAndMaxOperands_Ok() { double actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, DIVISION); double expected = Double.MIN_VALUE / Double.MAX_VALUE; assertEquals(expected, actual); @@ -214,56 +214,56 @@ void calculate_divisionByZero_notOk() { } @Test - void calculate_exponentiationPositiveToPositiveValue_ok() { + void calculate_exponentiationPositiveToPositiveValue_Ok() { double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, EXPONENTIATION); double expected = Math.pow(A_POSITIVE, B_POSITIVE); assertEquals(expected, actual); } @Test - void calculate_exponentiationNegativeToPositiveValue_ok() { + void calculate_exponentiationNegativeToPositiveValue_Ok() { double actual = calculator.calculate(A_NEGATIVE, B_POSITIVE, EXPONENTIATION); double expected = Math.pow(A_NEGATIVE, B_POSITIVE); assertEquals(expected, actual); } @Test - void calculate_exponentiationPositiveToNegativeValue_ok() { + void calculate_exponentiationPositiveToNegativeValue_Ok() { double actual = calculator.calculate(A_POSITIVE, B_NEGATIVE, EXPONENTIATION); double expected = Math.pow(A_POSITIVE, B_NEGATIVE); assertEquals(expected, actual); } @Test - void calculate_exponentiationNegativeToNegativeValue_ok() { + void calculate_exponentiationNegativeToNegativeValue_Ok() { double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, EXPONENTIATION); double expected = Math.pow(A_NEGATIVE, B_NEGATIVE); assertEquals(expected, actual); } @Test - void calculate_exponentiationPositiveValueToZero_ok() { + void calculate_exponentiationPositiveValueToZero_Ok() { double actual = calculator.calculate(A_POSITIVE, ZERO, EXPONENTIATION); double expected = Math.pow(A_POSITIVE, ZERO); assertEquals(expected, actual); } @Test - void calculate_exponentiationNegativeValueToZero_ok() { + void calculate_exponentiationNegativeValueToZero_Ok() { double actual = calculator.calculate(A_NEGATIVE, ZERO, EXPONENTIATION); double expected = Math.pow(A_NEGATIVE, ZERO); assertEquals(expected, actual); } @Test - void calculate_exponentiationZeroToPositiveValue_ok() { + void calculate_exponentiationZeroToPositiveValue_Ok() { double actual = calculator.calculate(ZERO, A_POSITIVE, EXPONENTIATION); double expected = Math.pow(ZERO, A_POSITIVE); assertEquals(expected, actual); } @Test - void calculate_exponentiationZeroToNegativeValue_ok() { + void calculate_exponentiationZeroToNegativeValue_Ok() { double actual = calculator.calculate(ZERO, A_NEGATIVE, EXPONENTIATION); double expected = Math.pow(ZERO, A_NEGATIVE); assertEquals(expected, actual); From 4e1fb11435ddcedd5aa583bfea963b35dfa2c6a5 Mon Sep 17 00:00:00 2001 From: Roman Dandali Date: Tue, 14 Sep 2021 11:49:17 +0300 Subject: [PATCH 3/6] similar tests are combined --- .../java/core/basesyntax/CalculatorTest.java | 46 ++++++++----------- 1 file changed, 18 insertions(+), 28 deletions(-) diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java index 1b1b743a..0dc910a9 100644 --- a/src/test/java/core/basesyntax/CalculatorTest.java +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -214,58 +214,42 @@ void calculate_divisionByZero_notOk() { } @Test - void calculate_exponentiationPositiveToPositiveValue_Ok() { + void calculate_exponentiationToPositiveValue_Ok() { double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, EXPONENTIATION); double expected = Math.pow(A_POSITIVE, B_POSITIVE); assertEquals(expected, actual); - } - - @Test - void calculate_exponentiationNegativeToPositiveValue_Ok() { - double actual = calculator.calculate(A_NEGATIVE, B_POSITIVE, EXPONENTIATION); - double expected = Math.pow(A_NEGATIVE, B_POSITIVE); + actual = calculator.calculate(A_NEGATIVE, B_POSITIVE, EXPONENTIATION); + expected = Math.pow(A_NEGATIVE, B_POSITIVE); assertEquals(expected, actual); } @Test - void calculate_exponentiationPositiveToNegativeValue_Ok() { + void calculate_exponentiationToNegativeValue_Ok() { double actual = calculator.calculate(A_POSITIVE, B_NEGATIVE, EXPONENTIATION); double expected = Math.pow(A_POSITIVE, B_NEGATIVE); assertEquals(expected, actual); - } - - @Test - void calculate_exponentiationNegativeToNegativeValue_Ok() { - double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, EXPONENTIATION); - double expected = Math.pow(A_NEGATIVE, B_NEGATIVE); + actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, EXPONENTIATION); + expected = Math.pow(A_NEGATIVE, B_NEGATIVE); assertEquals(expected, actual); } @Test - void calculate_exponentiationPositiveValueToZero_Ok() { + void calculate_exponentiationValueToZero_Ok() { double actual = calculator.calculate(A_POSITIVE, ZERO, EXPONENTIATION); double expected = Math.pow(A_POSITIVE, ZERO); assertEquals(expected, actual); - } - - @Test - void calculate_exponentiationNegativeValueToZero_Ok() { - double actual = calculator.calculate(A_NEGATIVE, ZERO, EXPONENTIATION); - double expected = Math.pow(A_NEGATIVE, ZERO); + actual = calculator.calculate(A_NEGATIVE, ZERO, EXPONENTIATION); + expected = Math.pow(A_NEGATIVE, ZERO); assertEquals(expected, actual); } @Test - void calculate_exponentiationZeroToPositiveValue_Ok() { + void calculate_exponentiationZero_Ok() { double actual = calculator.calculate(ZERO, A_POSITIVE, EXPONENTIATION); double expected = Math.pow(ZERO, A_POSITIVE); assertEquals(expected, actual); - } - - @Test - void calculate_exponentiationZeroToNegativeValue_Ok() { - double actual = calculator.calculate(ZERO, A_NEGATIVE, EXPONENTIATION); - double expected = Math.pow(ZERO, A_NEGATIVE); + actual = calculator.calculate(ZERO, A_NEGATIVE, EXPONENTIATION); + expected = Math.pow(ZERO, A_NEGATIVE); assertEquals(expected, actual); } @@ -274,5 +258,11 @@ void calculate_illegalOperation_notOk() { assertThrows(IllegalOperationException.class, () -> { calculator.calculate(A_POSITIVE, B_NEGATIVE, '%'); }); + assertThrows(IllegalOperationException.class, () -> { + calculator.calculate(A_POSITIVE, B_NEGATIVE, '#'); + }); + assertThrows(IllegalOperationException.class, () -> { + calculator.calculate(A_POSITIVE, B_NEGATIVE, '<'); + }); } } From 43d3f7eac74ff059f061d72fdc426aed6f971777 Mon Sep 17 00:00:00 2001 From: Roman Dandali Date: Tue, 14 Sep 2021 13:03:00 +0300 Subject: [PATCH 4/6] BeforeEach -> BeforeAll --- src/test/java/core/basesyntax/CalculatorTest.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java index 0dc910a9..8754f213 100644 --- a/src/test/java/core/basesyntax/CalculatorTest.java +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -3,7 +3,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; -import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; class CalculatorTest { @@ -17,10 +17,10 @@ class CalculatorTest { private static final char MULTIPLICATION = '*'; private static final char DIVISION = '/'; private static final char EXPONENTIATION = '^'; - private SimpleCalculator calculator; + private static SimpleCalculator calculator; - @BeforeEach - void setUp() { + @BeforeAll + static void beforeAll() { calculator = new Calculator(); } From 4af6231cafed85134523d5a4270b41d9cf7a00cd Mon Sep 17 00:00:00 2001 From: Roman Dandali Date: Tue, 14 Sep 2021 14:42:25 +0300 Subject: [PATCH 5/6] Added all mentor recommendations --- .../java/core/basesyntax/CalculatorTest.java | 177 ++++++++++-------- 1 file changed, 95 insertions(+), 82 deletions(-) diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java index 8754f213..632f558e 100644 --- a/src/test/java/core/basesyntax/CalculatorTest.java +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -7,10 +7,11 @@ import org.junit.jupiter.api.Test; class CalculatorTest { - private static final double A_POSITIVE = 1.23; - private static final double B_POSITIVE = 12.345; - private static final double A_NEGATIVE = -123.456; - private static final double B_NEGATIVE = -5.0; + private static final double FIRST_POSITIVE_OPERAND = 1.5; + private static final double SECOND_POSITIVE_OPERAND = 8.50; + private static final double FIRST_NEGATIVE_OPERAND = -100.450; + private static final double SECOND_NEGATIVE_OPERAND = -5.0; + private static final double DELTA = 0.0001; private static final byte ZERO = 0; private static final char ADDITION = '+'; private static final char SUBTRACTION = '-'; @@ -18,6 +19,8 @@ class CalculatorTest { private static final char DIVISION = '/'; private static final char EXPONENTIATION = '^'; private static SimpleCalculator calculator; + private double expected; + private double actual; @BeforeAll static void beforeAll() { @@ -26,243 +29,253 @@ static void beforeAll() { @Test void calculate_additionPositiveOperands_Ok() { - double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, ADDITION); - double expected = A_POSITIVE + B_POSITIVE; + actual = calculator.calculate(FIRST_POSITIVE_OPERAND, SECOND_POSITIVE_OPERAND, ADDITION); + expected = 10; assertEquals(expected, actual); } @Test void calculate_additionNegativeOperands_Ok() { - double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, ADDITION); - double expected = A_NEGATIVE + B_NEGATIVE; + actual = calculator.calculate(FIRST_NEGATIVE_OPERAND, SECOND_NEGATIVE_OPERAND, ADDITION); + expected = -105.450; assertEquals(expected, actual); } @Test void calculate_additionWithFirstNegativeOperand_Ok() { - double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, ADDITION); - double expected = A_NEGATIVE + A_POSITIVE; + actual = calculator.calculate(FIRST_NEGATIVE_OPERAND, FIRST_POSITIVE_OPERAND, ADDITION); + expected = -98.95; assertEquals(expected, actual); } @Test void calculate_additionMinOperands_Ok() { - double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, ADDITION); - double expected = Double.MIN_VALUE + Double.MIN_VALUE; - assertEquals(expected, actual); + actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, ADDITION); + expected = Double.MIN_VALUE; + assertEquals(expected, actual, DELTA); } @Test void calculate_additionMaxValuesOperands_Ok() { - double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, ADDITION); - double expected = Double.MAX_VALUE + Double.MAX_VALUE; - assertEquals(expected, actual); + actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, ADDITION); + expected = Double.POSITIVE_INFINITY; + assertEquals(expected, actual, DELTA); } @Test void calculate_additionMaxAndMinOperands_Ok() { - double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, ADDITION); - double expected = Double.MAX_VALUE + Double.MIN_VALUE; - assertEquals(expected, actual); + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, ADDITION); + expected = Double.MAX_VALUE; + assertEquals(expected, actual, DELTA); } @Test void calculate_subtractionPositiveOperands_Ok() { - double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, SUBTRACTION); - double expected = A_POSITIVE - B_POSITIVE; + actual = calculator.calculate(FIRST_POSITIVE_OPERAND, SECOND_POSITIVE_OPERAND, SUBTRACTION); + expected = -7.0; assertEquals(expected, actual); } @Test void calculate_subtractionNegativeOperands_Ok() { - double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, SUBTRACTION); - double expected = A_NEGATIVE - B_NEGATIVE; + actual = calculator.calculate(FIRST_NEGATIVE_OPERAND, SECOND_NEGATIVE_OPERAND, SUBTRACTION); + expected = -95.45; assertEquals(expected, actual); } @Test void calculate_subtractionWithFirstNegativeOperand_Ok() { - double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, SUBTRACTION); - double expected = A_NEGATIVE - A_POSITIVE; + actual = calculator.calculate(FIRST_NEGATIVE_OPERAND, FIRST_POSITIVE_OPERAND, SUBTRACTION); + expected = -101.95; assertEquals(expected, actual); } @Test void calculate_subtractionWithSecondNegativeOperand_Ok() { - double actual = calculator.calculate(A_POSITIVE, A_NEGATIVE, SUBTRACTION); - double expected = A_POSITIVE - A_NEGATIVE; + actual = calculator.calculate(FIRST_POSITIVE_OPERAND, FIRST_NEGATIVE_OPERAND, SUBTRACTION); + expected = 101.95; assertEquals(expected, actual); } @Test void calculate_subtractionMinOperands_Ok() { - double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, SUBTRACTION); - double expected = Double.MIN_VALUE - Double.MIN_VALUE; - assertEquals(expected, actual); + actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, SUBTRACTION); + expected = Double.MIN_VALUE; + assertEquals(expected, actual, DELTA); } @Test void calculate_subtractionMaxOperands_Ok() { - double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, SUBTRACTION); - double expected = Double.MAX_VALUE - Double.MAX_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, SUBTRACTION); + expected = ZERO; assertEquals(expected, actual); } @Test void calculate_subtractionMinAndMaxOperands_Ok() { - double actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, SUBTRACTION); - double expected = Double.MIN_VALUE - Double.MAX_VALUE; - assertEquals(expected, actual); + actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, SUBTRACTION); + expected = -Double.MAX_VALUE; + assertEquals(expected, actual, DELTA); } @Test void calculate_multiplicationPositiveOperands_Ok() { - double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, MULTIPLICATION); - double expected = A_POSITIVE * B_POSITIVE; + actual = calculator + .calculate(FIRST_POSITIVE_OPERAND, SECOND_POSITIVE_OPERAND, MULTIPLICATION); + expected = 12.75; assertEquals(expected, actual); } @Test void calculate_multiplicationNegativeOperands_Ok() { - double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, MULTIPLICATION); - double expected = A_NEGATIVE * B_NEGATIVE; + actual = calculator + .calculate(FIRST_NEGATIVE_OPERAND, SECOND_NEGATIVE_OPERAND, MULTIPLICATION); + expected = 502.25; assertEquals(expected, actual); } @Test void calculate_multiplicationWithFirstNegativeOperand_Ok() { - double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, MULTIPLICATION); - double expected = A_NEGATIVE * A_POSITIVE; + actual = calculator + .calculate(FIRST_NEGATIVE_OPERAND, FIRST_POSITIVE_OPERAND, MULTIPLICATION); + expected = -150.675; assertEquals(expected, actual); } @Test void calculate_multiplicationMinOperands_Ok() { - double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, MULTIPLICATION); - double expected = Double.MIN_VALUE * Double.MIN_VALUE; - assertEquals(expected, actual); + actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, MULTIPLICATION); + expected = Double.MIN_VALUE; + assertEquals(expected, actual, DELTA); } @Test void calculate_multiplicationMaxValuesOperands_Ok() { - double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, MULTIPLICATION); - double expected = Double.MAX_VALUE * Double.MAX_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, MULTIPLICATION); + expected = Double.POSITIVE_INFINITY; assertEquals(expected, actual); } @Test void calculate_multiplicationMaxAndMinOperands_Ok() { - double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, MULTIPLICATION); - double expected = Double.MAX_VALUE * Double.MIN_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, MULTIPLICATION); + expected = 8.881784197001251E-16; assertEquals(expected, actual); } @Test void calculate_divisionPositiveOperands_Ok() { - double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, DIVISION); - double expected = A_POSITIVE / B_POSITIVE; + actual = calculator + .calculate(FIRST_POSITIVE_OPERAND, SECOND_POSITIVE_OPERAND, DIVISION); + expected = 0.17647058823529413; assertEquals(expected, actual); } @Test void calculate_divisionNegativeOperands_Ok() { - double actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, DIVISION); - double expected = A_NEGATIVE / B_NEGATIVE; + actual = calculator + .calculate(FIRST_NEGATIVE_OPERAND, SECOND_NEGATIVE_OPERAND, DIVISION); + expected = 20.09; assertEquals(expected, actual); } @Test void calculate_divisionWithFirstNegativeOperand_Ok() { - double actual = calculator.calculate(A_NEGATIVE, A_POSITIVE, DIVISION); - double expected = A_NEGATIVE / A_POSITIVE; + actual = calculator + .calculate(FIRST_NEGATIVE_OPERAND, FIRST_POSITIVE_OPERAND, DIVISION); + expected = -66.96666666666667; assertEquals(expected, actual); } @Test void calculate_divisionWithSecondNegativeOperand_Ok() { - double actual = calculator.calculate(A_POSITIVE, A_NEGATIVE, DIVISION); - double expected = A_POSITIVE / A_NEGATIVE; + actual = calculator.calculate(FIRST_POSITIVE_OPERAND, FIRST_NEGATIVE_OPERAND, DIVISION); + expected = -0.014932802389248382; assertEquals(expected, actual); } @Test void calculate_divisionMinOperands_Ok() { - double actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, DIVISION); - double expected = Double.MIN_VALUE / Double.MIN_VALUE; + actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, DIVISION); + expected = 1; assertEquals(expected, actual); } @Test void calculate_divisionMaxOperands_Ok() { - double actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, DIVISION); - double expected = Double.MAX_VALUE / Double.MAX_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, DIVISION); + expected = 1; assertEquals(expected, actual); } @Test void calculate_divisionMinAndMaxOperands_Ok() { - double actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, DIVISION); - double expected = Double.MIN_VALUE / Double.MAX_VALUE; + actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, DIVISION); + expected = ZERO; assertEquals(expected, actual); } @Test void calculate_divisionByZero_notOk() { assertThrows(RuntimeException.class, () -> { - calculator.calculate(A_POSITIVE, ZERO, DIVISION); + calculator.calculate(FIRST_POSITIVE_OPERAND, ZERO, DIVISION); }); } @Test void calculate_exponentiationToPositiveValue_Ok() { - double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, EXPONENTIATION); - double expected = Math.pow(A_POSITIVE, B_POSITIVE); + actual = calculator + .calculate(FIRST_POSITIVE_OPERAND, SECOND_POSITIVE_OPERAND, EXPONENTIATION); + expected = 31.388871489063344; assertEquals(expected, actual); - actual = calculator.calculate(A_NEGATIVE, B_POSITIVE, EXPONENTIATION); - expected = Math.pow(A_NEGATIVE, B_POSITIVE); + actual = calculator + .calculate(FIRST_NEGATIVE_OPERAND, SECOND_POSITIVE_OPERAND, EXPONENTIATION); + expected = Double.NaN; assertEquals(expected, actual); } @Test void calculate_exponentiationToNegativeValue_Ok() { - double actual = calculator.calculate(A_POSITIVE, B_NEGATIVE, EXPONENTIATION); - double expected = Math.pow(A_POSITIVE, B_NEGATIVE); + actual = calculator + .calculate(FIRST_POSITIVE_OPERAND, SECOND_NEGATIVE_OPERAND, EXPONENTIATION); + expected = 0.13168724279835392; assertEquals(expected, actual); - actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, EXPONENTIATION); - expected = Math.pow(A_NEGATIVE, B_NEGATIVE); + actual = calculator + .calculate(FIRST_NEGATIVE_OPERAND, SECOND_NEGATIVE_OPERAND, EXPONENTIATION); + expected = -9.77800589098601E-11; assertEquals(expected, actual); } @Test void calculate_exponentiationValueToZero_Ok() { - double actual = calculator.calculate(A_POSITIVE, ZERO, EXPONENTIATION); - double expected = Math.pow(A_POSITIVE, ZERO); + actual = calculator.calculate(FIRST_POSITIVE_OPERAND, ZERO, EXPONENTIATION); + expected = 1; assertEquals(expected, actual); - actual = calculator.calculate(A_NEGATIVE, ZERO, EXPONENTIATION); - expected = Math.pow(A_NEGATIVE, ZERO); + actual = calculator.calculate(FIRST_NEGATIVE_OPERAND, ZERO, EXPONENTIATION); + expected = Math.pow(FIRST_NEGATIVE_OPERAND, ZERO); assertEquals(expected, actual); } @Test void calculate_exponentiationZero_Ok() { - double actual = calculator.calculate(ZERO, A_POSITIVE, EXPONENTIATION); - double expected = Math.pow(ZERO, A_POSITIVE); + actual = calculator.calculate(ZERO, FIRST_POSITIVE_OPERAND, EXPONENTIATION); + expected = ZERO; assertEquals(expected, actual); - actual = calculator.calculate(ZERO, A_NEGATIVE, EXPONENTIATION); - expected = Math.pow(ZERO, A_NEGATIVE); + actual = calculator.calculate(ZERO, FIRST_NEGATIVE_OPERAND, EXPONENTIATION); + expected = Double.POSITIVE_INFINITY; assertEquals(expected, actual); } @Test void calculate_illegalOperation_notOk() { assertThrows(IllegalOperationException.class, () -> { - calculator.calculate(A_POSITIVE, B_NEGATIVE, '%'); + calculator.calculate(FIRST_POSITIVE_OPERAND, SECOND_NEGATIVE_OPERAND, '%'); }); assertThrows(IllegalOperationException.class, () -> { - calculator.calculate(A_POSITIVE, B_NEGATIVE, '#'); + calculator.calculate(FIRST_POSITIVE_OPERAND, SECOND_NEGATIVE_OPERAND, '#'); }); assertThrows(IllegalOperationException.class, () -> { - calculator.calculate(A_POSITIVE, B_NEGATIVE, '<'); + calculator.calculate(FIRST_POSITIVE_OPERAND, SECOND_NEGATIVE_OPERAND, '<'); }); } } From 65561bc61121e7a6c651972ecad0ac897c34d7d3 Mon Sep 17 00:00:00 2001 From: Roman Dandali Date: Tue, 14 Sep 2021 14:45:33 +0300 Subject: [PATCH 6/6] Fixed calculate_exponentiationValueToZero_Ok() method --- src/test/java/core/basesyntax/CalculatorTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java index 632f558e..c829139b 100644 --- a/src/test/java/core/basesyntax/CalculatorTest.java +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -252,7 +252,7 @@ void calculate_exponentiationValueToZero_Ok() { expected = 1; assertEquals(expected, actual); actual = calculator.calculate(FIRST_NEGATIVE_OPERAND, ZERO, EXPONENTIATION); - expected = Math.pow(FIRST_NEGATIVE_OPERAND, ZERO); + expected = 1; assertEquals(expected, actual); }