From 94dcd83422bbc7df1008503f04afab688c440e0f Mon Sep 17 00:00:00 2001 From: Gleb Kreshchuk Date: Mon, 13 Sep 2021 23:42:26 +0300 Subject: [PATCH 1/3] Task completed according requirements --- src/main/java/core/basesyntax/HelloWorld.java | 8 -------- src/test/java/core/basesyntax/HelloWorldTest.java | 8 -------- 2 files changed, 16 deletions(-) delete mode 100644 src/main/java/core/basesyntax/HelloWorld.java delete mode 100644 src/test/java/core/basesyntax/HelloWorldTest.java 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/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 ccb7025f53bb21b17439a430eab9fcaddd39bd7b Mon Sep 17 00:00:00 2001 From: Gleb Kreshchuk Date: Mon, 13 Sep 2021 23:42:56 +0300 Subject: [PATCH 2/3] Task completed according requirements --- src/main/java/core/basesyntax/Calculate.java | 5 + src/main/java/core/basesyntax/Calculator.java | 25 ++++ .../java/core/basesyntax/CalculatorTest.java | 137 ++++++++++++++++++ 3 files changed, 167 insertions(+) create mode 100644 src/main/java/core/basesyntax/Calculate.java create mode 100644 src/main/java/core/basesyntax/Calculator.java create mode 100644 src/test/java/core/basesyntax/CalculatorTest.java diff --git a/src/main/java/core/basesyntax/Calculate.java b/src/main/java/core/basesyntax/Calculate.java new file mode 100644 index 00000000..f6a46513 --- /dev/null +++ b/src/main/java/core/basesyntax/Calculate.java @@ -0,0 +1,5 @@ +package core.basesyntax; + +public interface Calculate { + double calculate(double a, double b, char c); +} diff --git a/src/main/java/core/basesyntax/Calculator.java b/src/main/java/core/basesyntax/Calculator.java new file mode 100644 index 00000000..6dde939e --- /dev/null +++ b/src/main/java/core/basesyntax/Calculator.java @@ -0,0 +1,25 @@ +package core.basesyntax; + +public class Calculator implements Calculate { + + @Override + public double calculate(double firstParameter, double secondParameter, char operation) { + switch (operation) { + case '+': + return firstParameter + secondParameter; + case '-': + return firstParameter - secondParameter; + case '*': + return firstParameter * secondParameter; + case '^': + return Math.pow(firstParameter, secondParameter); + case '/': + if (secondParameter == 0) { + throw new IllegalArgumentException("Division by zero"); + } + return firstParameter / secondParameter; + default: + throw new IllegalArgumentException("Invalid 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..f102cd3c --- /dev/null +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -0,0 +1,137 @@ +package core.basesyntax; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +class CalculatorTest { + private static final double DELTA = 0.0001; + private Calculate calculator = new Calculator(); + + @Test + void additionWithTwoPositiveOperands_Ok() { + double expected = 100.0; + double actual = calculator.calculate(90.0, 10.0, '+'); + assertEquals(expected, actual); + } + + @Test + void additionWithTwoNegativeOperands_Ok() { + double expected = - 150.0; + double actual = calculator.calculate(-100.0, -50.0, '+'); + assertEquals(expected, actual); + } + + @Test + void additionWithPositiveAndNegativeOperands_Ok() { + double expected = - 150.0; + double actual = calculator.calculate(-200.0, 50.0, '+'); + assertEquals(expected, actual); + } + + @Test + void additionWithFirstOperandIsZero_Ok() { + double expected = 50.0; + double actual = calculator.calculate(0.0, 50.0, '+'); + assertEquals(expected, actual); + } + + @Test + void additionWithSecondOperandIsZero_Ok() { + double expected = 60.0; + double actual = calculator.calculate(60.0, 0.0, '+'); + assertEquals(expected, actual); + } + + @Test + void additionWithMinAndMaxDoubleValues_Ok() { + double expected = Double.MAX_VALUE + Double.MIN_VALUE; + double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '+'); + assertEquals(expected, actual, DELTA); + } + + @Test + void subtractionWithMinAndMaxDoubleValues_Ok() { + double expected = Double.MAX_VALUE - Double.MIN_VALUE; + double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '-'); + assertEquals(expected, actual, DELTA); + } + + @Test + void multiplicationWithMinAndMaxDoubleValues_Ok() { + double expected = Double.MAX_VALUE * Double.MIN_VALUE; + double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '*'); + assertEquals(expected, actual, DELTA); + } + + @Test + void divisionWithMinAndMaxDoubleValues_Ok() { + double expected = Double.MAX_VALUE / Double.MIN_VALUE; + double actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '/'); + assertEquals(expected, actual, DELTA); + } + + @Test + void divisionByZero_NotOk() { + assertThrows(IllegalArgumentException.class, () -> { + calculator.calculate(2.0, 0.0, '/'); + }); + } + + @Test + void raisingPositiveValueToThePositivePower_Ok() { + double expected = 64.0; + double actual = calculator.calculate(8.0, 2.0, '^'); + assertEquals(expected, actual); + } + + @Test + void raisingNegativeValueToThePositivePower_Ok() { + double expected = 64.0; + double actual = calculator.calculate(-8.0, 2.0, '^'); + assertEquals(expected, actual); + } + + @Test + void raisingPositiveValueToTheNegativePower_Ok() { + double expected = 0.015625; + double actual = calculator.calculate(8.0, -2.0, '^'); + assertEquals(expected, actual, DELTA); + } + + @Test + void raisingNegativeValueToTheNegativePower_Ok() { + double expected = 0.015625; + double actual = calculator.calculate(-8.0, -2.0, '^'); + assertEquals(expected, actual, DELTA); + } + + @Test + void raisingPositiveValueToZeroPower_Ok() { + double expected = 1.0; + double actual = calculator.calculate(8.0, 0.0, '^'); + assertEquals(expected, actual); + } + + @Test + void raisingNegativeValueToZeroPower_Ok() { + double expected = 1.0; + double actual = calculator.calculate(-8.0, 0.0, '^'); + assertEquals(expected, actual); + } + + @Test + void raisingZeroToPower_Ok() { + double expected = 0.0; + double actual = calculator.calculate(0.0, 10.0, '^'); + assertEquals(expected, actual); + } + + @Test + void illegalOperation_NotOk() { + assertThrows(IllegalArgumentException.class, () -> { + calculator.calculate(2.0, 3.0, '#'); + }); + } +} From b051fa04e150efb743ede58f66b117a4045f924b Mon Sep 17 00:00:00 2001 From: Gleb Kreshchuk Date: Mon, 13 Sep 2021 23:42:56 +0300 Subject: [PATCH 3/3] Task completed according requirements --- src/main/java/core/basesyntax/Calculate.java | 5 + src/main/java/core/basesyntax/Calculator.java | 29 ++++ .../java/core/basesyntax/CalculatorTest.java | 139 ++++++++++++++++++ 3 files changed, 173 insertions(+) create mode 100644 src/main/java/core/basesyntax/Calculate.java create mode 100644 src/main/java/core/basesyntax/Calculator.java create mode 100644 src/test/java/core/basesyntax/CalculatorTest.java diff --git a/src/main/java/core/basesyntax/Calculate.java b/src/main/java/core/basesyntax/Calculate.java new file mode 100644 index 00000000..f6a46513 --- /dev/null +++ b/src/main/java/core/basesyntax/Calculate.java @@ -0,0 +1,5 @@ +package core.basesyntax; + +public interface Calculate { + double calculate(double a, double b, char c); +} diff --git a/src/main/java/core/basesyntax/Calculator.java b/src/main/java/core/basesyntax/Calculator.java new file mode 100644 index 00000000..dc89af84 --- /dev/null +++ b/src/main/java/core/basesyntax/Calculator.java @@ -0,0 +1,29 @@ +package core.basesyntax; + +public class Calculator implements Calculate { + + @Override + public double calculate(double firstParameter, double secondParameter, char operation) { + switch (operation) { + case '+': + return firstParameter + secondParameter; + case '-': + return firstParameter - secondParameter; + case '*': + return firstParameter * secondParameter; + case '^': + if (firstParameter == 0 && secondParameter < 0) { + throw new IllegalArgumentException( + "Power zero to negative value is not allowed."); + } + return Math.pow(firstParameter, secondParameter); + case '/': + if (secondParameter == 0) { + throw new ArithmeticException("Division by zero is not allowed."); + } + return firstParameter / secondParameter; + default: + throw new IllegalArgumentException("Invalid 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..ed887ec2 --- /dev/null +++ b/src/test/java/core/basesyntax/CalculatorTest.java @@ -0,0 +1,139 @@ +package core.basesyntax; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.Test; + +class CalculatorTest { + private static final double DELTA = 0.0001; + private Calculate calculator = new Calculator(); + private double expected; + private double actual; + + @Test + void calculate_additionWithTwoPositiveOperands_Ok() { + expected = 100.0; + actual = calculator.calculate(90.0, 10.0, '+'); + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithTwoNegativeOperands_Ok() { + expected = - 150.0; + actual = calculator.calculate(-100.0, -50.0, '+'); + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithPositiveAndNegativeOperands_Ok() { + expected = - 150.0; + actual = calculator.calculate(-200.0, 50.0, '+'); + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithFirstOperandIsZero_Ok() { + expected = 50.0; + actual = calculator.calculate(0.0, 50.0, '+'); + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithSecondOperandIsZero_Ok() { + expected = 60.0; + actual = calculator.calculate(60.0, 0.0, '+'); + assertEquals(expected, actual); + } + + @Test + void calculate_additionWithMinAndMaxDoubleValues_Ok() { + expected = Double.MAX_VALUE + Double.MIN_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '+'); + assertEquals(expected, actual, DELTA); + } + + @Test + void calculate_subtractionWithMinAndMaxDoubleValues_Ok() { + expected = Double.MAX_VALUE - Double.MIN_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '-'); + assertEquals(expected, actual, DELTA); + } + + @Test + void calculate_multiplicationWithMinAndMaxDoubleValues_Ok() { + expected = Double.MAX_VALUE * Double.MIN_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '*'); + assertEquals(expected, actual, DELTA); + } + + @Test + void calculate_divisionWithMinAndMaxDoubleValues_Ok() { + expected = Double.MAX_VALUE / Double.MIN_VALUE; + actual = calculator.calculate(Double.MAX_VALUE, Double.MIN_VALUE, '/'); + assertEquals(expected, actual, DELTA); + } + + @Test + void calculate_divisionByZero_NotOk() { + assertThrows(ArithmeticException.class, () -> { + calculator.calculate(2.0, 0.0, '/'); + }); + } + + @Test + void calculate_raisingPositiveValueToThePositivePower_Ok() { + expected = 64.0; + actual = calculator.calculate(8.0, 2.0, '^'); + assertEquals(expected, actual); + } + + @Test + void calculate_raisingNegativeValueToThePositivePower_Ok() { + expected = 64.0; + actual = calculator.calculate(-8.0, 2.0, '^'); + assertEquals(expected, actual); + } + + @Test + void calculate_raisingPositiveValueToTheNegativePower_Ok() { + expected = 0.015625; + actual = calculator.calculate(8.0, -2.0, '^'); + assertEquals(expected, actual, DELTA); + } + + @Test + void calculate_raisingNegativeValueToTheNegativePower_Ok() { + expected = 0.015625; + actual = calculator.calculate(-8.0, -2.0, '^'); + assertEquals(expected, actual, DELTA); + } + + @Test + void calculate_raisingPositiveValueToZeroPower_Ok() { + expected = 1.0; + actual = calculator.calculate(8.0, 0.0, '^'); + assertEquals(expected, actual); + } + + @Test + void calculate_raisingNegativeValueToZeroPower_Ok() { + expected = 1.0; + actual = calculator.calculate(-8.0, 0.0, '^'); + assertEquals(expected, actual); + } + + @Test + void calculate_raisingZeroToPower_Ok() { + expected = 0.0; + actual = calculator.calculate(0.0, 10.0, '^'); + assertEquals(expected, actual); + } + + @Test + void illegalOperation_NotOk() { + assertThrows(IllegalArgumentException.class, () -> { + calculator.calculate(2.0, 3.0, '#'); + }); + } +}