From f623261827e72d5816859d2547ea87aa617df489 Mon Sep 17 00:00:00 2001 From: Dmytro Heleta Date: Tue, 14 Sep 2021 15:45:56 +0300 Subject: [PATCH 1/3] implement calculator and write tests --- src/main/java/core/basesyntax/Calculator.java | 29 ++ src/main/java/core/basesyntax/HelloWorld.java | 8 - .../java/core/basesyntax/CalculatorTest.java | 299 ++++++++++++++++++ .../java/core/basesyntax/HelloWorldTest.java | 8 - 4 files changed, 328 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/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..7b887c82 --- /dev/null +++ b/src/main/java/core/basesyntax/Calculator.java @@ -0,0 +1,29 @@ +package core.basesyntax; + +public class Calculator { + private static final char PLUS_SIGN = '+'; + private static final char MINUS_SIGN = '-'; + private static final char MULTIPLY_SIGN = '*'; + private static final char DIVIDE_SIGN = '/'; + private static final char RAISING_SIGN = '^'; + + double calculate(double firstValue, double secondValue, char operation) { + switch (operation) { + case PLUS_SIGN: + return firstValue + secondValue; + case MINUS_SIGN: + return firstValue - secondValue; + case MULTIPLY_SIGN: + return firstValue * secondValue; + case DIVIDE_SIGN: + if (secondValue == 0) { + throw new ArithmeticException("Division by zero is forbidden"); + } + return firstValue / secondValue; + case RAISING_SIGN: + return Math.pow(firstValue,secondValue); + default: + throw new IllegalArgumentException("Argument is illegal"); + } + } +} 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/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java new file mode 100644 index 00000000..9595982e --- /dev/null +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -0,0 +1,299 @@ +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 char ADDITION_SIGN = '+'; + private static final char SUBTRACTION_SIGN = '-'; + private static final char MULTIPLICATION_SIGN = '*'; + private static final char DIVISION_SIGN = '/'; + private static final char RAISING_SIGN = '^'; + private static final double DELTA = 0.0001; + private Calculator calculator; + private double expected; + private double actual; + + @BeforeEach + void setUp() { + calculator = new Calculator(); + } + + @Test + void calculate_additionWithPositiveOperands_IsOk() { + expected = 13.37; + actual = calculator.calculate(12.37,1, ADDITION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithNegativeOperands_IsOk() { + expected = -14.01; + actual = calculator.calculate(-12,-2.01, ADDITION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithOneNegativeOperandAndOnePositive_IsOk() { + expected = -36; + actual = calculator.calculate(-100,64, ADDITION_SIGN); + assertEquals(expected, actual); + actual = calculator.calculate(64,-100, ADDITION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithZero_IsOk() { + expected = 0.02; + actual = calculator.calculate(0,0.02, ADDITION_SIGN); + assertEquals(expected, actual); + actual = calculator.calculate(0.02,0, ADDITION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_additionMaxOperands_IsOk() { + expected = Double.POSITIVE_INFINITY; + actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, ADDITION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_additionMinOperands_IsOk() { + expected = Double.MIN_VALUE + Double.MIN_VALUE; + actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, ADDITION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionWithPositiveOperands_IsOk() { + expected = 401; + actual = calculator.calculate(800,399,SUBTRACTION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionWithNegativeOperands_IsOk() { + expected = 5; + actual = calculator.calculate(-10,-15, SUBTRACTION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionWithOneNegativeOperandAndOnePositive_IsOk() { + expected = 110; + actual = calculator.calculate(90,-20,SUBTRACTION_SIGN); + assertEquals(expected, actual); + expected = -60; + actual = calculator.calculate(-40,20, SUBTRACTION_SIGN); + assertEquals(expected, actual); + } + + @Test + void calculate_subtractionWithZero_IsOk() { + expected = -1; + actual = calculator.calculate(-1,0, SUBTRACTION_SIGN); + assertEquals(expected, actual); + actual = calculator.calculate(-1,0, SUBTRACTION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_subtractionMinAndMaxValues_IsOk() { + expected = -Double.MAX_VALUE; + actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, SUBTRACTION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_subtractionMaxMinValues_IsOk() { + expected = Double.MAX_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, SUBTRACTION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_subtractionMaxValues_IsOk() { + expected = 0; + actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, SUBTRACTION_SIGN); + assertEquals(expected, actual); + + } + + @Test + public void calculate_subtractionIfBothOperandsAreMinValues_IsOk() { + expected = 0; + actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, SUBTRACTION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_multiplicationOfTwoPositiveOperands_IsOk() { + expected = 200; + actual = calculator.calculate(20, 10, MULTIPLICATION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_multiplicationOfTwoNegativeOperands_IsOk() { + expected = 8; + actual = calculator.calculate(-2, -4, MULTIPLICATION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_multiplicationOfPositiveAndNegative_IsOk() { + expected = -60; + actual = calculator.calculate(-15, 4, MULTIPLICATION_SIGN); + assertEquals(expected, actual); + actual = calculator.calculate(4, -15, MULTIPLICATION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_multiplicationZero_IsOk() { + expected = 0; + actual = calculator.calculate(0, 2, MULTIPLICATION_SIGN); + assertEquals(expected, actual); + actual = calculator.calculate(2, 0, MULTIPLICATION_SIGN); + assertEquals(expected, actual); + actual = calculator.calculate(0, 0, MULTIPLICATION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_multiplicationMinMax_IsOk() { + expected = Double.MIN_VALUE; + actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, MULTIPLICATION_SIGN); + assertEquals(expected, actual, DELTA); + expected = Double.POSITIVE_INFINITY; + actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, MULTIPLICATION_SIGN); + assertEquals(expected, actual, DELTA); + expected = 0; + actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, MULTIPLICATION_SIGN); + assertEquals(expected, actual, DELTA); + } + + @Test + public void calculate_divisionTwoPositiveOperands_IsOk() { + expected = 2; + actual = calculator.calculate(6, 3, DIVISION_SIGN); + assertEquals(expected, actual, DELTA); + } + + @Test + public void calculate_divisionTwoNegativeOperands_IsOk() { + expected = 1; + actual = calculator.calculate(-1, -1, DIVISION_SIGN); + assertEquals(expected, actual, DELTA); + } + + @Test + public void calculate_divisionPositiveNegative_IsOk() { + expected = -16; + actual = calculator.calculate(32, -2, DIVISION_SIGN); + assertEquals(expected, actual, DELTA); + expected = -0.0625; + actual = calculator.calculate(-2, 32, DIVISION_SIGN); + assertEquals(expected, actual, DELTA); + } + + @Test + public void calculate_divisionFirstOperandEqualsZero_IsOk() { + expected = 0; + actual = calculator.calculate(0, 10, DIVISION_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_divisionSecondOperandEqualsZero_isNotOk() { + assertThrows(ArithmeticException.class, + () -> calculator.calculate(5, 0, DIVISION_SIGN)); + } + + @Test + public void calculate_divisionMinAndMaxValues_IsOk() { + expected = Double.POSITIVE_INFINITY; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, DIVISION_SIGN); + assertEquals(expected, actual, DELTA); + } + + @Test + public void calculate_divisionMaxAndMinValues_IsOk() { + expected = Double.POSITIVE_INFINITY; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, DIVISION_SIGN); + assertEquals(expected, actual, DELTA); + } + + @Test + public void calculate_divisionOperandsAreMaxValues_IsOk() { + expected = 1; + actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, DIVISION_SIGN); + assertEquals(expected, actual, DELTA); + } + + @Test + public void calculate_divisionOperandsAreMinValues_IsOk() { + expected = 1; + actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, DIVISION_SIGN); + assertEquals(expected, actual, DELTA); + } + + @Test + public void calculate_raisePositiveValueToPositiveValue_IsOk() { + expected = 4; + actual = calculator.calculate(2, 2, RAISING_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_raisePositiveValueToNegativeValue_IsOk() { + expected = 0.25; + actual = calculator.calculate(2, -2, RAISING_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_raiseNegativeValueToPositiveValue_IsOk() { + expected = -64; + actual = calculator.calculate(-4,3, RAISING_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_raiseNegativeValueToNegativeValue_IsOk() { + expected = -0.008; + actual = calculator.calculate(-5, -3, RAISING_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_raisePositiveValueToZero_IsOk() { + expected = 1; + actual = calculator.calculate(10, 0, RAISING_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_raiseNegativeValueToZero_IsOk() { + expected = 1; + actual = calculator.calculate(-2, 0, RAISING_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_raiseZeroValueToPositiveValue_IsOk() { + expected = 0; + actual = calculator.calculate(0, 2, RAISING_SIGN); + assertEquals(expected, actual); + } + + @Test + public void calculate_illegalOperation_isNotOk() { + assertThrows(IllegalArgumentException.class, () + -> calculator.calculate(10, 25, '=')); + } +} 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 5370f67619a483fbc14d3ecb7a0518dce3d05a0c Mon Sep 17 00:00:00 2001 From: Dmytro Heleta Date: Tue, 14 Sep 2021 16:02:09 +0300 Subject: [PATCH 2/3] fix lculate_additionMinOperands_IsOk method --- src/test/java/core/basesyntax/CalculatorTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java index 9595982e..8119bd90 100644 --- a/src/test/java/core/basesyntax/CalculatorTest.java +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -63,9 +63,9 @@ void calculate_additionMaxOperands_IsOk() { @Test void calculate_additionMinOperands_IsOk() { - expected = Double.MIN_VALUE + Double.MIN_VALUE; + expected = Double.MIN_VALUE; actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, ADDITION_SIGN); - assertEquals(expected, actual); + assertEquals(expected, actual, DELTA); } @Test From 234c22ec6cef964b64fb1c284a307c63fd07e434 Mon Sep 17 00:00:00 2001 From: Dmytro Heleta Date: Tue, 14 Sep 2021 16:05:52 +0300 Subject: [PATCH 3/3] add additional tess for MAX and min additions --- src/test/java/core/basesyntax/CalculatorTest.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java index 8119bd90..6d3af486 100644 --- a/src/test/java/core/basesyntax/CalculatorTest.java +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -59,6 +59,9 @@ void calculate_additionMaxOperands_IsOk() { expected = Double.POSITIVE_INFINITY; actual = calculator.calculate(Double.MAX_VALUE, Double.MAX_VALUE, ADDITION_SIGN); assertEquals(expected, actual); + expected = Double.MAX_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, ADDITION_SIGN); + assertEquals(expected, actual, DELTA); } @Test @@ -66,6 +69,9 @@ void calculate_additionMinOperands_IsOk() { expected = Double.MIN_VALUE; actual = calculator.calculate(Double.MIN_VALUE, Double.MIN_VALUE, ADDITION_SIGN); assertEquals(expected, actual, DELTA); + expected = Double.MAX_VALUE; + actual = calculator.calculate(Double.MIN_VALUE, Double.MAX_VALUE, ADDITION_SIGN); + assertEquals(expected, actual, DELTA); } @Test