Created a calculator and wrote tests for it

src/main/java/Calculate.java

@@ -0,0 +1,52 @@
+import java.util.NoSuchElementException;
+
+public class Calculate {
+    public static final char PLUS = '+';
+    public static final char MINUS = '-';
+    public static final char DIVISION = '/';
+    public static final char MULTIPLICATION = '*';
+    public static final char EXPONENTIATION = '^';
+
+    public double calculate(double firstNumber, double secondNumber, char operation) {
+        switch (operation) {
+            case PLUS:
+                return getTheAmountResult(firstNumber, secondNumber);
+            case MINUS:
+                return getTheSubtractionResult(firstNumber, secondNumber);
+            case DIVISION:
+                return getTheDivisionResult(firstNumber, secondNumber);
+            case MULTIPLICATION:
+                return getTheMultiplicationResult(firstNumber, secondNumber);
+            case EXPONENTIATION:
+                return getTheExponentiationResult(firstNumber, secondNumber);
+            default:
+                throw new NoSuchElementException("Incorrect operation");
+        }
+    }
+
+    private double getTheAmountResult(double firstNumber, double secondNumber) {
+        return firstNumber + secondNumber;
+    }
+
+    private double getTheSubtractionResult(double firstNumber, double secondNumber) {
+        return firstNumber - secondNumber;
+    }
+
+    private double getTheDivisionResult(double firstNumber, double secondNumber) {
+        if (secondNumber == 0) {
+            throw new ArithmeticException("We can't divide by zero");
+        }
+        return firstNumber / secondNumber;
+    }
+
+    private double getTheMultiplicationResult(double firstNumber, double secondNumber) {
+        return firstNumber * secondNumber;
+    }
+
+    private double getTheExponentiationResult(double firstNumber, double secondNumber) {
+        if (firstNumber == 0 && secondNumber < 0) {
+            throw new ArithmeticException("We can't divide by zero");
+        }
+        return Math.pow(firstNumber, secondNumber);
+    }
+}

src/test/java/CalculateTest.java

@@ -0,0 +1,228 @@
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.NoSuchElementException;
+import org.junit.jupiter.api.Test;
+
+class CalculateTest {
+    private static final Calculate CALCULATOR = new Calculate();
+    private double actual;
+    private double answer;
+
+    @Test
+    void additionWithTwoPositiveOperands_Ok() {
+        actual = CALCULATOR.calculate(6, 8, Calculate.PLUS);
+        answer = 14;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void additionWithTwoNegativeOperands_Ok() {
+        actual = CALCULATOR.calculate(-6, -8, Calculate.PLUS);
+        answer = -14;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void additionWithPositiveAndNegativeOperands_Ok() {
+        double actual = CALCULATOR.calculate(-6, 8, Calculate.PLUS);
+        double answer = 2;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void additionWithZeroInDifferentPlaces_Ok() {
+        actual = CALCULATOR.calculate(0, 8, Calculate.PLUS);
+        answer = 8;
+        assertEquals(answer,actual);
+
+        actual = CALCULATOR.calculate(6, 0, Calculate.PLUS);
+        answer = 6;
+        assertEquals(answer,actual);
+
+        actual = CALCULATOR.calculate(0, 0, Calculate.PLUS);
+        answer = 0;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void subtractionWithTwoPositiveOperands_Ok() {
+        actual = CALCULATOR.calculate(6, 8, Calculate.MINUS);
+        answer = -2;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void subtractionWithTwoNegativeOperands_Ok() {
+        actual = CALCULATOR.calculate(-6, -8, Calculate.MINUS);
+        answer = 2;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void subtractionWithPositiveAndNegativeOperands_Ok() {
+        actual = CALCULATOR.calculate(-6, 8, Calculate.MINUS);
+        answer = -14;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void subtractionWithZeroInDifferentPlaces_Ok() {
+        actual = CALCULATOR.calculate(0, 8, Calculate.MINUS);
+        answer = -8;
+        assertEquals(answer,actual);
+
+        actual = CALCULATOR.calculate(6, 0, Calculate.MINUS);
+        answer = 6;
+        assertEquals(answer,actual);
+
+        actual = CALCULATOR.calculate(0, 0, Calculate.MINUS);
+        answer = 0;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void divisionWithTwoPositiveOperands_Ok() {
+        actual = CALCULATOR.calculate(6, 2, Calculate.DIVISION);
+        answer = 3;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void divisionWithTwoNegativeOperands_Ok() {
+        actual = CALCULATOR.calculate(-6, -2, Calculate.DIVISION);
+        answer = 3;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void divisionWithPositiveAndNegativeOperands_Ok() {
+        actual = CALCULATOR.calculate(-6, 2, Calculate.DIVISION);
+        answer = -3;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void divisionWithZeroInStart_Ok() {
+        actual = CALCULATOR.calculate(0, 8, Calculate.DIVISION);
+        answer = 0;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void divisionWithZeroInEnd_notOk() {
+        assertThrows(ArithmeticException.class, () -> {
+            CALCULATOR.calculate(6, 0, Calculate.DIVISION);
+        });
+    }
+
+    @Test
+    void divisionWithZeroInStartAndEnd_notOk() {
+        assertThrows(ArithmeticException.class, () -> {
+            CALCULATOR.calculate(0, 0, Calculate.DIVISION);
+        });
+    }
+
+    @Test
+    void multiplicationWithTwoPositiveOperands_Ok() {
+        actual = CALCULATOR.calculate(6, 8, Calculate.MULTIPLICATION);
+        answer = 48;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void multiplicationWithTwoNegativeOperands_Ok() {
+        actual = CALCULATOR.calculate(-6, -8, Calculate.MULTIPLICATION);
+        answer = 48;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void multiplicationWithPositiveAndNegativeOperands_Ok() {
+        actual = CALCULATOR.calculate(-6, 8, Calculate.MULTIPLICATION);
+        answer = -48;
+        assertEquals(answer, actual);
+    }
+
+    @Test
+    void multiplicationWithZeroInDifferentPlaces_Ok() {
+        actual = CALCULATOR.calculate(0, 8, Calculate.MULTIPLICATION);
+        answer = 0;
+        assertEquals(answer,actual);
+
+        actual = CALCULATOR.calculate(6, 0, Calculate.MULTIPLICATION);
+        answer = 0;
+        assertEquals(answer,actual);
+
+        actual = CALCULATOR.calculate(0, 0, Calculate.MULTIPLICATION);
+        answer = 0;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void raisingPositiveValueToThePositivePower_Ok() {
+        actual = CALCULATOR.calculate(5, 2, Calculate.EXPONENTIATION);
+        answer = 25;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void raisingNegativeValueToThePositivePower_Ok() {
+        actual = CALCULATOR.calculate(-5, 2, Calculate.EXPONENTIATION);
+        answer = 25;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void raisingPositiveValueToTheNegativePower_Ok() {
+        actual = CALCULATOR.calculate(10, -3, Calculate.EXPONENTIATION);
+        answer = 0.001;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void raisingNegativeValueToTheNegativePower_Ok() {
+        actual = CALCULATOR.calculate(-10, -3, Calculate.EXPONENTIATION);
+        answer = -0.001;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void raisingPositiveValueToZeroPower_Ok() {
+        actual = CALCULATOR.calculate(5, 0, Calculate.EXPONENTIATION);
+        answer = 1;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void raisingNegativeValueToZeroPower_Ok() {
+        actual = CALCULATOR.calculate(-5, 0, Calculate.EXPONENTIATION);
+        answer = 1;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void raisingZeroToPower_Ok() {
+        actual = CALCULATOR.calculate(0, 0, Calculate.EXPONENTIATION);
+        answer = 1;
+        assertEquals(answer,actual);
+
+        actual = CALCULATOR.calculate(0, 5, Calculate.EXPONENTIATION);
+        answer = 0;
+        assertEquals(answer,actual);
+    }
+
+    @Test
+    void raisingZeroToNegativePower_notOk() {
+        assertThrows(ArithmeticException.class, () -> {
+            CALCULATOR.calculate(0, -5, Calculate.EXPONENTIATION);
+        });
+    }
+
+    @Test
+    void illegalOperation_notOk() {
+        assertThrows(NoSuchElementException.class, () -> {
+            CALCULATOR.calculate(0, 0, '&');
+        });
+    }
+}