Do Step2: calculator

src/main/java/calculator/application/CalculatorApp.java

@@ -0,0 +1,25 @@
+package calculator.application;
+
+import calculator.domain.Calculator;
+import calculator.domain.InputMachine;
+import calculator.view.ScreenMassage;
+
+public class CalculatorApp {
+    public static void main(String[] args) {
+        InputMachine inputMachine = new InputMachine();
+        Calculator calculator = new Calculator();
+        ScreenMassage screen = new ScreenMassage();
+
+        screen.showMassage();
+
+        int answer = 0;
+        try {
+            String userInput = inputMachine.getUserInput();
+            answer = calculator.getTotalCalculation(userInput);
+        } catch (Exception e) {
+            screen.showErrorMassage(e);
+        }
+
+        screen.showResult(answer);
+    }
+}

src/main/java/calculator/domain/Calculator.java

@@ -0,0 +1,59 @@
+package calculator.domain;
+
+public class Calculator {
+    public int getTotalCalculation(String arithmeticOperation) {
+        StringReader reader = new StringReader();
+
+        int[] numbers = reader.extractNumber(arithmeticOperation);
+        String[] operators = reader.extractOperator(arithmeticOperation);
+
+        int answer = 0;
+
+        for (int i = 0; i < operators.length; i += 1) {
+            if (operators[i].equals("+")) {
+                int value = this.add(numbers[i], numbers[i + 1]);
+                numbers[i + 1] = value;
+                answer = value;
+                continue;
+            }
+
+            if (operators[i].equals("-")) {
+                int value = this.subtract(numbers[i], numbers[i + 1]);
+                numbers[i + 1] = value;
+                answer = value;
+                continue;
+            }
+
+            if (operators[i].equals("*")) {
+                int value = this.multiply(numbers[i], numbers[i + 1]);
+                numbers[i + 1] = value;
+                answer = value;
+                continue;
+            }
+
+            if (operators[i].equals("/")) {
+                int value = this.divide(numbers[i], numbers[i + 1]);
+                numbers[i + 1] = value;
+                answer = value;
+            }
+        }
+
+        return answer;
+    }
+
+    public int add(int a, int b) {
+        return a + b;
+    }
+
+    public int subtract(int a, int b) {
+        return a - b;
+    }
+
+    public int multiply(int a, int b) {
+        return a * b;
+    }
+
+    public int divide(int a, int b) {
+        return a / b;
+    }
+}

src/main/java/calculator/domain/InputMachine.java

@@ -0,0 +1,20 @@
+package calculator.domain;
+
+import java.util.Scanner;
+
+public class InputMachine {
+    public String getUserInput() {
+        Scanner input = new Scanner(System.in);
+        String userInput = input.nextLine();
+
+        validateUserInput(userInput);
+
+        return userInput;
+    }
+
+    public void validateUserInput(String str) {
+        if (str == null || str == "") {
+            throw new IllegalArgumentException();
+        }
+    }
+}

src/main/java/calculator/domain/StringReader.java

@@ -0,0 +1,104 @@
+package calculator.domain;
+
+import java.util.*;
+import java.util.regex.*;
+
+public class StringReader {
+    public int[] extractNumber(String str) {
+        if (this.checkWeird(str)) {
+            throw new IllegalArgumentException();
+        }
+
+        String[] arr = str.split(" ");
+
+        removeUnnecessaryParts(arr);
+        ArrayList<String> pureNumbers = convertArrayToArrayList(arr);
+        ArrayList<String> result = considerBracket(pureNumbers);
+
+        return extractNumbersFromBracket(result);
+    }
+
+    public String[] extractOperator(String str) {
+        if (this.checkWeird(str)) {
+            throw new IllegalArgumentException();
+        }
+
+        String[] arr = str.split(" ");
+
+        ArrayList<String> pureOperators = convertArrayToArrayList(arr);
+        Object[] objOperators = pureOperators.stream()
+                .filter(v -> Pattern.matches("[\\*\\-\\+\\/]", v))
+                .toArray();
+
+        return convertObjectArrayToStringArray(objOperators);
+    }
+
+    public boolean checkWeird(String str) {
+        String weirds = str.replaceAll("[0-9\\+\\-\\*\\/\\' '\\(\\)]", "");
+        return weirds.length() > 0;
+    }
+
+    private void removeUnnecessaryParts(String[] arr) {
+        for (int i = 0; i < arr.length; i += 1) {
+            arr[i] = arr[i].replaceAll("[^0-9\\-\\(\\)]", "");
+        }
+    }
+
+    private ArrayList<String> convertArrayToArrayList(String[] arr) {
+        ArrayList<String> arrayList = new ArrayList<>();
+
+        for (String e : arr) {
+            arrayList.add(e);
+        }
+
+        return arrayList;
+    }
+
+    private String[] convertObjectArrayToStringArray(Object[] objArr) {
+        String[] strArr = new String[objArr.length];
+
+        int index = 0;
+        for (Object operator: objArr) {
+            strArr[index] = operator.toString();
+            index += 1;
+        }
+
+        return strArr;
+    }
+
+    private ArrayList<String> considerBracket(ArrayList<String> arrayList) {
+        ArrayList<String> result = new ArrayList<>();
+
+        for (int i = 0; i < arrayList.size(); i += 1) {
+            String e = arrayList.get(i);
+            if (e.length() > 0 && e.charAt(0) == '(') {
+                result.add(e);
+                continue;
+            }
+
+            if (Pattern.matches("[0-9]{1,}", e)) {
+                result.add(e);
+            }
+        }
+
+        return result;
+    }
+
+    private int[] extractNumbersFromBracket(ArrayList<String> arrayList) {
+        int[] answer = new int[arrayList.size()];
+
+        for (int i = 0; i < answer.length; i += 1) {
+            String e = arrayList.get(i);
+
+            if (e.charAt(0) == '(') {
+                String substr = e.substring(1, e.length() - 1);
+                answer[i] = Integer.parseInt(substr);
+                continue;
+            }
+
+            answer[i] = Integer.parseInt(e);
+        }
+
+        return answer;
+    }
+}

src/main/java/calculator/view/ScreenMassage.java

@@ -0,0 +1,15 @@
+package calculator.view;
+
+public class ScreenMassage {
+    public void showMassage() {
+        System.out.println("수식을 입력해주세요. 계산은 제가 합니다 ㅋ");
+    }
+
+    public void showResult(int result) {
+        System.out.printf("답은 %d 입니다.", result);
+    }
+
+    public void showErrorMassage(Exception e) {
+        System.out.println(e);
+    }
+}

src/test/java/calculator/CalculatorTest.java

@@ -0,0 +1,40 @@
+package calculator;
+
+import calculator.domain.Calculator;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("Calculator")
+public class CalculatorTest {
+    Calculator calculator = new Calculator();
+
+    @Test
+    @DisplayName("add")
+    public void add() {
+        assertThat(calculator.add(1, 1)).isEqualTo(2);
+        assertThat(calculator.add(-1, 1)).isEqualTo(0);
+    }
+
+    @Test
+    @DisplayName("subtract")
+    public void subtract() {
+        assertThat(calculator.subtract(1, 1)).isEqualTo(0);
+        assertThat(calculator.subtract(-1, 1)).isEqualTo(-2);
+    }
+
+    @Test
+    @DisplayName("multiply")
+    public void multiply() {
+        assertThat(calculator.multiply(2, 2)).isEqualTo(4);
+        assertThat(calculator.multiply(-2, 5)).isEqualTo(-10);
+    }
+
+    @Test
+    @DisplayName("divide")
+    public void divide() {
+        assertThat(calculator.divide(6, 2)).isEqualTo(3);
+        assertThat(calculator.divide(3, 2)).isEqualTo(1);
+    }
+}

src/test/java/calculator/InputMachineTest.java

@@ -0,0 +1,28 @@
+package calculator;
+
+import calculator.domain.InputMachine;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("InputMachine")
+public class InputMachineTest {
+    @Test
+    @DisplayName("validateUserInput")
+    public void validateUserInput() {
+        InputMachine inputMachine = new InputMachine();
+
+        assertThatThrownBy(() -> {
+            inputMachine.validateUserInput("");
+        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasToString("java.lang.IllegalArgumentException");
+
+        assertThatThrownBy(() -> {
+            inputMachine.validateUserInput(null);
+        })
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasToString("java.lang.IllegalArgumentException");
+    }
+}

src/test/java/calculator/StringReaderTest.java

@@ -0,0 +1,75 @@
+package calculator;
+
+import calculator.domain.StringReader;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("StringReader")
+public class StringReaderTest {
+    @Test
+    @DisplayName("extractNumber")
+    public void extractNumber() {
+        StringReader stringReader = new StringReader();
+
+        String input1 = "1 + 2 * 3";
+        int[] expected1= {1, 2, 3};
+        assertThat(stringReader.extractNumber(input1)).isEqualTo(expected1);
+
+        String input2 = "11 - 2 * 3 + 2";
+        int[] expected2 = {11, 2, 3, 2};
+        assertThat(stringReader.extractNumber(input2)).isEqualTo(expected2);
+
+        String input3 = "(-2) * (-3) + (-10)";
+        int[] expected3 = {-2, -3, -10};
+        assertThat(stringReader.extractNumber(input3)).isEqualTo(expected3);
+
+        String input4 = "1 & 3 + 5";
+        assertThatThrownBy(() -> {
+           stringReader.extractNumber(input4);
+        })
+                .hasToString("java.lang.IllegalArgumentException")
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("extractOperator")
+    public void extractOperator() {
+        StringReader stringReader = new StringReader();
+
+        String input1 = "1 + 2 * 3";
+        String[] expected1= {"+", "*"};
+        assertThat(stringReader.extractOperator(input1)).isEqualTo(expected1);
+
+        String input2 = "11 - 2 * 3 + 2";
+        String[] expected2 = {"-", "*", "+"};
+        assertThat(stringReader.extractOperator(input2)).isEqualTo(expected2);
+
+        String input3 = "(-2) * 3 + 4";
+        String[] expected3 = {"*", "+"};
+        assertThat(stringReader.extractOperator(input3)).isEqualTo(expected3);
+
+        String input4 = "1 & 3 + 5";
+        assertThatThrownBy(() -> {
+            stringReader.extractNumber(input4);
+        })
+                .hasToString("java.lang.IllegalArgumentException")
+                .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @ParameterizedTest
+    @CsvSource(value = {
+            "1 + 2 * 3, false",
+            "4 # 2 * 3, true",
+    })
+    @DisplayName("checkWeird")
+    public void checkWeird(String input, boolean expected) {
+        StringReader stringReader = new StringReader();
+
+        assertThat(stringReader.checkWeird(input)).isEqualTo(expected);
+    }
+}