From 04ecb715986d39431a7486383b0c23d391eefb35 Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Wed, 5 Feb 2025 18:51:32 +0900 Subject: [PATCH 1/9] =?UTF-8?q?Feat:=20=EC=B4=88=EA=B0=84=EB=8B=A8=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Calculator.java | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 src/main/java/Calculator.java diff --git a/src/main/java/Calculator.java b/src/main/java/Calculator.java new file mode 100644 index 0000000..01b4901 --- /dev/null +++ b/src/main/java/Calculator.java @@ -0,0 +1,21 @@ +public class Calculator { + + public int add(int num1, int num2) { + return num1 + num2; + } + + public int subtract(int num1, int num2) { + return num1 - num2; + } + + public int multiply(int num1, int num2) { + return num1 * num2; + } + + public int divide(int dividend, int divisor) { + if(divisor == 0){ + throw new ArithmeticException("0으로 나눌 수 없습니다."); + } + return dividend / divisor; + } +} From 2866d936d55b0ba7fdc8ede8b41dd8658e6e63ef Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Wed, 5 Feb 2025 18:51:59 +0900 Subject: [PATCH 2/9] =?UTF-8?q?Feat:=20=EC=B4=88=EA=B0=84=EB=8B=A8=20?= =?UTF-8?q?=EB=AC=B8=EC=9E=90=EC=97=B4=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/CalculatorTest.java | 105 ++++++++++++++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 src/test/java/CalculatorTest.java diff --git a/src/test/java/CalculatorTest.java b/src/test/java/CalculatorTest.java new file mode 100644 index 0000000..bb2e031 --- /dev/null +++ b/src/test/java/CalculatorTest.java @@ -0,0 +1,105 @@ +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Nested; +import static org.junit.jupiter.api.Assertions.*; + +public class CalculatorTest { + + private final Calculator calculator = new Calculator(); + + @Nested + @DisplayName("덧셈 테스트") + class addTest { + + @Test + @DisplayName("덧셈 성공 테스트") + void add_SuccessTest() { + final int a = 3; + final int b = 5; + final int actual = a+b; + + assertEquals(actual, calculator.add(a,b)); + } + + @Test + @DisplayName("덧셈 실패 테스트") + void add_FailTest() { + final int a = 3; + final int b = 5; + + assertNotEquals(0, calculator.add(a,b)); + } + } + + @Nested + @DisplayName("뺄셈 데스트") + class subtractTest { + + @Test + @DisplayName("뺄셈 성공 테스트") + void subtract_SuccessTest() { + final int a = 5; + final int b = 3; + final int actual = a-b; + + assertEquals(actual, calculator.subtract(a,b)); + } + + @Test + @DisplayName("뺄셈 실패 테스트") + void subtract_FailTest() { + final int a = 5; + final int b = 3; + + assertNotEquals(0, calculator.subtract(a,b)); + } + } + + @Nested + @DisplayName("곱셈 테스트") + class multiplyTest { + + @Test + @DisplayName("곱셈 성공 테스트") + void multiply_SuccessTest() { + final int a = 5; + final int b = 3; + final int actual = a*b; + + assertEquals(actual, calculator.multiply(a,b)); + } + + @Test + @DisplayName("곱셈 실패 테스트") + void multiply_FailTest() { + final int a = 5; + final int b = 3; + + assertNotEquals(0, calculator.multiply(a,b)); + } + } + + @Nested + @DisplayName("나눗셈 테스트") + class divideTest { + + @Test + @DisplayName("나눗셈 성공 테스트") + void divide_SuccessTest() { + final int a = 15; + final int b = 3; + final int actual = a/b; + + assertEquals(actual, calculator.divide(a,b)); + } + + @Test + @DisplayName("나눗셈 실패 테스트") + void divide_FailTest() { + final int a = 15; + final int b = 0; + + assertThrows(ArithmeticException.class, () -> calculator.divide(a,b)); + } + } +} From c4ba8e2083b7eee02508d70b67951f29e75ef04a Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Wed, 5 Feb 2025 19:30:05 +0900 Subject: [PATCH 3/9] =?UTF-8?q?Chore:=20CalculatorTest=20DisplayName=20?= =?UTF-8?q?=EC=88=98=EC=A0=95=20=EB=B0=8F=20=EC=9D=98=EB=AF=B8=EC=97=86?= =?UTF-8?q?=EB=8A=94=20=EA=B2=80=EC=A6=9D=20=EB=A9=94=EC=84=9C=EB=93=9C=20?= =?UTF-8?q?=EC=82=AD=EC=A0=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/CalculatorTest.java | 47 +++++++------------------------ 1 file changed, 10 insertions(+), 37 deletions(-) diff --git a/src/test/java/CalculatorTest.java b/src/test/java/CalculatorTest.java index bb2e031..18a2253 100644 --- a/src/test/java/CalculatorTest.java +++ b/src/test/java/CalculatorTest.java @@ -12,23 +12,14 @@ public class CalculatorTest { class addTest { @Test - @DisplayName("덧셈 성공 테스트") - void add_SuccessTest() { + @DisplayName("정수의 합") + void add_Test() { final int a = 3; final int b = 5; final int actual = a+b; assertEquals(actual, calculator.add(a,b)); } - - @Test - @DisplayName("덧셈 실패 테스트") - void add_FailTest() { - final int a = 3; - final int b = 5; - - assertNotEquals(0, calculator.add(a,b)); - } } @Nested @@ -36,23 +27,14 @@ void add_FailTest() { class subtractTest { @Test - @DisplayName("뺄셈 성공 테스트") - void subtract_SuccessTest() { + @DisplayName("정수의 차") + void subtract_Test() { final int a = 5; final int b = 3; final int actual = a-b; assertEquals(actual, calculator.subtract(a,b)); } - - @Test - @DisplayName("뺄셈 실패 테스트") - void subtract_FailTest() { - final int a = 5; - final int b = 3; - - assertNotEquals(0, calculator.subtract(a,b)); - } } @Nested @@ -60,23 +42,14 @@ void subtract_FailTest() { class multiplyTest { @Test - @DisplayName("곱셈 성공 테스트") - void multiply_SuccessTest() { + @DisplayName("정수의 곱셈") + void multiply_Test() { final int a = 5; final int b = 3; final int actual = a*b; assertEquals(actual, calculator.multiply(a,b)); } - - @Test - @DisplayName("곱셈 실패 테스트") - void multiply_FailTest() { - final int a = 5; - final int b = 3; - - assertNotEquals(0, calculator.multiply(a,b)); - } } @Nested @@ -84,8 +57,8 @@ void multiply_FailTest() { class divideTest { @Test - @DisplayName("나눗셈 성공 테스트") - void divide_SuccessTest() { + @DisplayName("정수의 나눗셈") + void divide_Test() { final int a = 15; final int b = 3; final int actual = a/b; @@ -94,8 +67,8 @@ void divide_SuccessTest() { } @Test - @DisplayName("나눗셈 실패 테스트") - void divide_FailTest() { + @DisplayName("0으로 나누었을 때 ArithmeticException 예외 발생") + void divideWithZero_Test() { final int a = 15; final int b = 0; From 66c20b2d025993fbe233f6bd8aadee111e4fb74d Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Fri, 7 Feb 2025 01:56:20 +0900 Subject: [PATCH 4/9] =?UTF-8?q?Refactor:=201-2=EB=8B=A8=EA=B3=84=20?= =?UTF-8?q?=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0=20=EB=B0=98=EC=98=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Calculator.java | 4 +- src/test/java/CalculatorTest.java | 78 +++++++++++++++++++++++-------- 2 files changed, 61 insertions(+), 21 deletions(-) diff --git a/src/main/java/Calculator.java b/src/main/java/Calculator.java index 01b4901..4d2169e 100644 --- a/src/main/java/Calculator.java +++ b/src/main/java/Calculator.java @@ -13,8 +13,8 @@ public int multiply(int num1, int num2) { } public int divide(int dividend, int divisor) { - if(divisor == 0){ - throw new ArithmeticException("0으로 나눌 수 없습니다."); + if (divisor == 0) { + throw new ArithmeticException("Divide by zero"); } return dividend / divisor; } diff --git a/src/test/java/CalculatorTest.java b/src/test/java/CalculatorTest.java index 18a2253..0da7d67 100644 --- a/src/test/java/CalculatorTest.java +++ b/src/test/java/CalculatorTest.java @@ -12,13 +12,23 @@ public class CalculatorTest { class addTest { @Test - @DisplayName("정수의 합") - void add_Test() { + @DisplayName("두 정수의 합을 반환한다.") + void shouldReturnSumOfTwoIntegers() { final int a = 3; final int b = 5; - final int actual = a+b; + final int actual = a + b; - assertEquals(actual, calculator.add(a,b)); + assertEquals(actual, calculator.add(a, b)); + } + + @Test + @DisplayName("두 음수 정수의 합을 반환한다.") + void shouldReturnSumOfTwoNegativeIntegers() { + final int a = -3; + final int b = -5; + final int actual = a + b; + + assertEquals(actual, calculator.add(a, b)); } } @@ -27,13 +37,23 @@ void add_Test() { class subtractTest { @Test - @DisplayName("정수의 차") - void subtract_Test() { + @DisplayName("두 정수의 차를 반환한다.") + void shouldReturnSubtractOfTwoIntegers() { final int a = 5; final int b = 3; - final int actual = a-b; + final int actual = a - b; + + assertEquals(actual, calculator.subtract(a, b)); + } + + @Test + @DisplayName("두 음수 정수의 차를 반환한다.") + void shouldReturnSubtractOfTwoNegativeIntegers() { + final int a = -5; + final int b = -3; + final int actual = a - b; - assertEquals(actual, calculator.subtract(a,b)); + assertEquals(actual, calculator.subtract(a, b)); } } @@ -42,13 +62,23 @@ void subtract_Test() { class multiplyTest { @Test - @DisplayName("정수의 곱셈") - void multiply_Test() { + @DisplayName("두 정수의 곱을 반환한다.") + void shouldReturnMultiplyOfTwoIntegers() { final int a = 5; final int b = 3; - final int actual = a*b; + final int actual = a * b; - assertEquals(actual, calculator.multiply(a,b)); + assertEquals(actual, calculator.multiply(a, b)); + } + + @Test + @DisplayName("두 음수 정수의 곱을 반환한다.") + void shouldReturnMultiplyOfTwoNegativeIntegers() { + final int a = -5; + final int b = -3; + final int actual = a * b; + + assertEquals(actual, calculator.multiply(a, b)); } } @@ -57,22 +87,32 @@ void multiply_Test() { class divideTest { @Test - @DisplayName("정수의 나눗셈") - void divide_Test() { + @DisplayName("두 정수의 몫을 반환한다.") + void shouldReturnDivideOfTwoIntegers() { final int a = 15; final int b = 3; - final int actual = a/b; + final int actual = a / b; + + assertEquals(actual, calculator.divide(a, b)); + } + + @Test + @DisplayName("두 음수 정수의 몫을 반환한다.") + void shouldReturnDivideOfTwoNegativeIntegers() { + final int a = -15; + final int b = -3; + final int actual = a / b; - assertEquals(actual, calculator.divide(a,b)); + assertEquals(actual, calculator.divide(a, b)); } @Test - @DisplayName("0으로 나누었을 때 ArithmeticException 예외 발생") - void divideWithZero_Test() { + @DisplayName("정수를 0으로 나누면 ArithmeticException이 발생한다.") + void shouldReturnDivideWithZeroOfTwoIntegers() { final int a = 15; final int b = 0; - assertThrows(ArithmeticException.class, () -> calculator.divide(a,b)); + assertThrows(ArithmeticException.class, () -> calculator.divide(a, b)); } } } From 72c5c03b05416197365f33140caab76d37e534e4 Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Sun, 9 Feb 2025 05:29:11 +0900 Subject: [PATCH 5/9] =?UTF-8?q?Feat:=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/StringCalculator.java | 81 ++++++++++++ src/test/java/StringCalculatorTest.java | 165 ++++++++++++++++++++++++ 2 files changed, 246 insertions(+) create mode 100644 src/main/java/StringCalculator.java create mode 100644 src/test/java/StringCalculatorTest.java diff --git a/src/main/java/StringCalculator.java b/src/main/java/StringCalculator.java new file mode 100644 index 0000000..fdce9aa --- /dev/null +++ b/src/main/java/StringCalculator.java @@ -0,0 +1,81 @@ +import java.util.Arrays; + +public class StringCalculator { + + private static int[] ExpressionToTokens(String expression) { + try { + String tokens = expression; + String delimiters = "[,:]"; + + if (expression.contains("//") && expression.contains("\n")) { + String customDelimiter = extractCustomDelimiter(expression); + tokens = extractToken(expression); + delimiters = "[,:" + customDelimiter + "]"; + } + + String[] splitTokens = tokens.split(delimiters); + return StringArrayToIntArray(splitTokens); + } catch (NumberFormatException e) { + throw new RuntimeException("Contains non-numerical values."); + } + } + + private static String extractCustomDelimiter(String expression) { + int startIndex = expression.indexOf("//") + 2; + int endIndex = expression.indexOf("\n"); + return expression.substring(startIndex, endIndex); + } + + private static String extractToken(String expression) { + int startIndex = expression.indexOf("//"); + int endIndex = expression.indexOf("\n"); + + return expression.substring(0, startIndex) + expression.substring(startIndex + 2, endIndex) + expression.substring(endIndex + 1); + } + + private static int[] StringArrayToIntArray(String[] expression) { + return Arrays.stream(expression).mapToInt(Integer::parseInt).toArray(); + } + + public int add(String expression) { + int[] tokens = ExpressionToTokens(expression); + int answer = tokens[0]; + for (int i = 1; i < tokens.length; i++) { + answer += tokens[i]; + } + return answer; + } + + public int subtract(String expression) { + int[] tokens = ExpressionToTokens(expression); + int answer = tokens[0]; + for (int i = 1; i < tokens.length; i++) { + answer -= tokens[i]; + } + return answer; + } + + public int multiply(String expression) { + int[] tokens = ExpressionToTokens(expression); + int answer = tokens[0]; + for (int i = 1; i < tokens.length; i++) { + answer *= tokens[i]; + } + return answer; + + } + + public int divide(String expression) { + int[] tokens = ExpressionToTokens(expression); + int answer = tokens[0]; + for (int i = 1; i < tokens.length; i++) { + if (tokens[i] == 0) { + throw new ArithmeticException("Divide by zero"); + } + answer /= tokens[i]; + } + return answer; + + } +} + diff --git a/src/test/java/StringCalculatorTest.java b/src/test/java/StringCalculatorTest.java new file mode 100644 index 0000000..445e451 --- /dev/null +++ b/src/test/java/StringCalculatorTest.java @@ -0,0 +1,165 @@ +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class StringCalculatorTest { + + private final StringCalculator stringCalculator = new StringCalculator(); + + @Nested + @DisplayName("입력된 문자열 합 계산") + class addTest { + + @Test + @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 합을 반환한다.") + public void shouldReturnSumOfString() { + final String expression = "1,2:3"; + assertEquals(6, stringCalculator.add(expression)); + } + + @Test + @DisplayName("숫자 문자 1개만 입력 되었을 때 해당 숫자를 반환한다.") + public void shouldReturnSumOfChar() { + final String expression = "1"; + assertEquals(1, stringCalculator.add(expression)); + } + + @Test + @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") + public void shouldReturnRuntimeExceptionToNumberFormatException() { + final String expression = "example"; + assertThrows(RuntimeException.class, () -> stringCalculator.add(expression)); + } + + @Test + @DisplayName("커스텀 구분자를 사용한 문자열의 합을 반환한다.") + public void shouldReturnSumWithCustomDistinguishedOfString() { + final String expression = "1//;\n2,3:4"; + assertEquals(10, stringCalculator.add(expression)); + } + + } + + @Nested + @DisplayName("입력된 문자열의 차 계산") + class subtractTest { + + @Test + @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 차로 양수를 반환한다.") + public void shouldReturnSubtractWithPositiveOfString() { + final String expression = "4,2:1"; + assertEquals(1, stringCalculator.subtract(expression)); + } + + @Test + @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 차로 0을 반환한다.") + public void shouldReturnSubtractWithZeroOfString() { + final String expression = "3:2,1"; + assertEquals(0, stringCalculator.subtract(expression)); + } + + @Test + @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 차로 음수를 반환한다.") + public void shouldReturnSubtractWithNegativeOfString() { + final String expression = "1,2:3"; + assertEquals(-4, stringCalculator.subtract(expression)); + } + + @Test + @DisplayName("숫자 문자 1개만 입력 되었을 때 해당 숫자를 반환한다.") + public void shouldReturnSubtractOfChar() { + final String expression = "1"; + assertEquals(1, stringCalculator.subtract(expression)); + } + + @Test + @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") + public void shouldReturnRuntimeExceptionToNumberFormatException() { + final String expression = "example"; + assertThrows(RuntimeException.class, () -> stringCalculator.subtract(expression)); + } + + @Test + @DisplayName("커스텀 구분자를 사용한 문자열의 차을 반환한다.") + public void shouldReturnSumWithCustomDistinguishedOfString() { + final String expression = "4:1//;\n2,1"; + assertEquals(0, stringCalculator.subtract(expression)); + } + } + + @Nested + @DisplayName("입력된 문자열의 곱 계산") + class multiplyTest { + + @Test + @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 곱으로 양수를 반환한다.") + public void shouldReturnMultiplyWithPositiveOfString() { + final String expression = "1,2:3"; + assertEquals(6, stringCalculator.multiply(expression)); + } + + @Test + @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 곱으로 0을 반환한다.") + public void shouldReturnMultiplyWithZeroOfString() { + final String expression = "1,2:0"; + assertEquals(0, stringCalculator.multiply(expression)); + } + + @Test + @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 곱으로 음수를 반환한다.") + public void shouldReturnMultiplyWithNegativeOfString() { + final String expression = "1,2:-3"; + assertEquals(-6, stringCalculator.multiply(expression)); + } + + @Test + @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") + public void shouldReturnRuntimeExceptionToNumberFormatException() { + final String expression = "example"; + assertThrows(RuntimeException.class, () -> stringCalculator.multiply(expression)); + } + + @Test + @DisplayName("커스텀 구분자를 사용한 문자열의 곱을 반환한다.") + public void shouldReturnSumWithCustomDistinguishedOfString() { + final String expression = "2:4,1//;\n2"; + assertEquals(16, stringCalculator.multiply(expression)); + } + } + + @Nested + @DisplayName("입력된 문자열의 몫 계산") + class divideTest { + + @Test + @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 몫으로 양수를 반환한다.") + public void shouldReturnDivideOfStringToPositive() { + final String expression = "24,2:3"; + assertEquals(4, stringCalculator.divide(expression)); + } + + @Test + @DisplayName("0으로 나누면 ArithmeticException이 발생한다..") + void shouldReturnDivideWithZeroOfString() { + final String expression = "1,2:0"; + assertThrows(ArithmeticException.class, () -> stringCalculator.divide(expression)); + } + + @Test + @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") + public void shouldReturnRuntimeExceptionToNumberFormatException() { + final String expression = "example"; + assertThrows(RuntimeException.class, () -> stringCalculator.divide(expression)); + } + + @Test + @DisplayName("커스텀 구분자를 사용한 문자열의 몫을 반환한다.") + public void shouldReturnSumWithCustomDistinguishedOfString() { + final String expression = "50:2,5//;\n1"; + assertEquals(5, stringCalculator.divide(expression)); + } + } +} From 057a54a35caf7b2de6c044ac6232b018561c3d20 Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Sun, 9 Feb 2025 16:21:52 +0900 Subject: [PATCH 6/9] =?UTF-8?q?Fix:=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20=ED=85=8C=EC=8A=A4=ED=8A=B8?= =?UTF-8?q?=EC=BD=94=EB=93=9C=20AssertJ=20=ED=98=95=EC=8B=9D=EC=9C=BC?= =?UTF-8?q?=EB=A1=9C=20=EC=88=98=EC=A0=95(JUnit=20>=20AssertJ)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build.gradle | 2 ++ src/test/java/StringCalculatorTest.java | 42 ++++++++++++------------- 2 files changed, 23 insertions(+), 21 deletions(-) diff --git a/build.gradle b/build.gradle index 87254a3..239f9e7 100644 --- a/build.gradle +++ b/build.gradle @@ -11,7 +11,9 @@ repositories { dependencies { 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') } test { diff --git a/src/test/java/StringCalculatorTest.java b/src/test/java/StringCalculatorTest.java index 445e451..3341774 100644 --- a/src/test/java/StringCalculatorTest.java +++ b/src/test/java/StringCalculatorTest.java @@ -2,8 +2,8 @@ import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; public class StringCalculatorTest { @@ -17,28 +17,28 @@ class addTest { @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 합을 반환한다.") public void shouldReturnSumOfString() { final String expression = "1,2:3"; - assertEquals(6, stringCalculator.add(expression)); + assertThat(6).isSameAs(stringCalculator.add(expression)); } @Test @DisplayName("숫자 문자 1개만 입력 되었을 때 해당 숫자를 반환한다.") public void shouldReturnSumOfChar() { final String expression = "1"; - assertEquals(1, stringCalculator.add(expression)); + assertThat(1).isSameAs(stringCalculator.add(expression)); } @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") public void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; - assertThrows(RuntimeException.class, () -> stringCalculator.add(expression)); + assertThatThrownBy(() -> stringCalculator.add(expression)).isInstanceOf(RuntimeException.class); } @Test @DisplayName("커스텀 구분자를 사용한 문자열의 합을 반환한다.") public void shouldReturnSumWithCustomDistinguishedOfString() { final String expression = "1//;\n2,3:4"; - assertEquals(10, stringCalculator.add(expression)); + assertThat(10).isSameAs(stringCalculator.add(expression)); } } @@ -51,42 +51,42 @@ class subtractTest { @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 차로 양수를 반환한다.") public void shouldReturnSubtractWithPositiveOfString() { final String expression = "4,2:1"; - assertEquals(1, stringCalculator.subtract(expression)); + assertThat(1).isSameAs(stringCalculator.subtract(expression)); } @Test @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 차로 0을 반환한다.") public void shouldReturnSubtractWithZeroOfString() { final String expression = "3:2,1"; - assertEquals(0, stringCalculator.subtract(expression)); + assertThat(0).isSameAs(stringCalculator.subtract(expression)); } @Test @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 차로 음수를 반환한다.") public void shouldReturnSubtractWithNegativeOfString() { final String expression = "1,2:3"; - assertEquals(-4, stringCalculator.subtract(expression)); + assertThat(-4).isSameAs(stringCalculator.subtract(expression)); } @Test @DisplayName("숫자 문자 1개만 입력 되었을 때 해당 숫자를 반환한다.") public void shouldReturnSubtractOfChar() { final String expression = "1"; - assertEquals(1, stringCalculator.subtract(expression)); + assertThat(1).isSameAs(stringCalculator.subtract(expression)); } @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") public void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; - assertThrows(RuntimeException.class, () -> stringCalculator.subtract(expression)); + assertThatThrownBy(() -> stringCalculator.subtract(expression)).isInstanceOf(RuntimeException.class); } @Test @DisplayName("커스텀 구분자를 사용한 문자열의 차을 반환한다.") public void shouldReturnSumWithCustomDistinguishedOfString() { final String expression = "4:1//;\n2,1"; - assertEquals(0, stringCalculator.subtract(expression)); + assertThat(0).isSameAs(stringCalculator.subtract(expression)); } } @@ -98,35 +98,35 @@ class multiplyTest { @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 곱으로 양수를 반환한다.") public void shouldReturnMultiplyWithPositiveOfString() { final String expression = "1,2:3"; - assertEquals(6, stringCalculator.multiply(expression)); + assertThat(6).isSameAs(stringCalculator.multiply(expression)); } @Test @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 곱으로 0을 반환한다.") public void shouldReturnMultiplyWithZeroOfString() { final String expression = "1,2:0"; - assertEquals(0, stringCalculator.multiply(expression)); + assertThat(0).isSameAs(stringCalculator.multiply(expression)); } @Test @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 곱으로 음수를 반환한다.") public void shouldReturnMultiplyWithNegativeOfString() { final String expression = "1,2:-3"; - assertEquals(-6, stringCalculator.multiply(expression)); + assertThat(-6).isSameAs(stringCalculator.multiply(expression)); } @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") public void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; - assertThrows(RuntimeException.class, () -> stringCalculator.multiply(expression)); + assertThatThrownBy(() -> stringCalculator.multiply(expression)).isInstanceOf(RuntimeException.class); } @Test @DisplayName("커스텀 구분자를 사용한 문자열의 곱을 반환한다.") public void shouldReturnSumWithCustomDistinguishedOfString() { final String expression = "2:4,1//;\n2"; - assertEquals(16, stringCalculator.multiply(expression)); + assertThat(16).isSameAs(stringCalculator.multiply(expression)); } } @@ -138,28 +138,28 @@ class divideTest { @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 몫으로 양수를 반환한다.") public void shouldReturnDivideOfStringToPositive() { final String expression = "24,2:3"; - assertEquals(4, stringCalculator.divide(expression)); + assertThat(4).isSameAs(stringCalculator.divide(expression)); } @Test @DisplayName("0으로 나누면 ArithmeticException이 발생한다..") void shouldReturnDivideWithZeroOfString() { final String expression = "1,2:0"; - assertThrows(ArithmeticException.class, () -> stringCalculator.divide(expression)); + assertThatThrownBy(() -> stringCalculator.divide(expression)).isInstanceOf(ArithmeticException.class); } @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") public void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; - assertThrows(RuntimeException.class, () -> stringCalculator.divide(expression)); + assertThatThrownBy(() -> stringCalculator.divide(expression)).isInstanceOf(RuntimeException.class); } @Test @DisplayName("커스텀 구분자를 사용한 문자열의 몫을 반환한다.") public void shouldReturnSumWithCustomDistinguishedOfString() { final String expression = "50:2,5//;\n1"; - assertEquals(5, stringCalculator.divide(expression)); + assertThat(5).isSameAs(stringCalculator.divide(expression)); } } } From 5a9277fe5eeb43116c14ff0a3d34efcc1ab8bd37 Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Sun, 9 Feb 2025 16:50:17 +0900 Subject: [PATCH 7/9] =?UTF-8?q?Fix:=20=EA=B3=84=EC=82=B0=EA=B8=B0=20?= =?UTF-8?q?=EA=B5=AC=ED=98=84=20=ED=85=8C=EC=8A=A4=ED=8A=B8=EC=BD=94?= =?UTF-8?q?=EB=93=9C=20AssertJ=20=ED=98=95=EC=8B=9D=EC=9C=BC=EB=A1=9C=20?= =?UTF-8?q?=EC=88=98=EC=A0=95=20(JUnit=20>=20AssertJ)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/CalculatorTest.java | 30 +++++++----- src/test/java/StringCalculatorTest.java | 64 ++++++++++++------------- 2 files changed, 49 insertions(+), 45 deletions(-) diff --git a/src/test/java/CalculatorTest.java b/src/test/java/CalculatorTest.java index 0da7d67..9844d7f 100644 --- a/src/test/java/CalculatorTest.java +++ b/src/test/java/CalculatorTest.java @@ -1,7 +1,9 @@ import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Nested; -import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; public class CalculatorTest { @@ -11,14 +13,16 @@ public class CalculatorTest { @DisplayName("덧셈 테스트") class addTest { + private final Calculator calculator = new Calculator(); + @Test @DisplayName("두 정수의 합을 반환한다.") void shouldReturnSumOfTwoIntegers() { final int a = 3; final int b = 5; - final int actual = a + b; + final int actual = 8; - assertEquals(actual, calculator.add(a, b)); + assertThat(actual).isEqualTo(calculator.add(a, b)); } @Test @@ -26,9 +30,9 @@ void shouldReturnSumOfTwoIntegers() { void shouldReturnSumOfTwoNegativeIntegers() { final int a = -3; final int b = -5; - final int actual = a + b; + final int actual = -8; - assertEquals(actual, calculator.add(a, b)); + assertThat(actual).isEqualTo(calculator.add(a, b)); } } @@ -43,7 +47,7 @@ void shouldReturnSubtractOfTwoIntegers() { final int b = 3; final int actual = a - b; - assertEquals(actual, calculator.subtract(a, b)); + assertThat(actual).isEqualTo(calculator.subtract(a, b)); } @Test @@ -53,7 +57,7 @@ void shouldReturnSubtractOfTwoNegativeIntegers() { final int b = -3; final int actual = a - b; - assertEquals(actual, calculator.subtract(a, b)); + assertThat(actual).isEqualTo(calculator.subtract(a, b)); } } @@ -68,7 +72,7 @@ void shouldReturnMultiplyOfTwoIntegers() { final int b = 3; final int actual = a * b; - assertEquals(actual, calculator.multiply(a, b)); + assertThat(actual).isEqualTo(calculator.multiply(a, b)); } @Test @@ -78,7 +82,7 @@ void shouldReturnMultiplyOfTwoNegativeIntegers() { final int b = -3; final int actual = a * b; - assertEquals(actual, calculator.multiply(a, b)); + assertThat(actual).isEqualTo(calculator.multiply(a, b)); } } @@ -93,7 +97,7 @@ void shouldReturnDivideOfTwoIntegers() { final int b = 3; final int actual = a / b; - assertEquals(actual, calculator.divide(a, b)); + assertThat(actual).isEqualTo(calculator.divide(a, b)); } @Test @@ -103,7 +107,7 @@ void shouldReturnDivideOfTwoNegativeIntegers() { final int b = -3; final int actual = a / b; - assertEquals(actual, calculator.divide(a, b)); + assertThat(actual).isEqualTo(calculator.divide(a, b)); } @Test @@ -112,7 +116,7 @@ void shouldReturnDivideWithZeroOfTwoIntegers() { final int a = 15; final int b = 0; - assertThrows(ArithmeticException.class, () -> calculator.divide(a, b)); + assertThatThrownBy(() -> calculator.divide(a, b)).isInstanceOf(ArithmeticException.class); } } } diff --git a/src/test/java/StringCalculatorTest.java b/src/test/java/StringCalculatorTest.java index 3341774..329cf45 100644 --- a/src/test/java/StringCalculatorTest.java +++ b/src/test/java/StringCalculatorTest.java @@ -15,30 +15,30 @@ class addTest { @Test @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 합을 반환한다.") - public void shouldReturnSumOfString() { + void shouldReturnSumOfString() { final String expression = "1,2:3"; - assertThat(6).isSameAs(stringCalculator.add(expression)); + assertThat(6).isEqualTo(stringCalculator.add(expression)); } @Test @DisplayName("숫자 문자 1개만 입력 되었을 때 해당 숫자를 반환한다.") - public void shouldReturnSumOfChar() { + void shouldReturnSumOfChar() { final String expression = "1"; - assertThat(1).isSameAs(stringCalculator.add(expression)); + assertThat(1).isEqualTo(stringCalculator.add(expression)); } @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") - public void shouldReturnRuntimeExceptionToNumberFormatException() { + void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; assertThatThrownBy(() -> stringCalculator.add(expression)).isInstanceOf(RuntimeException.class); } @Test @DisplayName("커스텀 구분자를 사용한 문자열의 합을 반환한다.") - public void shouldReturnSumWithCustomDistinguishedOfString() { + void shouldReturnSumWithCustomDistinguishedOfString() { final String expression = "1//;\n2,3:4"; - assertThat(10).isSameAs(stringCalculator.add(expression)); + assertThat(10).isEqualTo(stringCalculator.add(expression)); } } @@ -49,44 +49,44 @@ class subtractTest { @Test @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 차로 양수를 반환한다.") - public void shouldReturnSubtractWithPositiveOfString() { + void shouldReturnSubtractWithPositiveOfString() { final String expression = "4,2:1"; - assertThat(1).isSameAs(stringCalculator.subtract(expression)); + assertThat(1).isEqualTo(stringCalculator.subtract(expression)); } @Test @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 차로 0을 반환한다.") - public void shouldReturnSubtractWithZeroOfString() { + void shouldReturnSubtractWithZeroOfString() { final String expression = "3:2,1"; - assertThat(0).isSameAs(stringCalculator.subtract(expression)); + assertThat(0).isEqualTo(stringCalculator.subtract(expression)); } @Test @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 차로 음수를 반환한다.") - public void shouldReturnSubtractWithNegativeOfString() { + void shouldReturnSubtractWithNegativeOfString() { final String expression = "1,2:3"; - assertThat(-4).isSameAs(stringCalculator.subtract(expression)); + assertThat(-4).isEqualTo(stringCalculator.subtract(expression)); } @Test @DisplayName("숫자 문자 1개만 입력 되었을 때 해당 숫자를 반환한다.") - public void shouldReturnSubtractOfChar() { + void shouldReturnSubtractOfChar() { final String expression = "1"; - assertThat(1).isSameAs(stringCalculator.subtract(expression)); + assertThat(1).isEqualTo(stringCalculator.subtract(expression)); } @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") - public void shouldReturnRuntimeExceptionToNumberFormatException() { + void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; assertThatThrownBy(() -> stringCalculator.subtract(expression)).isInstanceOf(RuntimeException.class); } @Test @DisplayName("커스텀 구분자를 사용한 문자열의 차을 반환한다.") - public void shouldReturnSumWithCustomDistinguishedOfString() { + void shouldReturnSumWithCustomDistinguishedOfString() { final String expression = "4:1//;\n2,1"; - assertThat(0).isSameAs(stringCalculator.subtract(expression)); + assertThat(0).isEqualTo(stringCalculator.subtract(expression)); } } @@ -96,37 +96,37 @@ class multiplyTest { @Test @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 곱으로 양수를 반환한다.") - public void shouldReturnMultiplyWithPositiveOfString() { + void shouldReturnMultiplyWithPositiveOfString() { final String expression = "1,2:3"; - assertThat(6).isSameAs(stringCalculator.multiply(expression)); + assertThat(6).isEqualTo(stringCalculator.multiply(expression)); } @Test @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 곱으로 0을 반환한다.") - public void shouldReturnMultiplyWithZeroOfString() { + void shouldReturnMultiplyWithZeroOfString() { final String expression = "1,2:0"; - assertThat(0).isSameAs(stringCalculator.multiply(expression)); + assertThat(0).isEqualTo(stringCalculator.multiply(expression)); } @Test @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 곱으로 음수를 반환한다.") - public void shouldReturnMultiplyWithNegativeOfString() { + void shouldReturnMultiplyWithNegativeOfString() { final String expression = "1,2:-3"; - assertThat(-6).isSameAs(stringCalculator.multiply(expression)); + assertThat(-6).isEqualTo(stringCalculator.multiply(expression)); } @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") - public void shouldReturnRuntimeExceptionToNumberFormatException() { + void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; assertThatThrownBy(() -> stringCalculator.multiply(expression)).isInstanceOf(RuntimeException.class); } @Test @DisplayName("커스텀 구분자를 사용한 문자열의 곱을 반환한다.") - public void shouldReturnSumWithCustomDistinguishedOfString() { + void shouldReturnSumWithCustomDistinguishedOfString() { final String expression = "2:4,1//;\n2"; - assertThat(16).isSameAs(stringCalculator.multiply(expression)); + assertThat(16).isEqualTo(stringCalculator.multiply(expression)); } } @@ -136,9 +136,9 @@ class divideTest { @Test @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 몫으로 양수를 반환한다.") - public void shouldReturnDivideOfStringToPositive() { + void shouldReturnDivideOfStringToPositive() { final String expression = "24,2:3"; - assertThat(4).isSameAs(stringCalculator.divide(expression)); + assertThat(4).isEqualTo(stringCalculator.divide(expression)); } @Test @@ -150,16 +150,16 @@ void shouldReturnDivideWithZeroOfString() { @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") - public void shouldReturnRuntimeExceptionToNumberFormatException() { + void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; assertThatThrownBy(() -> stringCalculator.divide(expression)).isInstanceOf(RuntimeException.class); } @Test @DisplayName("커스텀 구분자를 사용한 문자열의 몫을 반환한다.") - public void shouldReturnSumWithCustomDistinguishedOfString() { + void shouldReturnSumWithCustomDistinguishedOfString() { final String expression = "50:2,5//;\n1"; - assertThat(5).isSameAs(stringCalculator.divide(expression)); + assertThat(5).isEqualTo(stringCalculator.divide(expression)); } } } From ac55a997fc99940baf5549e4456755909437b6e1 Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Sun, 9 Feb 2025 17:03:39 +0900 Subject: [PATCH 8/9] =?UTF-8?q?Chore:=20StringCalculatorTest=20=EB=A9=94?= =?UTF-8?q?=EC=84=9C=EB=93=9C=EB=AA=85=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/StringCalculatorTest.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/test/java/StringCalculatorTest.java b/src/test/java/StringCalculatorTest.java index 329cf45..d746e28 100644 --- a/src/test/java/StringCalculatorTest.java +++ b/src/test/java/StringCalculatorTest.java @@ -36,7 +36,7 @@ void shouldReturnRuntimeExceptionToNumberFormatException() { @Test @DisplayName("커스텀 구분자를 사용한 문자열의 합을 반환한다.") - void shouldReturnSumWithCustomDistinguishedOfString() { + void shouldReturnSumWithCustomDelimiterOfString() { final String expression = "1//;\n2,3:4"; assertThat(10).isEqualTo(stringCalculator.add(expression)); } @@ -84,7 +84,7 @@ void shouldReturnRuntimeExceptionToNumberFormatException() { @Test @DisplayName("커스텀 구분자를 사용한 문자열의 차을 반환한다.") - void shouldReturnSumWithCustomDistinguishedOfString() { + void shouldReturnSumWithCustomDelimiterOfString() { final String expression = "4:1//;\n2,1"; assertThat(0).isEqualTo(stringCalculator.subtract(expression)); } @@ -124,7 +124,7 @@ void shouldReturnRuntimeExceptionToNumberFormatException() { @Test @DisplayName("커스텀 구분자를 사용한 문자열의 곱을 반환한다.") - void shouldReturnSumWithCustomDistinguishedOfString() { + void shouldReturnSumWithCustomDelimiterOfString() { final String expression = "2:4,1//;\n2"; assertThat(16).isEqualTo(stringCalculator.multiply(expression)); } @@ -142,7 +142,7 @@ void shouldReturnDivideOfStringToPositive() { } @Test - @DisplayName("0으로 나누면 ArithmeticException이 발생한다..") + @DisplayName("0으로 나누면 ArithmeticException이 발생한다.") void shouldReturnDivideWithZeroOfString() { final String expression = "1,2:0"; assertThatThrownBy(() -> stringCalculator.divide(expression)).isInstanceOf(ArithmeticException.class); @@ -157,7 +157,7 @@ void shouldReturnRuntimeExceptionToNumberFormatException() { @Test @DisplayName("커스텀 구분자를 사용한 문자열의 몫을 반환한다.") - void shouldReturnSumWithCustomDistinguishedOfString() { + void shouldReturnSumWithCustomDelimiterOfString() { final String expression = "50:2,5//;\n1"; assertThat(5).isEqualTo(stringCalculator.divide(expression)); } From 6a11e37187067f6c410d67d7bcd97bd65f8a475f Mon Sep 17 00:00:00 2001 From: "Park, seun" Date: Thu, 13 Feb 2025 01:23:21 +0900 Subject: [PATCH 9/9] =?UTF-8?q?Refactor:=20PR=20=EB=A6=AC=EB=B7=B0=20?= =?UTF-8?q?=EA=B8=B0=EB=B0=98=EC=9C=BC=EB=A1=9C=20=EC=BD=94=EB=93=9C=20?= =?UTF-8?q?=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/StringCalculator.java | 86 ++++++--------- src/test/java/CalculatorTest.java | 12 +-- src/test/java/StringCalculatorTest.java | 134 ++++++------------------ 3 files changed, 70 insertions(+), 162 deletions(-) diff --git a/src/main/java/StringCalculator.java b/src/main/java/StringCalculator.java index fdce9aa..fe2f000 100644 --- a/src/main/java/StringCalculator.java +++ b/src/main/java/StringCalculator.java @@ -1,81 +1,57 @@ import java.util.Arrays; +import java.util.regex.Matcher; +import java.util.regex.Pattern; public class StringCalculator { - private static int[] ExpressionToTokens(String expression) { - try { - String tokens = expression; - String delimiters = "[,:]"; - if (expression.contains("//") && expression.contains("\n")) { - String customDelimiter = extractCustomDelimiter(expression); - tokens = extractToken(expression); - delimiters = "[,:" + customDelimiter + "]"; - } - - String[] splitTokens = tokens.split(delimiters); - return StringArrayToIntArray(splitTokens); - } catch (NumberFormatException e) { - throw new RuntimeException("Contains non-numerical values."); + private static int[] expressionToTokens(String expression) { + if (expression.isEmpty()) { + return new int[]{0}; } - } - private static String extractCustomDelimiter(String expression) { - int startIndex = expression.indexOf("//") + 2; - int endIndex = expression.indexOf("\n"); - return expression.substring(startIndex, endIndex); - } - - private static String extractToken(String expression) { - int startIndex = expression.indexOf("//"); - int endIndex = expression.indexOf("\n"); + String tokens = expression; + String delimiters = "[,:]"; - return expression.substring(0, startIndex) + expression.substring(startIndex + 2, endIndex) + expression.substring(endIndex + 1); - } + if (expression.contains("//") && expression.contains("\n")) { + String customDelimiter = extractCustomDelimiter(expression); + tokens = extractToken(expression); + delimiters = "[,:]" + "|" + customDelimiter; + } - private static int[] StringArrayToIntArray(String[] expression) { - return Arrays.stream(expression).mapToInt(Integer::parseInt).toArray(); + String[] splitTokens = tokens.split(delimiters); + return stringArrayToIntArray(splitTokens); } - public int add(String expression) { - int[] tokens = ExpressionToTokens(expression); - int answer = tokens[0]; - for (int i = 1; i < tokens.length; i++) { - answer += tokens[i]; + private static String extractCustomDelimiter(String expression) { + Pattern pattern = Pattern.compile("//(.*?)\n"); + Matcher matcher = pattern.matcher(expression); + if (matcher.find()) { + return Pattern.quote(matcher.group(1)); } - return answer; + throw new IllegalArgumentException("Invalid custom delimiter format"); } - public int subtract(String expression) { - int[] tokens = ExpressionToTokens(expression); - int answer = tokens[0]; - for (int i = 1; i < tokens.length; i++) { - answer -= tokens[i]; - } - return answer; + private static String extractToken(String expression) { + return expression.replaceFirst("//.*?\n", ","); } - public int multiply(String expression) { - int[] tokens = ExpressionToTokens(expression); - int answer = tokens[0]; - for (int i = 1; i < tokens.length; i++) { - answer *= tokens[i]; + private static int[] stringArrayToIntArray(String[] expression) { + try{ + return Arrays.stream(expression).mapToInt(Integer::parseInt).toArray(); + } catch (NumberFormatException e) { + throw new RuntimeException("Contains non-numerical values."); } - return answer; - } - public int divide(String expression) { - int[] tokens = ExpressionToTokens(expression); + public int add(String expression) { + int[] tokens = expressionToTokens(expression); + int answer = tokens[0]; for (int i = 1; i < tokens.length; i++) { - if (tokens[i] == 0) { - throw new ArithmeticException("Divide by zero"); - } - answer /= tokens[i]; + answer += tokens[i]; } return answer; - } } diff --git a/src/test/java/CalculatorTest.java b/src/test/java/CalculatorTest.java index 9844d7f..4856734 100644 --- a/src/test/java/CalculatorTest.java +++ b/src/test/java/CalculatorTest.java @@ -45,7 +45,7 @@ class subtractTest { void shouldReturnSubtractOfTwoIntegers() { final int a = 5; final int b = 3; - final int actual = a - b; + final int actual = 2; assertThat(actual).isEqualTo(calculator.subtract(a, b)); } @@ -55,7 +55,7 @@ void shouldReturnSubtractOfTwoIntegers() { void shouldReturnSubtractOfTwoNegativeIntegers() { final int a = -5; final int b = -3; - final int actual = a - b; + final int actual = -2; assertThat(actual).isEqualTo(calculator.subtract(a, b)); } @@ -70,7 +70,7 @@ class multiplyTest { void shouldReturnMultiplyOfTwoIntegers() { final int a = 5; final int b = 3; - final int actual = a * b; + final int actual = 15; assertThat(actual).isEqualTo(calculator.multiply(a, b)); } @@ -80,7 +80,7 @@ void shouldReturnMultiplyOfTwoIntegers() { void shouldReturnMultiplyOfTwoNegativeIntegers() { final int a = -5; final int b = -3; - final int actual = a * b; + final int actual = 15; assertThat(actual).isEqualTo(calculator.multiply(a, b)); } @@ -95,7 +95,7 @@ class divideTest { void shouldReturnDivideOfTwoIntegers() { final int a = 15; final int b = 3; - final int actual = a / b; + final int actual = 5; assertThat(actual).isEqualTo(calculator.divide(a, b)); } @@ -105,7 +105,7 @@ void shouldReturnDivideOfTwoIntegers() { void shouldReturnDivideOfTwoNegativeIntegers() { final int a = -15; final int b = -3; - final int actual = a / b; + final int actual = 5; assertThat(actual).isEqualTo(calculator.divide(a, b)); } diff --git a/src/test/java/StringCalculatorTest.java b/src/test/java/StringCalculatorTest.java index d746e28..26a32d1 100644 --- a/src/test/java/StringCalculatorTest.java +++ b/src/test/java/StringCalculatorTest.java @@ -21,145 +21,77 @@ void shouldReturnSumOfString() { } @Test - @DisplayName("숫자 문자 1개만 입력 되었을 때 해당 숫자를 반환한다.") + @DisplayName("숫자 한 개만 입력된 경우 해당 숫자를 반환한다.") void shouldReturnSumOfChar() { final String expression = "1"; assertThat(1).isEqualTo(stringCalculator.add(expression)); } + } - @Test - @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") - void shouldReturnRuntimeExceptionToNumberFormatException() { - final String expression = "example"; - assertThatThrownBy(() -> stringCalculator.add(expression)).isInstanceOf(RuntimeException.class); - } + @Nested + @DisplayName("커스텀 구분자를 포함한 문자열 합 계산") + class CustomDelimiterTest { @Test @DisplayName("커스텀 구분자를 사용한 문자열의 합을 반환한다.") void shouldReturnSumWithCustomDelimiterOfString() { final String expression = "1//;\n2,3:4"; - assertThat(10).isEqualTo(stringCalculator.add(expression)); + assertThat(stringCalculator.add(expression)).isEqualTo(10); } - } - - @Nested - @DisplayName("입력된 문자열의 차 계산") - class subtractTest { - @Test - @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 차로 양수를 반환한다.") - void shouldReturnSubtractWithPositiveOfString() { - final String expression = "4,2:1"; - assertThat(1).isEqualTo(stringCalculator.subtract(expression)); - } - - @Test - @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 차로 0을 반환한다.") - void shouldReturnSubtractWithZeroOfString() { - final String expression = "3:2,1"; - assertThat(0).isEqualTo(stringCalculator.subtract(expression)); - } - - @Test - @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 차로 음수를 반환한다.") - void shouldReturnSubtractWithNegativeOfString() { - final String expression = "1,2:3"; - assertThat(-4).isEqualTo(stringCalculator.subtract(expression)); - } - - @Test - @DisplayName("숫자 문자 1개만 입력 되었을 때 해당 숫자를 반환한다.") - void shouldReturnSubtractOfChar() { - final String expression = "1"; - assertThat(1).isEqualTo(stringCalculator.subtract(expression)); - } - - @Test - @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") - void shouldReturnRuntimeExceptionToNumberFormatException() { - final String expression = "example"; - assertThatThrownBy(() -> stringCalculator.subtract(expression)).isInstanceOf(RuntimeException.class); + @DisplayName("커스텀 구분자와 기본 구분자를 함께 사용한 문자열의 합을 반환한다.") + void shouldReturnSumWithCustomDelimiterAndDefaultDelimiterOfString() { + final String expression = "1//***\n2,3***4"; + assertThat(stringCalculator.add(expression)).isEqualTo(10); } @Test - @DisplayName("커스텀 구분자를 사용한 문자열의 차을 반환한다.") - void shouldReturnSumWithCustomDelimiterOfString() { - final String expression = "4:1//;\n2,1"; - assertThat(0).isEqualTo(stringCalculator.subtract(expression)); + @DisplayName("커스텀 구분자가 여러 개 문자를 포함할 때 문자열의 합을 반환한다.") + void shouldReturnSumWithCustomDelimitersOfString() { + final String expression = "1//**\n2**3**4"; + assertThat(stringCalculator.add(expression)).isEqualTo(10); } } @Nested - @DisplayName("입력된 문자열의 곱 계산") - class multiplyTest { - - @Test - @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 곱으로 양수를 반환한다.") - void shouldReturnMultiplyWithPositiveOfString() { - final String expression = "1,2:3"; - assertThat(6).isEqualTo(stringCalculator.multiply(expression)); - } - - @Test - @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 곱으로 0을 반환한다.") - void shouldReturnMultiplyWithZeroOfString() { - final String expression = "1,2:0"; - assertThat(0).isEqualTo(stringCalculator.multiply(expression)); - } - - @Test - @DisplayName("쉽표와 콜론을 구분자로 가지는 문자열의 곱으로 음수를 반환한다.") - void shouldReturnMultiplyWithNegativeOfString() { - final String expression = "1,2:-3"; - assertThat(-6).isEqualTo(stringCalculator.multiply(expression)); - } + @DisplayName("예외 발생") + class ExceptionTest { @Test @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") void shouldReturnRuntimeExceptionToNumberFormatException() { final String expression = "example"; - assertThatThrownBy(() -> stringCalculator.multiply(expression)).isInstanceOf(RuntimeException.class); + assertThatThrownBy(() -> stringCalculator.add(expression)).isInstanceOf(RuntimeException.class); } @Test - @DisplayName("커스텀 구분자를 사용한 문자열의 곱을 반환한다.") - void shouldReturnSumWithCustomDelimiterOfString() { - final String expression = "2:4,1//;\n2"; - assertThat(16).isEqualTo(stringCalculator.multiply(expression)); + @DisplayName("빈 문자열이 입력된 경우 0을 반환한다.") + void shouldReturnZeroWhenEmptyStringIsEntered() { + final String expression = ""; + assertThat(stringCalculator.add(expression)).isEqualTo(0); } - } - - @Nested - @DisplayName("입력된 문자열의 몫 계산") - class divideTest { @Test - @DisplayName("쉼표와 콜론을 구분자로 가지는 문자열의 몫으로 양수를 반환한다.") - void shouldReturnDivideOfStringToPositive() { - final String expression = "24,2:3"; - assertThat(4).isEqualTo(stringCalculator.divide(expression)); + @DisplayName("구분자만 입력된 경우 RuntimeException이 발생한다.") + void shouldThrowRuntimeExceptionWhenOnlyDelimitersAreEntered() { + final String expression = ",,,"; + assertThatThrownBy(() -> stringCalculator.add(expression)).isInstanceOf(RuntimeException.class); } @Test - @DisplayName("0으로 나누면 ArithmeticException이 발생한다.") - void shouldReturnDivideWithZeroOfString() { - final String expression = "1,2:0"; - assertThatThrownBy(() -> stringCalculator.divide(expression)).isInstanceOf(ArithmeticException.class); + @DisplayName("커스텀 구분자 사이에 공백이 포함된 경우 RuntimeException이 발생한다.") + void shouldThrowRuntimeExceptionWhenSpaceExistsBetweenCustomDelimiters() { + final String expression = "1//;\n2; 3;4"; + assertThatThrownBy(() -> stringCalculator.add(expression)).isInstanceOf(RuntimeException.class); } @Test - @DisplayName("숫자가 아닌 문자열이 입력 되었을 때 RuntimeException이 발생한다.") - void shouldReturnRuntimeExceptionToNumberFormatException() { - final String expression = "example"; - assertThatThrownBy(() -> stringCalculator.divide(expression)).isInstanceOf(RuntimeException.class); + @DisplayName("커스텀 구분자를 잘못된 방식으로 입력한 경우 RuntimeException이 발생한다.") + void shouldThrowRuntimeExceptionWhenInvalidCustomDelimiterFormatIsUsed() { + final String expression = "//;\n1;2;3;"; + assertThatThrownBy(() -> stringCalculator.add(expression)).isInstanceOf(RuntimeException.class); } - @Test - @DisplayName("커스텀 구분자를 사용한 문자열의 몫을 반환한다.") - void shouldReturnSumWithCustomDelimiterOfString() { - final String expression = "50:2,5//;\n1"; - assertThat(5).isEqualTo(stringCalculator.divide(expression)); - } } }