[이동훈] 1차시 미션 제출합니다.

build.gradle

@@ -10,11 +10,10 @@ repositories {
 }
 
 dependencies {
-    testImplementation platform('org.junit:junit-bom:5.9.1')
-    testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation platform('org.junit:junit-bom:5.9.1')
     testImplementation platform('org.assertj:assertj-bom:3.25.1')
     testImplementation('org.junit.jupiter:junit-jupiter')
+
     testImplementation('org.assertj:assertj-core')
 }
 

src/main/java/domain/Calculator.java

@@ -0,0 +1,25 @@
+package domain;
+
+import exception.ErrorMessage;
+
+public class Calculator {
+
+    public int add(int num1, int num2) {
+        return Math.addExact(num1, num2);
+    }
+
+    public int sub(int num1, int num2) {
+        return Math.subtractExact(num1, num2);
+    }
+
+    public int mul(int num1, int num2) {
+        return Math.multiplyExact(num1, num2);
+    }
+
+    public int div(int num1, int num2) {
+        if (num2 == 0)
+            throw new ArithmeticException(ErrorMessage.DIVIDE_BY_ZERO);
+
+        return num1 / num2;
+    }
+}

src/main/java/domain/StringCalculator.java

@@ -0,0 +1,52 @@
+package domain;
+
+import exception.ErrorMessage;
+import util.DelimiterUtil;
+import util.ParseUtil;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class StringCalculator {
+
+    public int calculate(String str) {
+        if (str == null) {
+            throw new RuntimeException(ErrorMessage.NULL_STRING);
+        }
+
+        if (str.isBlank())
+            return 0;
+
+        String customDelimiter = DelimiterUtil.findCustomDelimiter(str);
+        String strNumbers = extractNumber(str, customDelimiter);
+        String[] tokens = splitTokens(strNumbers, customDelimiter);
+        List<Integer> numbers = ParseUtil.parseNumber(tokens);
+
+        return sum(numbers);
+    }
+
+    private String extractNumber(String str, String customDelimiter) {
+        if (customDelimiter != null) {
+            return str.substring(str.indexOf("\n") + 1);
+        }
+
+        return str;
+    }
+
+    private String[] splitTokens(String strNumbers, String customDelimiter) {
+        String delimiterRegex = "[,|:]";
+
+        if (customDelimiter == null) {
+            return strNumbers.split(delimiterRegex);
+        }
+
+        return strNumbers.split(Pattern.quote(customDelimiter));
+    }
+
+    private int sum(List<Integer> numbers) {
+        return numbers.stream()
+                .mapToInt(Integer::intValue)
+                .sum();
+    }
+}

src/main/java/exception/ErrorMessage.java

@@ -0,0 +1,14 @@
+package exception;
+
+public class ErrorMessage {
+
+    public static final String NULL_STRING = "문자열에 null 값이 전달되었습니다.";
+    public static final String CUSTOM_DELIMITER_NOT_FOUND = "커스텀 구분자를 찾을 수 없습니다.";
+    public static final String NEGATIVE_NUMBER_NOT_ALLOWED = "음수는 처리할 수 없습니다.";
+    public static final String INVALID_STRING = "문자열은 처리할 수 없습니다.";
+    public static final String DIVIDE_BY_ZERO = "0으로 나눌 수 없습니다.";
+
+    private ErrorMessage() {
+        throw new RuntimeException();
+    }
+}

src/main/java/util/DelimiterUtil.java

@@ -0,0 +1,21 @@
+package util;
+
+import exception.ErrorMessage;
+
+public class DelimiterUtil {
+
+    public static String findCustomDelimiter(String str) {
+        int startDelimiterIdx = str.indexOf("//");
+        int endDelimiterIdx = str.indexOf("\n");
+
+        if (startDelimiterIdx == -1 && endDelimiterIdx == -1) {
+            return null;
+        }
+
+        if ((startDelimiterIdx == -1) ^ (endDelimiterIdx == -1) || (startDelimiterIdx + 2 == endDelimiterIdx)) {
+            throw new RuntimeException(ErrorMessage.CUSTOM_DELIMITER_NOT_FOUND);
+        }
+
+        return str.substring(startDelimiterIdx + 2, endDelimiterIdx);
+    }
+}

src/main/java/util/ParseUtil.java

@@ -0,0 +1,29 @@
+package util;
+
+import exception.ErrorMessage;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class ParseUtil {
+
+    public static List<Integer> parseNumber(String[] tokens) {
+        return Arrays.stream(tokens)
+            .map(ParseUtil::parseTokenToInt)
+            .toList();
+    }
+
+    public static int parseTokenToInt(String token) {
+        try {
+            int number = Integer.parseInt(token.trim());
+
+            if (number < 0) {
+                throw new RuntimeException(ErrorMessage.NEGATIVE_NUMBER_NOT_ALLOWED);
+            }
+
+            return number;
+        } catch (NumberFormatException ex) {
+            throw new RuntimeException(ErrorMessage.INVALID_STRING);
+        }
+    }
+}

src/test/java/CalculatorTest.java

@@ -1,66 +1,83 @@
-import org.junit.jupiter.api.DisplayName;
+import domain.Calculator;
+import exception.ErrorMessage;
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.*;
 
-@DisplayName("계산기 기능 테스트 클래스")
 public class CalculatorTest {
+
+    private final Calculator calculator = new Calculator();
+
+    @Test
+    public void 덧셈_테스트() {
+        final int num1 = 1;
+        final int num2 = 2;
+        final int actual = calculator.add(num1, num2);
+
+        assertThat(actual).isEqualTo(num1 + num2);
+    }
+
     @Test
-    @DisplayName("더하기 연산 테스트")
-    public void testAdd() {
-        int num1 = 1, num2 = 2;
+    public void 뺄셈_테스트() {
+        final int num1 = 3;
+        final int num2 = 2;
+        final int actual = calculator.sub(num1, num2);
 
-        assertThat(3).isEqualTo(Calculator.add(num1, num2));
+        assertThat(actual).isEqualTo(num1 - num2);
     }
 
     @Test
-    @DisplayName("빼기 연산 테스트")
-    public void testSub() {
-        int num1 = 1, num2 = 2;
+    public void 곱셈_테스트() {
+        final int num1 = 3;
+        final int num2 = 2;
+        final int actual = calculator.mul(num1, num2);
 
-        assertThat(-1).isEqualTo(Calculator.sub(num1, num2));
+        assertThat(actual).isEqualTo(num1 * num2);
     }
 
     @Test
-    @DisplayName("곱하기 연산 테스트")
-    public void testMul() {
-        int num1 = 10, num2 = 2;
+    public void 나눗셈_테스트() {
+        final int num1 = 4;
+        final int num2 = 2;
+        final int actual = calculator.div(num1, num2);
 
-        assertThat(20).isEqualTo(Calculator.mul(num1, num2));
+        assertThat(actual).isEqualTo(num1 / num2);
     }
 
     @Test
-    @DisplayName("나누기 연산 테스트")
-    public void testDiv() {
-        int num1 = 1, num2 = 2;
+    public void 덧셈_오버플로우_예외_발생() {
+        final int num1 = Integer.MAX_VALUE;
+        final int num2 = Integer.MAX_VALUE;
 
-        assertThat(0).isEqualTo(Calculator.div(num1, num2));
+        assertThatThrownBy(() -> calculator.add(num1, num2))
+                .isInstanceOf(ArithmeticException.class);
     }
 
     @Test
-    @DisplayName("나누기 연산에서 나누는 값이 0인지 테스트")
-    public void testDivideByZero() {
-        int num1 = 2, num2 = 0;
+    public void 뺄셈_오버플로우_예외_발생() {
+        final int num1 = Integer.MIN_VALUE;
+        final int num2 = Integer.MAX_VALUE;
 
-        assertThatThrownBy(() -> {
-            Calculator.div(num1, num2);
-        }).isInstanceOf(ArithmeticException.class);
+        assertThatThrownBy(() -> calculator.sub(num1, num2))
+                .isInstanceOf(ArithmeticException.class);
     }
 
     @Test
-    @DisplayName("연산 후 int 범위를 벗어나는 지 테스트")
-    public void testOverflow() {
-        assertThatThrownBy(() -> {
-            Calculator.add(Integer.MAX_VALUE, 1);
-        }).isInstanceOf(ArithmeticException.class);
-
-        assertThatThrownBy(() -> {
-            Calculator.sub(Integer.MIN_VALUE, 1);
-        }).isInstanceOf(ArithmeticException.class);
-
-        assertThatThrownBy(() -> {
-            Calculator.mul(Integer.MAX_VALUE, 2);
-        }).isInstanceOf(ArithmeticException.class);
+    public void 곱셈_오버플로우_예외_발생() {
+        final int num1 = Integer.MAX_VALUE;
+        final int num2 = Integer.MAX_VALUE;
+
+        assertThatThrownBy(() -> calculator.mul(num1, num2))
+                .isInstanceOf(ArithmeticException.class);
+    }
+
+    @Test
+    public void 나눗셈_0으로_나누면_예외_발생() {
+        final int num1 = Integer.MAX_VALUE;
+        final int num2 = 0;
+
+        assertThatThrownBy(() -> calculator.div(num1, num2))
+                .isInstanceOf(ArithmeticException.class)
+                .hasMessageContaining(ErrorMessage.DIVIDE_BY_ZERO);
     }
 }