From 0fe359a6628595eec97f598115d86a06b863c5db Mon Sep 17 00:00:00 2001
From: Roman Radikhovskiy <radihovskiyroman@gmail.com>
Date: Mon, 13 Sep 2021 19:20:43 +0300
Subject: [PATCH 1/3] Implemented calculator

---
 src/main/java/core/basesyntax/Calculator.java |  23 ++
 src/main/java/core/basesyntax/HelloWorld.java |   8 -
 .../java/core/basesyntax/CalculatorTest.java  | 310 ++++++++++++++++++
 .../java/core/basesyntax/HelloWorldTest.java  |   8 -
 4 files changed, 333 insertions(+), 16 deletions(-)
 create mode 100644 src/main/java/core/basesyntax/Calculator.java
 delete mode 100644 src/main/java/core/basesyntax/HelloWorld.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/Calculator.java b/src/main/java/core/basesyntax/Calculator.java
new file mode 100644
index 00000000..3e4827c3
--- /dev/null
+++ b/src/main/java/core/basesyntax/Calculator.java
@@ -0,0 +1,23 @@
+package core.basesyntax;
+
+public class Calculator {
+    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 Math.pow(number1, number2);
+            case '/':
+                if (number2 == 0) {
+                    throw new IllegalArgumentException("Can't divide by zero");
+                }
+                return number1 / number2;
+            default:
+                throw new IllegalStateException("Invalid operation");
+        }
+    }
+}
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/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java
new file mode 100644
index 00000000..ceef45cb
--- /dev/null
+++ b/src/test/java/core/basesyntax/CalculatorTest.java
@@ -0,0 +1,310 @@
+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 Calculator calculator = new Calculator();
+    private double expected;
+    private double actual;
+    private double number1;
+    private double number2;
+
+    @Test
+    void addictionTwoPositive() {
+        number1 = 7;
+        number2 = 14;
+        expected = 21;
+        actual = calculator.calculate(number1, number2, '+');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void addictionTwoNegative() {
+        number1 = -7;
+        number2 = -14;
+        expected = -21;
+        actual = calculator.calculate(number1, number2, '+');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void addictionPositiveAndNegative() {
+        number1 = 7;
+        number2 = -14;
+        expected = -7;
+        actual = calculator.calculate(number1, number2, '+');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void addictionZero_1() {
+        number1 = 0;
+        number2 = -14;
+        expected = -14;
+        actual = calculator.calculate(number1, number2, '+');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void addictionZero_2() {
+        number1 = -14;
+        number2 = 0;
+        expected = -14;
+        actual = calculator.calculate(number1, number2, '+');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void addictionMaxValue() {
+        number1 = Double.MAX_VALUE;
+        number2 = -7;
+        expected = Double.MAX_VALUE;
+        actual = calculator.calculate(number1, number2, '+');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void addictionMinValue() {
+        number1 = Double.MIN_VALUE;
+        number2 = 0;
+        expected = Double.MIN_VALUE;
+        actual = calculator.calculate(number1, number2, '+');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void subtractionTwoPositive() {
+        number1 = 7;
+        number2 = 14;
+        expected = -7;
+        actual = calculator.calculate(number1, number2, '-');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void subtractionTwoNegative() {
+        number1 = -7;
+        number2 = -14;
+        expected = 7;
+        actual = calculator.calculate(number1, number2, '-');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void subtractionPositiveAndNegative() {
+        number1 = 7;
+        number2 = -14;
+        expected = 21;
+        actual = calculator.calculate(number1, number2, '-');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void subtractionZero_1() {
+        number1 = 0;
+        number2 = -14;
+        expected = 14;
+        actual = calculator.calculate(number1, number2, '-');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void subtractionZero_2() {
+        number1 = -14;
+        number2 = 0;
+        expected = -14;
+        actual = calculator.calculate(number1, number2, '-');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void subtractionMaxValue() {
+        number1 = Double.MAX_VALUE;
+        number2 = -7;
+        expected = Double.MAX_VALUE;
+        actual = calculator.calculate(number1, number2, '-');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void subtractionMinValue() {
+        number1 = Double.MIN_VALUE;
+        number2 = 3;
+        expected = -3;
+        actual = calculator.calculate(number1, number2, '-');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void multiplicationTwoPositive() {
+        number1 = 7;
+        number2 = 14;
+        expected = 98;
+        actual = calculator.calculate(number1, number2, '*');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void multiplicationTwoNegative() {
+        number1 = -7;
+        number2 = -14;
+        expected = 98;
+        actual = calculator.calculate(number1, number2, '*');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void multiplicationPositiveAndNegative() {
+        number1 = 7;
+        number2 = -14;
+        expected = -98;
+        actual = calculator.calculate(number1, number2, '*');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void multiplicationZero_1() {
+        number1 = 0;
+        number2 = 14;
+        expected = 0;
+        actual = calculator.calculate(number1, number2, '*');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void multiplicationZero_2() {
+        number1 = 14;
+        number2 = 0;
+        expected = 0;
+        actual = calculator.calculate(number1, number2, '*');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void multiplicationMaxValue() {
+        number1 = Double.MAX_VALUE;
+        number2 = 7;
+        expected = Double.POSITIVE_INFINITY;
+        actual = calculator.calculate(number1, number2, '*');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void multiplicationMinValue() {
+        number1 = Double.MIN_VALUE;
+        number2 = 3;
+        expected = 1.5E-323;
+        actual = calculator.calculate(number1, number2, '*');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void divisionTwoPositive() {
+        number1 = 7;
+        number2 = 14;
+        expected = 0.5;
+        actual = calculator.calculate(number1, number2, '/');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void divisionTwoNegative() {
+        number1 = -7;
+        number2 = -14;
+        expected = 0.5;
+        actual = calculator.calculate(number1, number2, '/');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void divisionPositiveAndNegative() {
+        number1 = 7;
+        number2 = -14;
+        expected = -0.5;
+        actual = calculator.calculate(number1, number2, '/');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void divisionZero_1() {
+        number1 = 0;
+        number2 = 14;
+        expected = 0;
+        actual = calculator.calculate(number1, number2, '/');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void divisionZero_2() {
+        number1 = 14;
+        number2 = 0;
+        assertThrows(IllegalArgumentException.class, () -> {
+            calculator.calculate(number1, number2, '/');
+        });
+    }
+
+    @Test
+    void divisionMaxValue() {
+        number1 = Double.MAX_VALUE;
+        number2 = 7;
+        expected = 2.5681330498033083E307;
+        actual = calculator.calculate(number1, number2, '/');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void divisionMinValue() {
+        number1 = Double.MIN_VALUE;
+        number2 = 3;
+        expected = 0;
+        actual = calculator.calculate(number1, number2, '/');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void raiseToPower() {
+        number1 = 7;
+        number2 = 3;
+        expected = 343;
+        actual = calculator.calculate(number1, number2, '^');
+        assertEquals(expected, actual);
+        number1 = -7;
+        number2 = 3;
+        expected = -343;
+        actual = calculator.calculate(number1, number2, '^');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void raiseToNegativePower() {
+        number1 = 7;
+        number2 = -2;
+        expected = 0.02040816326530612;
+        actual = calculator.calculate(number1, number2, '^');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void raiseToZeroPower() {
+        number1 = 7;
+        number2 = 0;
+        expected = 1;
+        actual = calculator.calculate(number1, number2, '^');
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    void checkOperation() {
+        number1 = 7;
+        number2 = 4;
+        assertThrows(IllegalStateException.class, () -> {
+            calculator.calculate(number1, number2, '!');
+        });
+        assertThrows(IllegalStateException.class, () -> {
+            calculator.calculate(number1, number2, '3');
+        });
+    }
+}
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 5fc9ffacfa649d0d2e3b261c2c9c130149d1b979 Mon Sep 17 00:00:00 2001
From: Roman Radikhovskiy <radihovskiyroman@gmail.com>
Date: Mon, 13 Sep 2021 19:33:44 +0300
Subject: [PATCH 2/3] Implemented calculator

---
 src/test/java/core/basesyntax/CalculatorTest.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java
index ceef45cb..6f70bac6 100644
--- a/src/test/java/core/basesyntax/CalculatorTest.java
+++ b/src/test/java/core/basesyntax/CalculatorTest.java
@@ -281,8 +281,8 @@ void raiseToPower() {
     @Test
     void raiseToNegativePower() {
         number1 = 7;
-        number2 = -2;
-        expected = 0.02040816326530612;
+        number2 = -1;
+        expected = 0.14285714285714285;
         actual = calculator.calculate(number1, number2, '^');
         assertEquals(expected, actual);
     }

From 77251c31bb1c03177752ce45e743c46f263b8d8a Mon Sep 17 00:00:00 2001
From: Roman Radikhovskiy <radihovskiyroman@gmail.com>
Date: Tue, 14 Sep 2021 12:14:20 +0300
Subject: [PATCH 3/3] Changed variables, combined methods and so on

---
 src/main/java/core/basesyntax/Calculator.java |  18 +-
 .../java/core/basesyntax/CalculatorTest.java  | 300 +++++++++---------
 2 files changed, 152 insertions(+), 166 deletions(-)

diff --git a/src/main/java/core/basesyntax/Calculator.java b/src/main/java/core/basesyntax/Calculator.java
index 3e4827c3..baaf8e27 100644
--- a/src/main/java/core/basesyntax/Calculator.java
+++ b/src/main/java/core/basesyntax/Calculator.java
@@ -1,23 +1,23 @@
 package core.basesyntax;
 
 public class Calculator {
-    public double calculate(double number1, double number2, char operation) {
+    public double calculate(double first, double second, char operation) {
         switch (operation) {
             case '+':
-                return number1 + number2;
+                return first + second;
             case '-':
-                return number1 - number2;
+                return first - second;
             case '*':
-                return number1 * number2;
+                return first * second;
             case '^':
-                return Math.pow(number1, number2);
+                return Math.pow(first, second);
             case '/':
-                if (number2 == 0) {
-                    throw new IllegalArgumentException("Can't divide by zero");
+                if (second == 0) {
+                    throw new ArithmeticException("Can't divide by zero");
                 }
-                return number1 / number2;
+                return first / second;
             default:
-                throw new IllegalStateException("Invalid operation");
+                throw new IllegalArgumentException("Invalid operation");
         }
     }
 }
diff --git a/src/test/java/core/basesyntax/CalculatorTest.java b/src/test/java/core/basesyntax/CalculatorTest.java
index 6f70bac6..edae83f5 100644
--- a/src/test/java/core/basesyntax/CalculatorTest.java
+++ b/src/test/java/core/basesyntax/CalculatorTest.java
@@ -3,308 +3,294 @@
 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 Calculator calculator = new Calculator();
-    private double expected;
-    private double actual;
-    private double number1;
-    private double number2;
+    private static Calculator calculator;
+
+    @BeforeAll
+    static void beforeAll() {
+        calculator = new Calculator();
+    }
 
     @Test
     void addictionTwoPositive() {
-        number1 = 7;
-        number2 = 14;
-        expected = 21;
-        actual = calculator.calculate(number1, number2, '+');
+        double first = 7;
+        double second = 14;
+        double expected = 21;
+        double actual = calculator.calculate(first, second, '+');
         assertEquals(expected, actual);
     }
 
     @Test
     void addictionTwoNegative() {
-        number1 = -7;
-        number2 = -14;
-        expected = -21;
-        actual = calculator.calculate(number1, number2, '+');
+        double first = -38;
+        double second = -17;
+        double expected = -55;
+        double actual = calculator.calculate(first, second, '+');
         assertEquals(expected, actual);
     }
 
     @Test
     void addictionPositiveAndNegative() {
-        number1 = 7;
-        number2 = -14;
-        expected = -7;
-        actual = calculator.calculate(number1, number2, '+');
+        double first = 40;
+        double second = -20;
+        double expected = 20;
+        double actual = calculator.calculate(first, second, '+');
         assertEquals(expected, actual);
     }
 
     @Test
-    void addictionZero_1() {
-        number1 = 0;
-        number2 = -14;
-        expected = -14;
-        actual = calculator.calculate(number1, number2, '+');
+    void addictionZero() {
+        double first = 0;
+        double second = 93;
+        double expected = 93;
+        double actual = calculator.calculate(first, second, '+');
         assertEquals(expected, actual);
-    }
-
-    @Test
-    void addictionZero_2() {
-        number1 = -14;
-        number2 = 0;
-        expected = -14;
-        actual = calculator.calculate(number1, number2, '+');
+        first = 36;
+        second = 0;
+        expected = 36;
+        actual = calculator.calculate(first, second, '+');
         assertEquals(expected, actual);
     }
 
     @Test
     void addictionMaxValue() {
-        number1 = Double.MAX_VALUE;
-        number2 = -7;
-        expected = Double.MAX_VALUE;
-        actual = calculator.calculate(number1, number2, '+');
+        double first = Double.MAX_VALUE;
+        double second = -7;
+        double expected = Double.MAX_VALUE;
+        double actual = calculator.calculate(first, second, '+');
         assertEquals(expected, actual);
     }
 
     @Test
     void addictionMinValue() {
-        number1 = Double.MIN_VALUE;
-        number2 = 0;
-        expected = Double.MIN_VALUE;
-        actual = calculator.calculate(number1, number2, '+');
+        double first = Double.MIN_VALUE;
+        double second = 0;
+        double expected = Double.MIN_VALUE;
+        double actual = calculator.calculate(first, second, '+');
         assertEquals(expected, actual);
     }
 
     @Test
     void subtractionTwoPositive() {
-        number1 = 7;
-        number2 = 14;
-        expected = -7;
-        actual = calculator.calculate(number1, number2, '-');
+        double first = 15;
+        double second = 10;
+        double expected = 5;
+        double actual = calculator.calculate(first, second, '-');
         assertEquals(expected, actual);
     }
 
     @Test
     void subtractionTwoNegative() {
-        number1 = -7;
-        number2 = -14;
-        expected = 7;
-        actual = calculator.calculate(number1, number2, '-');
+        double first = -3;
+        double second = -4;
+        double expected = 1;
+        double actual = calculator.calculate(first, second, '-');
         assertEquals(expected, actual);
     }
 
     @Test
     void subtractionPositiveAndNegative() {
-        number1 = 7;
-        number2 = -14;
-        expected = 21;
-        actual = calculator.calculate(number1, number2, '-');
+        double first = 34;
+        double second = -14;
+        double expected = 48;
+        double actual = calculator.calculate(first, second, '-');
         assertEquals(expected, actual);
     }
 
     @Test
-    void subtractionZero_1() {
-        number1 = 0;
-        number2 = -14;
-        expected = 14;
-        actual = calculator.calculate(number1, number2, '-');
+    void subtractionZero() {
+        double first = 0;
+        double second = -17;
+        double expected = 17;
+        double actual = calculator.calculate(first, second, '-');
         assertEquals(expected, actual);
-    }
-
-    @Test
-    void subtractionZero_2() {
-        number1 = -14;
-        number2 = 0;
-        expected = -14;
-        actual = calculator.calculate(number1, number2, '-');
+        first = -11;
+        second = 0;
+        expected = -11;
+        actual = calculator.calculate(first, second, '-');
         assertEquals(expected, actual);
     }
 
     @Test
     void subtractionMaxValue() {
-        number1 = Double.MAX_VALUE;
-        number2 = -7;
-        expected = Double.MAX_VALUE;
-        actual = calculator.calculate(number1, number2, '-');
+        double first = Double.MAX_VALUE;
+        double second = -4;
+        double expected = Double.MAX_VALUE;
+        double actual = calculator.calculate(first, second, '-');
         assertEquals(expected, actual);
     }
 
     @Test
     void subtractionMinValue() {
-        number1 = Double.MIN_VALUE;
-        number2 = 3;
-        expected = -3;
-        actual = calculator.calculate(number1, number2, '-');
+        double first = Double.MIN_VALUE;
+        double second = 3;
+        double expected = -3;
+        double actual = calculator.calculate(first, second, '-');
         assertEquals(expected, actual);
     }
 
     @Test
     void multiplicationTwoPositive() {
-        number1 = 7;
-        number2 = 14;
-        expected = 98;
-        actual = calculator.calculate(number1, number2, '*');
+        double first = 6;
+        double second = 4;
+        double expected = 24;
+        double actual = calculator.calculate(first, second, '*');
         assertEquals(expected, actual);
     }
 
     @Test
     void multiplicationTwoNegative() {
-        number1 = -7;
-        number2 = -14;
-        expected = 98;
-        actual = calculator.calculate(number1, number2, '*');
+        double first = -7;
+        double second = -14;
+        double expected = 98;
+        double actual = calculator.calculate(first, second, '*');
         assertEquals(expected, actual);
     }
 
     @Test
     void multiplicationPositiveAndNegative() {
-        number1 = 7;
-        number2 = -14;
-        expected = -98;
-        actual = calculator.calculate(number1, number2, '*');
+        double first = 7;
+        double second = -21;
+        double expected = -147;
+        double actual = calculator.calculate(first, second, '*');
         assertEquals(expected, actual);
     }
 
     @Test
-    void multiplicationZero_1() {
-        number1 = 0;
-        number2 = 14;
-        expected = 0;
-        actual = calculator.calculate(number1, number2, '*');
+    void multiplicationZero() {
+        double first = 0;
+        double second = 346;
+        double expected = 0;
+        double actual = calculator.calculate(first, second, '*');
         assertEquals(expected, actual);
-    }
-
-    @Test
-    void multiplicationZero_2() {
-        number1 = 14;
-        number2 = 0;
+        first = 52;
+        second = 0;
         expected = 0;
-        actual = calculator.calculate(number1, number2, '*');
+        actual = calculator.calculate(first, second, '*');
         assertEquals(expected, actual);
     }
 
     @Test
     void multiplicationMaxValue() {
-        number1 = Double.MAX_VALUE;
-        number2 = 7;
-        expected = Double.POSITIVE_INFINITY;
-        actual = calculator.calculate(number1, number2, '*');
+        double first = Double.MAX_VALUE;
+        double second = 32;
+        double expected = Double.POSITIVE_INFINITY;
+        double actual = calculator.calculate(first, second, '*');
         assertEquals(expected, actual);
     }
 
     @Test
     void multiplicationMinValue() {
-        number1 = Double.MIN_VALUE;
-        number2 = 3;
-        expected = 1.5E-323;
-        actual = calculator.calculate(number1, number2, '*');
+        double first = Double.MIN_VALUE;
+        double second = 3;
+        double expected = 1.5E-323;
+        double actual = calculator.calculate(first, second, '*');
         assertEquals(expected, actual);
     }
 
     @Test
     void divisionTwoPositive() {
-        number1 = 7;
-        number2 = 14;
-        expected = 0.5;
-        actual = calculator.calculate(number1, number2, '/');
+        double first = 6;
+        double second = 2;
+        double expected = 3;
+        double actual = calculator.calculate(first, second, '/');
         assertEquals(expected, actual);
     }
 
     @Test
     void divisionTwoNegative() {
-        number1 = -7;
-        number2 = -14;
-        expected = 0.5;
-        actual = calculator.calculate(number1, number2, '/');
+        double first = -10;
+        double second = -5;
+        double expected = 2;
+        double actual = calculator.calculate(first, second, '/');
         assertEquals(expected, actual);
     }
 
     @Test
     void divisionPositiveAndNegative() {
-        number1 = 7;
-        number2 = -14;
-        expected = -0.5;
-        actual = calculator.calculate(number1, number2, '/');
+        double first = 20;
+        double second = -5;
+        double expected = -4;
+        double actual = calculator.calculate(first, second, '/');
         assertEquals(expected, actual);
     }
 
     @Test
-    void divisionZero_1() {
-        number1 = 0;
-        number2 = 14;
-        expected = 0;
-        actual = calculator.calculate(number1, number2, '/');
+    void divisionZero() {
+        double first = 0;
+        double second = 300;
+        double expected = 0;
+        double actual = calculator.calculate(first, second, '/');
         assertEquals(expected, actual);
-    }
-
-    @Test
-    void divisionZero_2() {
-        number1 = 14;
-        number2 = 0;
-        assertThrows(IllegalArgumentException.class, () -> {
-            calculator.calculate(number1, number2, '/');
+        double firstL = 35437;
+        double secondL = 0;
+        assertThrows(ArithmeticException.class, () -> {
+            calculator.calculate(firstL, secondL, '/');
         });
     }
 
     @Test
     void divisionMaxValue() {
-        number1 = Double.MAX_VALUE;
-        number2 = 7;
-        expected = 2.5681330498033083E307;
-        actual = calculator.calculate(number1, number2, '/');
+        double first = Double.MAX_VALUE;
+        double second = 7;
+        double expected = 2.5681330498033083E307;
+        double actual = calculator.calculate(first, second, '/');
         assertEquals(expected, actual);
     }
 
     @Test
     void divisionMinValue() {
-        number1 = Double.MIN_VALUE;
-        number2 = 3;
-        expected = 0;
-        actual = calculator.calculate(number1, number2, '/');
+        double first = Double.MIN_VALUE;
+        double second = 3;
+        double expected = 0;
+        double actual = calculator.calculate(first, second, '/');
         assertEquals(expected, actual);
     }
 
     @Test
     void raiseToPower() {
-        number1 = 7;
-        number2 = 3;
-        expected = 343;
-        actual = calculator.calculate(number1, number2, '^');
+        double first = 7;
+        double second = 3;
+        double expected = 343;
+        double actual = calculator.calculate(first, second, '^');
         assertEquals(expected, actual);
-        number1 = -7;
-        number2 = 3;
+        first = -7;
+        second = 3;
         expected = -343;
-        actual = calculator.calculate(number1, number2, '^');
+        actual = calculator.calculate(first, second, '^');
         assertEquals(expected, actual);
     }
 
     @Test
     void raiseToNegativePower() {
-        number1 = 7;
-        number2 = -1;
-        expected = 0.14285714285714285;
-        actual = calculator.calculate(number1, number2, '^');
+        double first = 7;
+        double second = -1;
+        double expected = 0.14285714285714285;
+        double actual = calculator.calculate(first, second, '^');
         assertEquals(expected, actual);
     }
 
     @Test
     void raiseToZeroPower() {
-        number1 = 7;
-        number2 = 0;
-        expected = 1;
-        actual = calculator.calculate(number1, number2, '^');
+        double first = 4363;
+        double second = 0;
+        double expected = 1;
+        double actual = calculator.calculate(first, second, '^');
         assertEquals(expected, actual);
     }
 
     @Test
     void checkOperation() {
-        number1 = 7;
-        number2 = 4;
-        assertThrows(IllegalStateException.class, () -> {
-            calculator.calculate(number1, number2, '!');
+        double first = 7;
+        double second = 4;
+        assertThrows(IllegalArgumentException.class, () -> {
+            calculator.calculate(first, second, '!');
         });
-        assertThrows(IllegalStateException.class, () -> {
-            calculator.calculate(number1, number2, '3');
+        assertThrows(IllegalArgumentException.class, () -> {
+            calculator.calculate(first, second, '3');
         });
     }
 }