Created Calculator class and calculate method in SimpleCalculator interface

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");
+        }
+    }
+}

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);
+    }
+}

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);
+}

src/test/java/core/basesyntax/CalculatorTest.java

@@ -0,0 +1,268 @@
+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 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 static SimpleCalculator calculator;
+
+    @BeforeAll
+    static void beforeAll() {
+        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_exponentiationToPositiveValue_Ok() {
+        double actual = calculator.calculate(A_POSITIVE, B_POSITIVE, EXPONENTIATION);
+        double expected = Math.pow(A_POSITIVE, B_POSITIVE);
+        assertEquals(expected, actual);
+        actual = calculator.calculate(A_NEGATIVE, B_POSITIVE, EXPONENTIATION);
+        expected = Math.pow(A_NEGATIVE, B_POSITIVE);
+        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);
+        assertEquals(expected, actual);
+        actual = calculator.calculate(A_NEGATIVE, B_NEGATIVE, EXPONENTIATION);
+        expected = Math.pow(A_NEGATIVE, B_NEGATIVE);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void calculate_exponentiationValueToZero_Ok() {
+        double actual = calculator.calculate(A_POSITIVE, ZERO, EXPONENTIATION);
+        double expected = Math.pow(A_POSITIVE, ZERO);
+        assertEquals(expected, actual);
+        actual = calculator.calculate(A_NEGATIVE, ZERO, EXPONENTIATION);
+        expected = Math.pow(A_NEGATIVE, ZERO);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void calculate_exponentiationZero_Ok() {
+        double actual = calculator.calculate(ZERO, A_POSITIVE, EXPONENTIATION);
+        double expected = Math.pow(ZERO, A_POSITIVE);
+        assertEquals(expected, actual);
+        actual = calculator.calculate(ZERO, A_NEGATIVE, EXPONENTIATION);
+        expected = Math.pow(ZERO, A_NEGATIVE);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    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, '<');
+        });
+    }
+}