From f4deb7c82393c677ab4de22795d37a5143a10eb5 Mon Sep 17 00:00:00 2001 From: SergiiLonskyi Date: Mon, 13 Sep 2021 18:54:40 +0300 Subject: [PATCH 1/2] implemented lambda calculator --- pom.xml | 2 +- src/main/java/core/basesyntax/Calculator.java | 5 + .../basesyntax/CalculatorImplementation.java | 45 ++++ src/main/java/core/basesyntax/HelloWorld.java | 8 - .../CalculatorImplementationTest.java | 249 ++++++++++++++++++ .../java/core/basesyntax/HelloWorldTest.java | 8 - 6 files changed, 300 insertions(+), 17 deletions(-) create mode 100644 src/main/java/core/basesyntax/Calculator.java create mode 100644 src/main/java/core/basesyntax/CalculatorImplementation.java delete mode 100644 src/main/java/core/basesyntax/HelloWorld.java create mode 100644 src/test/java/core/basesyntax/CalculatorImplementationTest.java delete mode 100644 src/test/java/core/basesyntax/HelloWorldTest.java diff --git a/pom.xml b/pom.xml index edd71909..adca8e20 100644 --- a/pom.xml +++ b/pom.xml @@ -15,7 +15,7 @@ https://raw.githubusercontent.com/mate-academy/style-guides/master/java/checkstyle.xml - 5.7.0 + 5.7.2 diff --git a/src/main/java/core/basesyntax/Calculator.java b/src/main/java/core/basesyntax/Calculator.java new file mode 100644 index 00000000..ff438c2d --- /dev/null +++ b/src/main/java/core/basesyntax/Calculator.java @@ -0,0 +1,5 @@ +package core.basesyntax; + +public interface Calculator { + double calculate(double firstNum, double secondNum, char mathOperation); +} diff --git a/src/main/java/core/basesyntax/CalculatorImplementation.java b/src/main/java/core/basesyntax/CalculatorImplementation.java new file mode 100644 index 00000000..ecfd1c58 --- /dev/null +++ b/src/main/java/core/basesyntax/CalculatorImplementation.java @@ -0,0 +1,45 @@ +package core.basesyntax; + +public class CalculatorImplementation implements Calculator { + + @Override + public double calculate(double firstNum, double secondNum, char mathOperation) { + switch (mathOperation) { + case '+': + return addition(firstNum, secondNum); + case '-': + return subtraction(firstNum, secondNum); + case '/': + return division(firstNum, secondNum); + case '*': + return multiplication(firstNum, secondNum); + case '^': + return raiseToPower(firstNum, secondNum); + default: + throw new RuntimeException("Wrong input. Please try again"); + } + } + + private double addition(double firstNum, double secondNum) { + return firstNum + secondNum; + } + + private double subtraction(double firstNum, double secondNum) { + return firstNum - secondNum; + } + + private double division(double firstNum, double secondNum) { + if (secondNum == 0) { + throw new ArithmeticException("Divide by zero"); + } + return firstNum / secondNum; + } + + private double multiplication(double firstNum, double secondNum) { + return firstNum * secondNum; + } + + private double raiseToPower(double firstNum, double secondNum) { + return Math.pow(firstNum, secondNum); + } +} 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/CalculatorImplementationTest.java b/src/test/java/core/basesyntax/CalculatorImplementationTest.java new file mode 100644 index 00000000..b7ec44a9 --- /dev/null +++ b/src/test/java/core/basesyntax/CalculatorImplementationTest.java @@ -0,0 +1,249 @@ +package core.basesyntax; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +class CalculatorImplementationTest { + private static CalculatorImplementation calculator; + private static double actual; + private static double expected; + private static final double DELTA = 0.00001; + private static final String DIVISION_OPERATION_MESSAGE = "Oops, operation of" + + " division doesn't work correctly"; + private static final String MULTIPLICATION_OPERATION_MESSAGE = "Oops, operation of" + + " multiplication doesn't work correctly"; + private static final String SUBTRACTION_OPERATION_MESSAGE = "Oops, operation of" + + " subtraction doesn't work correctly"; + private static final String ADDITION_OPERATION_MESSAGE = "Oops, operation of" + + " addition doesn't work correctly"; + + @BeforeAll + static void beforeAll() { + calculator = new CalculatorImplementation(); + } + + @Test + void addition_TwoPositiveOperands_Ok() { + actual = calculator.calculate(200.3, 0.7,'+'); + expected = 201.0; + assertEquals(actual, expected, DELTA, ADDITION_OPERATION_MESSAGE); + } + + @Test + void addition_TwoNegativeOperands_Ok() { + actual = calculator.calculate(-20.65, -10.35, '+'); + expected = -31.0; + assertEquals(actual, expected, DELTA, ADDITION_OPERATION_MESSAGE); + } + + @Test + void addition_positiveAndNegativeOperands_Ok() { + actual = calculator.calculate(150.0, -90.5, '+'); + expected = 59.5; + assertEquals(actual, expected, DELTA, ADDITION_OPERATION_MESSAGE); + } + + @Test + void addition_NegativeAndPositiveOperands_Ok() { + actual = calculator.calculate(-30.45, 30.05,'+'); + expected = -0.4; + assertEquals(actual, expected, DELTA, ADDITION_OPERATION_MESSAGE); + } + + @Test + void addition_WithZero_Ok() { + actual = calculator.calculate(0.0, 222.22, '+'); + expected = 222.22; + assertEquals(actual,expected); + actual = calculator.calculate(234.34, 0.0, '+'); + expected = 234.34; + assertEquals(actual,expected, DELTA, ADDITION_OPERATION_MESSAGE); + } + + @Test + void addition_MinAndMaxDoubleValues_Ok() { + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '+'); + expected = Double.MAX_VALUE + Double.MIN_VALUE; + assertEquals(actual, expected, DELTA, ADDITION_OPERATION_MESSAGE); + } + + @Test + void subtraction_TwoPositiveOperands_Ok() { + actual = calculator.calculate(125.75, 98.05, '-'); + expected = 27.7; + assertEquals(actual, expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + } + + @Test + void subtraction_TwoNegativeOperands_Ok() { + actual = calculator.calculate(-78.634, -18.995, '-'); + expected = -59.639; + assertEquals(actual, expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + } + + @Test + void subtraction_PositiveAndNegativeOperands_Ok() { + actual = calculator.calculate(123.456, -123.456, '-'); + expected = 246.912; + assertEquals(actual, expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + } + + @Test + void subtraction_NegativeAndPositiveOperands_Ok() { + actual = calculator.calculate(-232.98, 785.38, '-'); + expected = -1018.36; + assertEquals(actual, expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + } + + @Test + void subtraction_WithZero_Ok() { + actual = calculator.calculate(0.0, 444.44, '-'); + expected = -444.44; + assertEquals(actual,expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + actual = calculator.calculate(555.58, 0.0, '-'); + expected = 555.58; + assertEquals(actual,expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + } + + @Test + void subtraction_MinAndMaxDoubleValues_Ok() { + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '-'); + expected = Double.MAX_VALUE - Double.MIN_VALUE; + assertEquals(actual, expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + } + + @Test + void multiplication_TwoPositiveOperands_Ok() { + actual = calculator.calculate(2.34, 2.210,'*'); + expected = 5.1714; + assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + } + + @Test + void multiplication_TwoNegativeOperands_Ok() { + actual = calculator.calculate(-5.65, -7.77, '*'); + expected = 43.9005; + assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + } + + @Test + void multiplication_PositiveAndNegativeOperands_Ok() { + actual = calculator.calculate(15.0, -3.5, '*'); + expected = -52.5; + assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + } + + @Test + void multiplication_NegativeAndPositiveOperands_Ok() { + actual = calculator.calculate(-10.45, 10.05,'*'); + expected = -105.0225; + assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + } + + @Test + void multiplication_WithZero_Ok() { + actual = calculator.calculate(0.0, 12.22, '*'); + expected = 0; + assertEquals(actual,expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + actual = calculator.calculate(15.15, 0.0, '*'); + expected = 0; + assertEquals(actual,expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + } + + @Test + void multiplication_MinAndMaxDoubleValues_Ok() { + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '*'); + expected = Double.MAX_VALUE * Double.MIN_VALUE; + assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + } + + @Test + void division_TwoPositiveOperands_Ok() { + actual = calculator.calculate(60.30, 3.15,'/'); + expected = 19.1428571; + assertEquals(actual, expected, DELTA, DIVISION_OPERATION_MESSAGE); + } + + @Test + void division_TwoNegativeOperands_Ok() { + actual = calculator.calculate(-1.234, -0.456, '/'); + expected = 2.70614035; + assertEquals(actual, expected, DELTA, DIVISION_OPERATION_MESSAGE); + } + + @Test + void division_PositiveAndNegativeOperands_Ok() { + actual = calculator.calculate(15.0, -3.5, '/'); + expected = -4.28571429; + assertEquals(actual, expected, DELTA, DIVISION_OPERATION_MESSAGE); + } + + @Test + void division_NegativeAndPositiveOperands_Ok() { + actual = calculator.calculate(-10, 2,'/'); + expected = -5; + assertEquals(actual, expected, DELTA, DIVISION_OPERATION_MESSAGE); + } + + @Test + void division_WithZero_NotOk() { + actual = calculator.calculate(0.0, 35.35, '/'); + expected = 0; + assertEquals(actual,expected, DELTA, DIVISION_OPERATION_MESSAGE); + assertThrows(ArithmeticException.class, () -> calculator.calculate(100.55,0,'/')); + assertThrows(ArithmeticException.class, () -> calculator.calculate(0,0,'/')); + } + + @Test + void division_MinAndMaxDoubleValues_Ok() { + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '/'); + expected = Double.MAX_VALUE / Double.MIN_VALUE; + assertEquals(actual, expected, DELTA, DIVISION_OPERATION_MESSAGE); + } + + @Test + void raising_ToAPowerTwoPositiveOperands_Ok() { + actual = calculator.calculate(2, 5,'^'); + expected = 32; + assertEquals(actual, expected); + } + + @Test + void raising_ToAPowerTwoNegativeOperands_Ok() { + actual = calculator.calculate(-2, -5, '^'); + expected = -0.03125; + assertEquals(actual, expected); + } + + @Test + void raising_ToAPowerPositiveAndNegativeOperands_Ok() { + actual = calculator.calculate(2, -5, '^'); + expected = 0.03125; + assertEquals(actual, expected); + } + + @Test + void raising_ToAPowerNegativeAndPositiveOperands_Ok() { + actual = calculator.calculate(-10, 2,'^'); + expected = 100; + assertEquals(actual, expected); + } + + @Test + void raising_ToAPowerWithZero_Ok() { + actual = calculator.calculate(0, 2, '^'); + expected = 0; + assertEquals(actual,expected); + actual = calculator.calculate(2, 0, '^'); + expected = 1; + assertEquals(actual,expected); + } + + @Test + void illegalOperation_NotOk() { + assertThrows(RuntimeException.class, () -> calculator.calculate(20,4,'#')); + } +} 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 91182dcffb7b34b2782a4ce0b7a919e237017777 Mon Sep 17 00:00:00 2001 From: SergiiLonskyi Date: Mon, 13 Sep 2021 19:35:57 +0300 Subject: [PATCH 2/2] implemented lambda calculator --- .../CalculatorImplementationTest.java | 52 ++++++++++--------- 1 file changed, 28 insertions(+), 24 deletions(-) diff --git a/src/test/java/core/basesyntax/CalculatorImplementationTest.java b/src/test/java/core/basesyntax/CalculatorImplementationTest.java index b7ec44a9..5ea25ba6 100644 --- a/src/test/java/core/basesyntax/CalculatorImplementationTest.java +++ b/src/test/java/core/basesyntax/CalculatorImplementationTest.java @@ -7,9 +7,6 @@ import org.junit.jupiter.api.Test; class CalculatorImplementationTest { - private static CalculatorImplementation calculator; - private static double actual; - private static double expected; private static final double DELTA = 0.00001; private static final String DIVISION_OPERATION_MESSAGE = "Oops, operation of" + " division doesn't work correctly"; @@ -19,6 +16,9 @@ class CalculatorImplementationTest { + " subtraction doesn't work correctly"; private static final String ADDITION_OPERATION_MESSAGE = "Oops, operation of" + " addition doesn't work correctly"; + private static CalculatorImplementation calculator; + private static double actual; + private static double expected; @BeforeAll static void beforeAll() { @@ -27,7 +27,7 @@ static void beforeAll() { @Test void addition_TwoPositiveOperands_Ok() { - actual = calculator.calculate(200.3, 0.7,'+'); + actual = calculator.calculate(200.3, 0.7, '+'); expected = 201.0; assertEquals(actual, expected, DELTA, ADDITION_OPERATION_MESSAGE); } @@ -48,7 +48,7 @@ void addition_positiveAndNegativeOperands_Ok() { @Test void addition_NegativeAndPositiveOperands_Ok() { - actual = calculator.calculate(-30.45, 30.05,'+'); + actual = calculator.calculate(-30.45, 30.05, '+'); expected = -0.4; assertEquals(actual, expected, DELTA, ADDITION_OPERATION_MESSAGE); } @@ -57,10 +57,10 @@ void addition_NegativeAndPositiveOperands_Ok() { void addition_WithZero_Ok() { actual = calculator.calculate(0.0, 222.22, '+'); expected = 222.22; - assertEquals(actual,expected); + assertEquals(actual, expected); actual = calculator.calculate(234.34, 0.0, '+'); expected = 234.34; - assertEquals(actual,expected, DELTA, ADDITION_OPERATION_MESSAGE); + assertEquals(actual, expected, DELTA, ADDITION_OPERATION_MESSAGE); } @Test @@ -102,10 +102,10 @@ void subtraction_NegativeAndPositiveOperands_Ok() { void subtraction_WithZero_Ok() { actual = calculator.calculate(0.0, 444.44, '-'); expected = -444.44; - assertEquals(actual,expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + assertEquals(actual, expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); actual = calculator.calculate(555.58, 0.0, '-'); expected = 555.58; - assertEquals(actual,expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); + assertEquals(actual, expected, DELTA, SUBTRACTION_OPERATION_MESSAGE); } @Test @@ -117,7 +117,7 @@ void subtraction_MinAndMaxDoubleValues_Ok() { @Test void multiplication_TwoPositiveOperands_Ok() { - actual = calculator.calculate(2.34, 2.210,'*'); + actual = calculator.calculate(2.34, 2.210, '*'); expected = 5.1714; assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); } @@ -138,7 +138,7 @@ void multiplication_PositiveAndNegativeOperands_Ok() { @Test void multiplication_NegativeAndPositiveOperands_Ok() { - actual = calculator.calculate(-10.45, 10.05,'*'); + actual = calculator.calculate(-10.45, 10.05, '*'); expected = -105.0225; assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); } @@ -147,10 +147,10 @@ void multiplication_NegativeAndPositiveOperands_Ok() { void multiplication_WithZero_Ok() { actual = calculator.calculate(0.0, 12.22, '*'); expected = 0; - assertEquals(actual,expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); actual = calculator.calculate(15.15, 0.0, '*'); expected = 0; - assertEquals(actual,expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); + assertEquals(actual, expected, DELTA, MULTIPLICATION_OPERATION_MESSAGE); } @Test @@ -162,7 +162,7 @@ void multiplication_MinAndMaxDoubleValues_Ok() { @Test void division_TwoPositiveOperands_Ok() { - actual = calculator.calculate(60.30, 3.15,'/'); + actual = calculator.calculate(60.30, 3.15, '/'); expected = 19.1428571; assertEquals(actual, expected, DELTA, DIVISION_OPERATION_MESSAGE); } @@ -183,18 +183,22 @@ void division_PositiveAndNegativeOperands_Ok() { @Test void division_NegativeAndPositiveOperands_Ok() { - actual = calculator.calculate(-10, 2,'/'); + actual = calculator.calculate(-10, 2, '/'); expected = -5; assertEquals(actual, expected, DELTA, DIVISION_OPERATION_MESSAGE); } @Test - void division_WithZero_NotOk() { + void division_WithZero_Ok() { actual = calculator.calculate(0.0, 35.35, '/'); expected = 0; - assertEquals(actual,expected, DELTA, DIVISION_OPERATION_MESSAGE); - assertThrows(ArithmeticException.class, () -> calculator.calculate(100.55,0,'/')); - assertThrows(ArithmeticException.class, () -> calculator.calculate(0,0,'/')); + assertEquals(actual, expected, DELTA, DIVISION_OPERATION_MESSAGE); + } + + @Test + void division_WhenSecondOperandZero_NotOk() { + assertThrows(ArithmeticException.class, () -> calculator.calculate(100.55, 0, '/')); + assertThrows(ArithmeticException.class, () -> calculator.calculate(0, 0, '/')); } @Test @@ -206,7 +210,7 @@ void division_MinAndMaxDoubleValues_Ok() { @Test void raising_ToAPowerTwoPositiveOperands_Ok() { - actual = calculator.calculate(2, 5,'^'); + actual = calculator.calculate(2, 5, '^'); expected = 32; assertEquals(actual, expected); } @@ -227,7 +231,7 @@ void raising_ToAPowerPositiveAndNegativeOperands_Ok() { @Test void raising_ToAPowerNegativeAndPositiveOperands_Ok() { - actual = calculator.calculate(-10, 2,'^'); + actual = calculator.calculate(-10, 2, '^'); expected = 100; assertEquals(actual, expected); } @@ -236,14 +240,14 @@ void raising_ToAPowerNegativeAndPositiveOperands_Ok() { void raising_ToAPowerWithZero_Ok() { actual = calculator.calculate(0, 2, '^'); expected = 0; - assertEquals(actual,expected); + assertEquals(actual, expected); actual = calculator.calculate(2, 0, '^'); expected = 1; - assertEquals(actual,expected); + assertEquals(actual, expected); } @Test void illegalOperation_NotOk() { - assertThrows(RuntimeException.class, () -> calculator.calculate(20,4,'#')); + assertThrows(RuntimeException.class, () -> calculator.calculate(20, 4, '#')); } }