From 447d973eecc6bebca8fcc055393b75d0cc7aa7f2 Mon Sep 17 00:00:00 2001 From: Alex Hazniuk Date: Fri, 22 Oct 2021 09:34:05 +0300 Subject: [PATCH 1/2] implemented task lambda calc --- .../java/core/basesyntax/Calculation.java | 5 + src/main/java/core/basesyntax/Calculator.java | 21 ++ src/main/java/core/basesyntax/HelloWorld.java | 8 - .../basesyntax/IllegalOperationException.java | 7 + .../java/core/basesyntax/CalculatorTest.java | 212 ++++++++++++++++++ .../java/core/basesyntax/HelloWorldTest.java | 8 - 6 files changed, 245 insertions(+), 16 deletions(-) create mode 100644 src/main/java/core/basesyntax/Calculation.java 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/test/java/core/basesyntax/CalculatorTest.java delete mode 100644 src/test/java/core/basesyntax/HelloWorldTest.java diff --git a/src/main/java/core/basesyntax/Calculation.java b/src/main/java/core/basesyntax/Calculation.java new file mode 100644 index 00000000..971836fb --- /dev/null +++ b/src/main/java/core/basesyntax/Calculation.java @@ -0,0 +1,5 @@ +package core.basesyntax; + +public interface Calculation { + double calculate(double number1, double number2, char operation); +} diff --git a/src/main/java/core/basesyntax/Calculator.java b/src/main/java/core/basesyntax/Calculator.java new file mode 100644 index 00000000..62d7b255 --- /dev/null +++ b/src/main/java/core/basesyntax/Calculator.java @@ -0,0 +1,21 @@ +package core.basesyntax; + +public class Calculator implements Calculation { + @Override + public double calculate(double number1, double number2, char operation) { + switch (operation) { + case '+': + return number1 + number2; + case '-': + return number1 - number2; + case '*': + return number1 * number2; + case '/': + return number1 / number2; + case '^': + return Math.pow(number1, number2); + default: + throw new IllegalOperationException("Illegal operator"); + } + } +} 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..4689e504 --- /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/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java new file mode 100644 index 00000000..8df668a5 --- /dev/null +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -0,0 +1,212 @@ +package core.basesyntax; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +class CalculatorTest { + private static final double DELTA = 0.1; + private static Calculation count; + private double actual; + + @BeforeAll + public static void beforeAll() { + count = new Calculator(); + } + + @Test + public void calculate_addition_positiveOperands() { + actual = count.calculate(6, 7, '+'); + assertEquals(13, actual); + } + + @Test + public void calculate_addition_negativeOperands() { + actual = count.calculate(-9, -11, '+'); + assertEquals(-20, actual); + } + + @Test + public void calculate_addition_positiveNegativeOperands() { + actual = count.calculate(10, -20, '+'); + assertEquals(-10, actual); + } + + @Test + public void calculate_addition_zeroOperands() { + actual = count.calculate(0, 0, '+'); + assertEquals(0, actual); + } + + @Test + public void calculate_addition_operandsMinValues() { + actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '+'); + assertEquals(1.0E-323, actual); + } + + @Test + public void calculate_addition_operandsMaxValues() { + actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '+'); + assertTrue(Double.isInfinite(actual)); + } + + @Test + public void calculate_subtraction_positiveOperands() { + actual = count.calculate(6, 7, '-'); + assertEquals(-1, actual); + } + + @Test + public void calculate_subtraction_negativeOperands() { + actual = count.calculate(-9, -11, '-'); + assertEquals(2, actual); + } + + @Test + public void calculate_subtraction_positiveNegativeOperands() { + actual = count.calculate(10, -20, '-'); + assertEquals(30, actual); + } + + @Test + public void calculate_subtraction_zeroOperands() { + actual = count.calculate(0, 0, '-'); + assertEquals(0, actual); + } + + @Test + public void calculate_subtraction_operandsMinValues() { + actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '-'); + assertEquals(0, actual); + } + + @Test + public void calculate_subtraction_operandsMaxValues() { + actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '-'); + assertEquals(0, actual); + } + + @Test + public void calculate_multiplication_positiveOperands() { + actual = count.calculate(6, 7, '*'); + assertEquals(42, actual); + } + + @Test + public void calculate_multiplication_negativeOperands() { + actual = count.calculate(-9, -11, '*'); + assertEquals(99, actual); + } + + @Test + public void calculate_multiplication_positiveNegativeOperands() { + actual = count.calculate(10, -20, '*'); + assertEquals(-200, actual); + } + + @Test + public void calculate_multiplication_zeroOperands() { + actual = count.calculate(0, 2, '*'); + assertEquals(0, actual); + actual = count.calculate(2, 0, '*'); + assertEquals(0, actual); + actual = count.calculate(0, 0, '*'); + assertEquals(0, actual); + } + + @Test + public void calculate_multiplication_operandsMinValues() { + actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '*'); + assertEquals(0, actual); + } + + @Test + public void calculate_multiplication_operandsMaxValues() { + actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '*'); + assertTrue(Double.isInfinite(actual)); + } + + @Test + public void calculate_division_positiveOperands() { + actual = count.calculate(1.4, 1.2, '/'); + assertEquals(1.2, actual, DELTA); + } + + @Test + public void calculate_division_negativeOperands() { + actual = count.calculate(-10, -2, '/'); + assertEquals(5, actual); + } + + @Test + public void calculate_division_positiveNegativeOperands() { + actual = count.calculate(10, -2, '/'); + assertEquals(-5, actual); + } + + @Test + public void calculate_division_zeroDividendOperand() { + actual = count.calculate(0, 5, '/'); + assertEquals(0, actual); + } + + @Test + public void calculate_division_zeroDividerOperand() { + actual = count.calculate(5, 0, '/'); + assertTrue(Double.isInfinite(actual)); + } + + @Test + public void calculate_division_operandsMinValues() { + actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '/'); + assertEquals(1, actual); + } + + @Test + public void calculate_division_operandsMaxValues() { + actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '/'); + assertEquals(1, actual); + } + + @Test + void calculate_raising_positiveNegativeValue_positivePower() { + actual = count.calculate(2, 3, '^'); + assertEquals(8, actual); + actual = count.calculate(-2, 3, '^'); + assertEquals(-8, actual); + } + + @Test + void calculate_raising_positiveNegativeValue_negativePower() { + actual = count.calculate(2, -2, '^'); + assertEquals(0.25, actual); + actual = count.calculate(-2, -2, '^'); + assertEquals(0.25, actual); + } + + @Test + void calculate_raising_positiveNegativeValue_zeroPower() { + actual = count.calculate(2, 0, '^'); + assertEquals(1, actual); + actual = count.calculate(-2, 0, '^'); + assertEquals(1, actual); + } + + @Test + void calculate_raising_zeroValue_positiveNegativePower() { + actual = count.calculate(0, -2, '^'); + assertTrue(Double.isInfinite(actual)); + actual = count.calculate(0, 2, '^'); + assertEquals(0, actual); + } + + @Test + void calculate_illegalOperation_isNotOk() { + assertThrows(IllegalOperationException.class, () -> { + count.calculate(0, 2, '%'); + }); + } +} 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 09d59e1617827854b99d55542a506565a99466f1 Mon Sep 17 00:00:00 2001 From: Alex Hazniuk Date: Fri, 22 Oct 2021 10:29:06 +0300 Subject: [PATCH 2/2] fixed task lambda calc --- .../java/core/basesyntax/CalculatorTest.java | 62 +++++++++---------- 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java index 8df668a5..f53bc560 100644 --- a/src/test/java/core/basesyntax/CalculatorTest.java +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -10,7 +10,6 @@ class CalculatorTest { private static final double DELTA = 0.1; private static Calculation count; - private double actual; @BeforeAll public static void beforeAll() { @@ -19,97 +18,97 @@ public static void beforeAll() { @Test public void calculate_addition_positiveOperands() { - actual = count.calculate(6, 7, '+'); + double actual = count.calculate(6, 7, '+'); assertEquals(13, actual); } @Test public void calculate_addition_negativeOperands() { - actual = count.calculate(-9, -11, '+'); + double actual = count.calculate(-9, -11, '+'); assertEquals(-20, actual); } @Test public void calculate_addition_positiveNegativeOperands() { - actual = count.calculate(10, -20, '+'); + double actual = count.calculate(10, -20, '+'); assertEquals(-10, actual); } @Test public void calculate_addition_zeroOperands() { - actual = count.calculate(0, 0, '+'); + double actual = count.calculate(0, 0, '+'); assertEquals(0, actual); } @Test public void calculate_addition_operandsMinValues() { - actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '+'); + double actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '+'); assertEquals(1.0E-323, actual); } @Test public void calculate_addition_operandsMaxValues() { - actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '+'); + double actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '+'); assertTrue(Double.isInfinite(actual)); } @Test public void calculate_subtraction_positiveOperands() { - actual = count.calculate(6, 7, '-'); + double actual = count.calculate(6, 7, '-'); assertEquals(-1, actual); } @Test public void calculate_subtraction_negativeOperands() { - actual = count.calculate(-9, -11, '-'); + double actual = count.calculate(-9, -11, '-'); assertEquals(2, actual); } @Test public void calculate_subtraction_positiveNegativeOperands() { - actual = count.calculate(10, -20, '-'); + double actual = count.calculate(10, -20, '-'); assertEquals(30, actual); } @Test public void calculate_subtraction_zeroOperands() { - actual = count.calculate(0, 0, '-'); + double actual = count.calculate(0, 0, '-'); assertEquals(0, actual); } @Test public void calculate_subtraction_operandsMinValues() { - actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '-'); + double actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '-'); assertEquals(0, actual); } @Test public void calculate_subtraction_operandsMaxValues() { - actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '-'); + double actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '-'); assertEquals(0, actual); } @Test public void calculate_multiplication_positiveOperands() { - actual = count.calculate(6, 7, '*'); + double actual = count.calculate(6, 7, '*'); assertEquals(42, actual); } @Test public void calculate_multiplication_negativeOperands() { - actual = count.calculate(-9, -11, '*'); + double actual = count.calculate(-9, -11, '*'); assertEquals(99, actual); } @Test public void calculate_multiplication_positiveNegativeOperands() { - actual = count.calculate(10, -20, '*'); + double actual = count.calculate(10, -20, '*'); assertEquals(-200, actual); } @Test public void calculate_multiplication_zeroOperands() { - actual = count.calculate(0, 2, '*'); + double actual = count.calculate(0, 2, '*'); assertEquals(0, actual); actual = count.calculate(2, 0, '*'); assertEquals(0, actual); @@ -119,61 +118,61 @@ public void calculate_multiplication_zeroOperands() { @Test public void calculate_multiplication_operandsMinValues() { - actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '*'); + double actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '*'); assertEquals(0, actual); } @Test public void calculate_multiplication_operandsMaxValues() { - actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '*'); + double actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '*'); assertTrue(Double.isInfinite(actual)); } @Test public void calculate_division_positiveOperands() { - actual = count.calculate(1.4, 1.2, '/'); + double actual = count.calculate(1.4, 1.2, '/'); assertEquals(1.2, actual, DELTA); } @Test public void calculate_division_negativeOperands() { - actual = count.calculate(-10, -2, '/'); + double actual = count.calculate(-10, -2, '/'); assertEquals(5, actual); } @Test public void calculate_division_positiveNegativeOperands() { - actual = count.calculate(10, -2, '/'); + double actual = count.calculate(10, -2, '/'); assertEquals(-5, actual); } @Test public void calculate_division_zeroDividendOperand() { - actual = count.calculate(0, 5, '/'); + double actual = count.calculate(0, 5, '/'); assertEquals(0, actual); } @Test public void calculate_division_zeroDividerOperand() { - actual = count.calculate(5, 0, '/'); + double actual = count.calculate(5, 0, '/'); assertTrue(Double.isInfinite(actual)); } @Test public void calculate_division_operandsMinValues() { - actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '/'); + double actual = count.calculate(Double.MIN_VALUE, Double.MIN_VALUE, '/'); assertEquals(1, actual); } @Test public void calculate_division_operandsMaxValues() { - actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '/'); + double actual = count.calculate(Double.MAX_VALUE, Double.MAX_VALUE, '/'); assertEquals(1, actual); } @Test void calculate_raising_positiveNegativeValue_positivePower() { - actual = count.calculate(2, 3, '^'); + double actual = count.calculate(2, 3, '^'); assertEquals(8, actual); actual = count.calculate(-2, 3, '^'); assertEquals(-8, actual); @@ -181,7 +180,7 @@ void calculate_raising_positiveNegativeValue_positivePower() { @Test void calculate_raising_positiveNegativeValue_negativePower() { - actual = count.calculate(2, -2, '^'); + double actual = count.calculate(2, -2, '^'); assertEquals(0.25, actual); actual = count.calculate(-2, -2, '^'); assertEquals(0.25, actual); @@ -189,7 +188,7 @@ void calculate_raising_positiveNegativeValue_negativePower() { @Test void calculate_raising_positiveNegativeValue_zeroPower() { - actual = count.calculate(2, 0, '^'); + double actual = count.calculate(2, 0, '^'); assertEquals(1, actual); actual = count.calculate(-2, 0, '^'); assertEquals(1, actual); @@ -197,7 +196,7 @@ void calculate_raising_positiveNegativeValue_zeroPower() { @Test void calculate_raising_zeroValue_positiveNegativePower() { - actual = count.calculate(0, -2, '^'); + double actual = count.calculate(0, -2, '^'); assertTrue(Double.isInfinite(actual)); actual = count.calculate(0, 2, '^'); assertEquals(0, actual); @@ -205,8 +204,9 @@ void calculate_raising_zeroValue_positiveNegativePower() { @Test void calculate_illegalOperation_isNotOk() { + char invalidOperation = '%'; assertThrows(IllegalOperationException.class, () -> { - count.calculate(0, 2, '%'); + count.calculate(0, 2, invalidOperation); }); } }