🚀 2단계 - 문자열 덧셈 계산기

src/main/java/step2/calculator/StringAddCalculator.java

@@ -0,0 +1,23 @@
+package step2.calculator;
+
+public class StringAddCalculator {
+
+    public static int calculate(String input) {
+        validate(input);
+        StringAddCalculatorToken[] tokens = split(input);
+        return sum(tokens);
+    }
+
+    private static void validate(String input) {
+        StringAddCalculatorInputValidator.validate(input);
+    }
+
+    private static StringAddCalculatorToken[] split(String input) {
+        return StringAddCalculatorTokenGenerator.generateTokens(input);
+    }
+
+    private static int sum(StringAddCalculatorToken[] tokens) {
+        return StringAddCalculatorTokenCalculator.sum(tokens);
+    }
+
+}

src/main/java/step2/calculator/StringAddCalculatorInputValidator.java

@@ -0,0 +1,22 @@
+package step2.calculator;
+
+class StringAddCalculatorInputValidatorException extends RuntimeException {
+
+    public StringAddCalculatorInputValidatorException(String message) {
+        super(message);
+    }
+}
+
+public class StringAddCalculatorInputValidator {
+
+    public static void validate(String input) {
+        if (input == null || input.isEmpty()) {
+            // "null" and "Empty String" are valid in StringAddCalculator
+            return;
+        }
+
+        if (input.isBlank()) {
+            throw new StringAddCalculatorInputValidatorException("Input cannot be blank");
+        }
+    }
+}

src/main/java/step2/calculator/StringAddCalculatorToken.java

@@ -0,0 +1,39 @@
+package step2.calculator;
+
+
+class StringAddCalculatorTokenException extends RuntimeException {
+
+    public StringAddCalculatorTokenException(String message) {
+        super(message);
+    }
+}
+
+
+public class StringAddCalculatorToken {
+
+    private final int value;
+
+    public StringAddCalculatorToken(String value) {
+        if (value.isEmpty()) {
+            this.value = 0;
+            return;
+        }
+        this.value = Integer.parseInt(value);
+        validate();
+    }
+
+    public StringAddCalculatorToken(int number) {
+        this.value = number;
+        validate();
+    }
+
+    private void validate() {
+        if (this.value < 0) {
+            throw new StringAddCalculatorTokenException("Don't allow negative number");
+        }
+    }
+
+    public int toInteger() {
+        return this.value;
+    }
+}

src/main/java/step2/calculator/StringAddCalculatorTokenCalculator.java

@@ -0,0 +1,12 @@
+package step2.calculator;
+
+public class StringAddCalculatorTokenCalculator {
+
+    public static int sum(StringAddCalculatorToken[] tokens) {
+        int result = 0;
+        for (StringAddCalculatorToken stringAddCalculatorToken : tokens) {
+            result += stringAddCalculatorToken.toInteger();
+        }
+        return result;
+    }
+}

src/main/java/step2/calculator/StringAddCalculatorTokenGenerator.java

@@ -0,0 +1,42 @@
+package step2.calculator;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class StringAddCalculatorTokenGenerator {
+
+    final static String[] defaultDelimiters = {",", ":"};
+    final static String[] defaultCustomDelimiterRegexes = {"//(\\D)\n(.*)"};
+
+    public static StringAddCalculatorToken[] generateTokens(String input) {
+        if (input == null || input.isEmpty()) {
+            return new StringAddCalculatorToken[]{new StringAddCalculatorToken(0)};
+        }
+
+        ArrayList<String> delimiters = new ArrayList<>(Arrays.asList(defaultDelimiters));
+
+        for (String customDelimiterRegex : defaultCustomDelimiterRegexes) {
+            Matcher matcher = Pattern.compile(customDelimiterRegex).matcher(input);
+            if (matcher.find()) {
+                String customDelimiter = matcher.group(1);
+                delimiters.add(customDelimiter);
+                input = matcher.group(2);
+            }
+        }
+
+        String[] stringTokens = input.split(String.format("[%s]", String.join("", delimiters)));
+        if (input.startsWith("-") && delimiters.contains("-")) {
+            stringTokens[1] = "-" + stringTokens[1];
+        }
+
+        StringAddCalculatorToken[] stringAddCalculatorTokens = new StringAddCalculatorToken[stringTokens.length];
+        for (int i = 0; i < stringTokens.length; i++) {
+            stringAddCalculatorTokens[i] = new StringAddCalculatorToken(stringTokens[i]);
+        }
+
+        return stringAddCalculatorTokens;
+    }
+
+}

src/test/java/study/SetTest.java → src/test/java/step1/study/SetTest.java

@@ -1,6 +1,7 @@
-package study;
+package step1.study;
 
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 
@@ -25,21 +26,23 @@ void setUp() {
         numbers.add(3);
     }
 
-    // Test Case 구현
     @Test
-    void srs1Test() {
-        assertThat(numbers.size()).isEqualTo(3);
+    @DisplayName("set.size()")
+    void size() {
+        assertThat(numbers).hasSize(3);
     }
 
     @ParameterizedTest
     @ValueSource(ints = {1, 2, 3})
-    void srs2Test(int number) {
-        assertThat(numbers.contains(number)).isTrue();
+    @DisplayName("set.contains() #1")
+    void contains1(int number) {
+        assertThat(numbers).contains(number);
     }
 
     @ParameterizedTest
     @CsvSource(value = {"1:true", "2:true", "3:true", "4:false", "5:false"}, delimiter = ':')
-    void srs3Test(int number, boolean expected) {
+    @DisplayName("set.contains() #2")
+    void contains2(int number, boolean expected) {
         assertThat(numbers.contains(number)).isEqualTo(expected);
     }
 }

src/test/java/step1/study/StringTest.java

@@ -0,0 +1,39 @@
+package step1.study;
+
+import org.junit.jupiter.api.DisplayName;
+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.assertThatExceptionOfType;
+
+public class StringTest {
+
+    @Test
+    @DisplayName("String.split()")
+    void split() {
+        String value1 = "1,2";
+        assertThat(value1.split(",")).containsExactly("1", "2");
+
+        String value2 = "1";
+        assertThat(value2.split(",")).containsExactly("1");
+    }
+
+    @Test
+    @DisplayName("String.substring()")
+    void substring() {
+        String value = "(1,2)";
+        assertThat(value.substring(1, value.length() - 1)).isEqualTo("1,2");
+    }
+
+    @Test
+    @DisplayName("String.charAt()")
+    void charAt() {
+        String value = "abc";
+        assertThat(value.charAt(0)).isEqualTo('a');
+        assertThat(value.charAt(1)).isEqualTo('b');
+        assertThat(value.charAt(2)).isEqualTo('c');
+        assertThatThrownBy(() -> {value.charAt(3);}).
+            isExactlyInstanceOf(StringIndexOutOfBoundsException.class);
+    }
+}

src/test/java/step2/calculator/StringAddCalculatorTest.java

@@ -0,0 +1,87 @@
+package step2.calculator;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class StringAddCalculatorTest {
+
+    @Test
+    @DisplayName("input: null --> output: 0")
+    public void givenNull_whenCalculate_thenReturnZero() {
+        int result = StringAddCalculator.calculate(null);
+        assertThat(result).isEqualTo(0);
+    }
+
+    @Test
+    @DisplayName("input: \"\"(=Empty String) --> output: 0")
+    public void givenEmptyString_whenCalculate_thenReturnZero() {
+        int result = StringAddCalculator.calculate("");
+        assertThat(result).isEqualTo(0);
+    }
+
+    @Test
+    @DisplayName("input: \" \"(=Blank) --> output: RuntimeException")
+    public void givenBlank_whenCalculate_thenThrowException() {
+        assertThatThrownBy(() -> StringAddCalculator.calculate(" ")).isExactlyInstanceOf(
+            StringAddCalculatorInputValidatorException.class);
+    }
+
+    @Test
+    @DisplayName("input: \"1\" --> output: 1")
+    public void givenOneNumber_whenCalculate_thenReturnJustNumber() {
+        int result = StringAddCalculator.calculate("1");
+        assertThat(result).isEqualTo(1);
+    }
+
+    @Test
+    @DisplayName("input: \"1,2\" --> output: 3")
+    public void givenTwoNumbersWithComma_whenCalculate_thenReturnSum() {
+        int result = StringAddCalculator.calculate("1,2");
+        assertThat(result).isEqualTo(3);
+    }
+
+    @Test
+    @DisplayName("input: \"1,2:3\" --> output: 6")
+    public void givenThreeNumbersWithCommaAndColon_whenCalculate_thenReturnSum() {
+        int result = StringAddCalculator.calculate("1,2:3");
+        assertThat(result).isEqualTo(6);
+    }
+
+    @Test
+    @DisplayName("input: \"//;\\n1;2;3\" --> output: 6")
+    public void givenThreeNumbersWithCustomDelimiter_whenCalculate_thenReturnSum() {
+        int result = StringAddCalculator.calculate("//;\n1;2;3");
+        assertThat(result).isEqualTo(6);
+    }
+
+    @Test
+    @DisplayName("input: \"//-\n1-2-3\" --> output: 6")
+    public void givenThreeNumbersWithCustomDelimiterMinus_whenCalculate_thenReturnSum() {
+        int result = StringAddCalculator.calculate("//-\n1-2-3");
+        assertThat(result).isEqualTo(6);
+    }
+
+    @Test
+    @DisplayName("input: \"-1,2,3\" --> output: StringAddCalculatorTokenException(=RuntimeException)")
+    public void givenNegativeNumber_whenCalculate_thenThrowException() {
+        assertThatThrownBy(() -> StringAddCalculator.calculate("-1,2,3")).isExactlyInstanceOf(
+            StringAddCalculatorTokenException.class);
+    }
+
+    @Test
+    @DisplayName("input: \"//-\n-1-2-3\" --> output: RuntimeException")
+    public void givenNegativeNumberWithCustomDelimiterMinus_whenCalculate_thenThrowException() {
+        assertThatThrownBy(() -> StringAddCalculator.calculate("//-\n-1-2-3")).isExactlyInstanceOf(
+            StringAddCalculatorTokenException.class);
+    }
+
+    @Test
+    @DisplayName("input: \"11,22:33\" --> output: 66")
+    public void givenTwoDigits_whenCalculate_thenReturnSum() {
+        int result = StringAddCalculator.calculate("11,22:33");
+        assertThat(result).isEqualTo(66);
+    }
+}