From 0c4e779d7d5db32c66cf638fae10046c878a1e04 Mon Sep 17 00:00:00 2001 From: hamliet Date: Wed, 5 Feb 2020 13:25:47 +0900 Subject: [PATCH 01/29] =?UTF-8?q?[add]=20String=20=ED=81=B4=EB=9E=98?= =?UTF-8?q?=EC=8A=A4=EC=97=90=20=EB=8C=80=ED=95=9C=20=ED=95=99=EC=8A=B5=20?= =?UTF-8?q?=ED=85=8C=EC=8A=A4=ED=8A=B8=20-=20=EC=9A=94=EA=B5=AC=EC=82=AC?= =?UTF-8?q?=ED=95=AD1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/empty.txt | 0 src/test/java/study/StringTest.java | 25 +++++++++++++++++++++++++ 2 files changed, 25 insertions(+) delete mode 100644 src/test/java/empty.txt create mode 100644 src/test/java/study/StringTest.java diff --git a/src/test/java/empty.txt b/src/test/java/empty.txt deleted file mode 100644 index e69de29b..00000000 diff --git a/src/test/java/study/StringTest.java b/src/test/java/study/StringTest.java new file mode 100644 index 00000000..f7d82a34 --- /dev/null +++ b/src/test/java/study/StringTest.java @@ -0,0 +1,25 @@ +package study; + +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.*; + +public class StringTest { + @Test + void split() { + String value = "1,2"; + String[] result = value.split(","); + assertThat(result).contains("1"); + assertThat(result).contains("2"); + } + + @Test + void split2() { + String value2 = "1"; + String[] result2 = value2.split(","); + assertThat(result2).contains("1"); + assertThat(result2).containsExactly("1"); + } + +} From c9243856aeb0a08b9aa5a173bdabee2c9735206e Mon Sep 17 00:00:00 2001 From: hamliet Date: Wed, 5 Feb 2020 13:27:51 +0900 Subject: [PATCH 02/29] =?UTF-8?q?[add]=20String=20=ED=81=B4=EB=9E=98?= =?UTF-8?q?=EC=8A=A4=EC=97=90=20=EB=8C=80=ED=95=9C=20=ED=95=99=EC=8A=B5=20?= =?UTF-8?q?=ED=85=8C=EC=8A=A4=ED=8A=B8=20-=20=EC=9A=94=EA=B5=AC=EC=82=AC?= =?UTF-8?q?=ED=95=AD2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/StringTest.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/test/java/study/StringTest.java b/src/test/java/study/StringTest.java index f7d82a34..2419afc5 100644 --- a/src/test/java/study/StringTest.java +++ b/src/test/java/study/StringTest.java @@ -22,4 +22,10 @@ void split2() { assertThat(result2).containsExactly("1"); } + @Test + void substring() { + String value3 = "(1,2)"; + String result3 = value3.substring(1,4); + assertThat(result3).contains("1,2"); + } } From c82d818d223a57a6e4ae53cb6091d6acad8a7f51 Mon Sep 17 00:00:00 2001 From: hamliet Date: Wed, 5 Feb 2020 16:57:40 +0900 Subject: [PATCH 03/29] =?UTF-8?q?[add]=20String=20=ED=81=B4=EB=9E=98?= =?UTF-8?q?=EC=8A=A4=EC=97=90=20=EB=8C=80=ED=95=9C=20=ED=95=99=EC=8A=B5=20?= =?UTF-8?q?=ED=85=8C=EC=8A=A4=ED=8A=B8=20-=20=EC=9A=94=EA=B5=AC=EC=82=AC?= =?UTF-8?q?=ED=95=AD3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/StringTest.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/test/java/study/StringTest.java b/src/test/java/study/StringTest.java index 2419afc5..f860dc85 100644 --- a/src/test/java/study/StringTest.java +++ b/src/test/java/study/StringTest.java @@ -1,9 +1,13 @@ package study; +import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import java.io.IOException; + import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; public class StringTest { @Test @@ -28,4 +32,15 @@ void substring() { String result3 = value3.substring(1,4); assertThat(result3).contains("1,2"); } + + @Test + @DisplayName("요구사항 3 - assertThatThrownBy, hasMessageContaining 사용") + public void testException() { + assertThatThrownBy(() -> { + String value4 = "abc"; + value4.charAt(4); + }).isInstanceOf(IndexOutOfBoundsException.class) + .hasMessageContaining("String index out of range: 4"); + } + } From 6806957faba7e7fb09fadc763abbf4c5cbe9aa18 Mon Sep 17 00:00:00 2001 From: hamliet Date: Wed, 5 Feb 2020 17:19:23 +0900 Subject: [PATCH 04/29] =?UTF-8?q?[add]=20Set=20Collection=EC=97=90=20?= =?UTF-8?q?=EB=8C=80=ED=95=9C=20=ED=95=99=EC=8A=B5=20=ED=85=8C=EC=8A=A4?= =?UTF-8?q?=ED=8A=B8=20-=20=EC=9A=94=EA=B5=AC=EC=82=AC=ED=95=AD1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/SetTest.java | 27 +++++++++++++++++++++++++++ src/test/java/study/StringTest.java | 16 ++++++++++++++-- 2 files changed, 41 insertions(+), 2 deletions(-) create mode 100644 src/test/java/study/SetTest.java diff --git a/src/test/java/study/SetTest.java b/src/test/java/study/SetTest.java new file mode 100644 index 00000000..8418284f --- /dev/null +++ b/src/test/java/study/SetTest.java @@ -0,0 +1,27 @@ +package study; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.HashSet; +import java.util.Set; + +import static org.assertj.core.api.Assertions.assertThat; + +public class SetTest { + private Set numbers; + + @BeforeEach + void setUp() { + numbers = new HashSet<>(); + numbers.add(1); + numbers.add(1); + numbers.add(2); + numbers.add(3); + } + + @Test + void numbersSizeTest(){ + assertThat( numbers.size() ).isEqualTo(3); + } +} \ No newline at end of file diff --git a/src/test/java/study/StringTest.java b/src/test/java/study/StringTest.java index f860dc85..af225c86 100644 --- a/src/test/java/study/StringTest.java +++ b/src/test/java/study/StringTest.java @@ -3,8 +3,6 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; -import java.io.IOException; - import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.*; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; @@ -43,4 +41,18 @@ public void testException() { .hasMessageContaining("String index out of range: 4"); } + @Test + @DisplayName("요구사항 3 - assertThatExceptionOfType, withMessageMatching 사용") + public void testException2() { + assertThatExceptionOfType(IndexOutOfBoundsException.class) + .isThrownBy(() -> { + String value4 = "abc"; + value4.charAt(4); + }).withMessageMatching("String index out of range: \\d+"); + } + + + + + } From 8a1e5119d2a4fb6ed7a4a5d7bc1799843d2209ed Mon Sep 17 00:00:00 2001 From: hamliet Date: Wed, 5 Feb 2020 17:24:22 +0900 Subject: [PATCH 05/29] =?UTF-8?q?[add]=20Set=20Collection=EC=97=90=20?= =?UTF-8?q?=EB=8C=80=ED=95=9C=20=ED=95=99=EC=8A=B5=20=ED=85=8C=EC=8A=A4?= =?UTF-8?q?=ED=8A=B8=20-=20=EC=9A=94=EA=B5=AC=EC=82=AC=ED=95=AD2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/SetTest.java | 9 +++++++++ src/test/java/study/StringTest.java | 5 ----- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/test/java/study/SetTest.java b/src/test/java/study/SetTest.java index 8418284f..521ac102 100644 --- a/src/test/java/study/SetTest.java +++ b/src/test/java/study/SetTest.java @@ -2,6 +2,8 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import java.util.HashSet; import java.util.Set; @@ -24,4 +26,11 @@ void setUp() { void numbersSizeTest(){ assertThat( numbers.size() ).isEqualTo(3); } + + @ParameterizedTest + @ValueSource(ints = {1, 2, 3}) + void numberExistTest(int number) { + assertThat(numbers.contains(number)).isTrue(); + } + } \ No newline at end of file diff --git a/src/test/java/study/StringTest.java b/src/test/java/study/StringTest.java index af225c86..bcff76b2 100644 --- a/src/test/java/study/StringTest.java +++ b/src/test/java/study/StringTest.java @@ -50,9 +50,4 @@ public void testException2() { value4.charAt(4); }).withMessageMatching("String index out of range: \\d+"); } - - - - - } From 9ff5ba22d0dedf90b97a63595fa5d07857374ec8 Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:25:18 +0900 Subject: [PATCH 06/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20README.md=20=ED=8C=8C?= =?UTF-8?q?=EC=9D=BC=20=EC=9E=91=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 21 ++++++++++++++++----- src/main/java/empty.txt | 0 src/test/java/study/SetTest.java | 10 ++++++++-- src/test/java/study/StringTest.java | 2 +- 4 files changed, 25 insertions(+), 8 deletions(-) delete mode 100644 src/main/java/empty.txt diff --git a/README.md b/README.md index 7d742d97..f4c9e879 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,16 @@ -# java-calculator -문자열 계산기 미션 저장소 - -## 우아한테크코스 코드리뷰 -* [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md) \ No newline at end of file +# 문자열 계산기 +​ +## 요구사항 +​ +- 사용자가 입력한 문자열 값에 따라 사칙연산을 수행할 수 있는 계산기를 구현해야 한다. +- 문자열 계산기는 사칙연산의 계산 우선순위가 아닌 입력 값에 따라 계산 순서가 결정된다. 즉, 수학에서는 곱셈, 나눗셈이 덧셈, 뺄셈 보다 먼저 계산해야 하지만 이를 무시한다. +- 예를 들어 "2 + 3 * 4 / 2"와 같은 문자열을 입력할 경우 2 + 3 * 4 / 2 실행 결과인 10을 출력해야 한다. +​ +## 추가할 기능 목록 +1. 사용자로부터 입력받기 +2. 홀수 인덱스와 짝수 인덱스로 나누는 함수 + 1. 짝수 인덱스일 때는 부호를 저장하는 로직 + 2. 홀수 인덱스일 경우에는 계산하는 함수 호출 +3. 계산하는 함수 구현 +4. 사칙연산에 해당하는 각 함수 구현 +5. 입력값을 확인하는 핸들러 구현 \ No newline at end of file diff --git a/src/main/java/empty.txt b/src/main/java/empty.txt deleted file mode 100644 index e69de29b..00000000 diff --git a/src/test/java/study/SetTest.java b/src/test/java/study/SetTest.java index 521ac102..3db2123f 100644 --- a/src/test/java/study/SetTest.java +++ b/src/test/java/study/SetTest.java @@ -3,6 +3,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; import org.junit.jupiter.params.provider.ValueSource; import java.util.HashSet; @@ -23,8 +24,8 @@ void setUp() { } @Test - void numbersSizeTest(){ - assertThat( numbers.size() ).isEqualTo(3); + void numbersSizeTest() { + assertThat(numbers.size()).isEqualTo(3); } @ParameterizedTest @@ -33,4 +34,9 @@ void numberExistTest(int number) { assertThat(numbers.contains(number)).isTrue(); } + @ParameterizedTest + @CsvSource(value = {"1:true", "2:true", "3:true", "4:false"}, delimiter = ':') + void numberExistTest(int number, boolean result) { + assertThat(numbers.contains(number)).isEqualTo(result); + } } \ No newline at end of file diff --git a/src/test/java/study/StringTest.java b/src/test/java/study/StringTest.java index bcff76b2..68854319 100644 --- a/src/test/java/study/StringTest.java +++ b/src/test/java/study/StringTest.java @@ -27,7 +27,7 @@ void split2() { @Test void substring() { String value3 = "(1,2)"; - String result3 = value3.substring(1,4); + String result3 = value3.substring(1, 4); assertThat(result3).contains("1,2"); } From 1b360a23d9e694c79ab5a418a6a6d28577e0a1ae Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:29:22 +0900 Subject: [PATCH 07/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EC=82=AC=EC=9A=A9=EC=9E=90?= =?UTF-8?q?=EB=A1=9C=EB=B6=80=ED=84=B0=20=EC=9E=85=EB=A0=A5=EB=B0=9B?= =?UTF-8?q?=EA=B8=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Calculator.java | 16 ++++++++++++++++ 1 file changed, 16 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 00000000..f3ec3bc8 --- /dev/null +++ b/src/main/java/Calculator.java @@ -0,0 +1,16 @@ +import java.util.Scanner; + +public class Calculator { + static int returnValue; + private static final int INDEX_INIT = 1; + private static Scanner scanner = new Scanner(System.in); + + public static void main(String args[]) { + String[] values = scanner.nextLine().split(" "); + returnValue = Integer.parseInt(values[0]); + for (int i = INDEX_INIT; i < values.length; i++) { + //check 함수 + } + System.out.println(returnValue); + } +} From addb5c7597177c32b8f8e6a44b296e39815dfc4f Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:30:46 +0900 Subject: [PATCH 08/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=ED=99=80=EC=88=98=20?= =?UTF-8?q?=EC=9D=B8=EB=8D=B1=EC=8A=A4=EC=99=80=20=EC=A7=9D=EC=88=98=20?= =?UTF-8?q?=EC=9D=B8=EB=8D=B1=EC=8A=A4=EB=A1=9C=20=EB=82=98=EB=88=84?= =?UTF-8?q?=EB=8A=94=20=ED=95=A8=EC=88=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Calculator.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/main/java/Calculator.java b/src/main/java/Calculator.java index f3ec3bc8..382c47a1 100644 --- a/src/main/java/Calculator.java +++ b/src/main/java/Calculator.java @@ -3,7 +3,10 @@ public class Calculator { static int returnValue; private static final int INDEX_INIT = 1; + private static final int EVEN = 0; + private static final int ODD = 1; private static Scanner scanner = new Scanner(System.in); + private static String nowSign; public static void main(String args[]) { String[] values = scanner.nextLine().split(" "); @@ -13,4 +16,13 @@ public static void main(String args[]) { } System.out.println(returnValue); } + + private static void check(int i, String value) { + if (i % 2 == EVEN) { + //계산하는 함수 + } + if (i % 2 == ODD) { + nowSign = value; + } + } } From 47cf992d2b2b71b361de328a44a3db74b5a6652c Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:33:04 +0900 Subject: [PATCH 09/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EB=B6=80=ED=98=B8=EC=97=90?= =?UTF-8?q?=20=EB=94=B0=EB=9D=BC=20=EA=B3=84=EC=82=B0=ED=95=98=EB=8A=94=20?= =?UTF-8?q?=ED=95=A8=EC=88=98=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 | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/src/main/java/Calculator.java b/src/main/java/Calculator.java index 382c47a1..93afbd05 100644 --- a/src/main/java/Calculator.java +++ b/src/main/java/Calculator.java @@ -12,17 +12,36 @@ public static void main(String args[]) { String[] values = scanner.nextLine().split(" "); returnValue = Integer.parseInt(values[0]); for (int i = INDEX_INIT; i < values.length; i++) { - //check 함수 + check(i, values[i]); } System.out.println(returnValue); } private static void check(int i, String value) { if (i % 2 == EVEN) { - //계산하는 함수 + calculate(Integer.parseInt(value)); } if (i % 2 == ODD) { nowSign = value; } } + + private static void calculate(int nowNumber) { + if (nowSign.equals("+")) { + //덧셈 함수 + return; + } + if (nowSign.equals("-")) { + //뺄셈 함수 + return; + } + if (nowSign.equals("*")) { + //곱하기 함수 + return; + } + if (nowSign.equals("/")) { + //더하기 함수 + return; + } + } } From 3de796170261a697737ca360ea9f66704a7508c4 Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:35:10 +0900 Subject: [PATCH 10/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EC=82=AC=EC=B9=99=EC=97=B0?= =?UTF-8?q?=EC=82=B0=EC=97=90=20=ED=95=B4=EB=8B=B9=ED=95=98=EB=8A=94=20?= =?UTF-8?q?=EA=B0=81=20=ED=95=A8=EC=88=98=20=EA=B5=AC=ED=98=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- src/main/java/Calculator.java | 24 ++++++++++++++++++++---- 2 files changed, 21 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index f4c9e879..30b44ff9 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,6 @@ 2. 홀수 인덱스와 짝수 인덱스로 나누는 함수 1. 짝수 인덱스일 때는 부호를 저장하는 로직 2. 홀수 인덱스일 경우에는 계산하는 함수 호출 -3. 계산하는 함수 구현 +3. 부호에 따라 계산하는 함수 구현 4. 사칙연산에 해당하는 각 함수 구현 5. 입력값을 확인하는 핸들러 구현 \ No newline at end of file diff --git a/src/main/java/Calculator.java b/src/main/java/Calculator.java index 93afbd05..3d6b1c2a 100644 --- a/src/main/java/Calculator.java +++ b/src/main/java/Calculator.java @@ -28,20 +28,36 @@ private static void check(int i, String value) { private static void calculate(int nowNumber) { if (nowSign.equals("+")) { - //덧셈 함수 + plus(nowNumber); return; } if (nowSign.equals("-")) { - //뺄셈 함수 + minus(nowNumber); return; } if (nowSign.equals("*")) { - //곱하기 함수 + multiply(nowNumber); return; } if (nowSign.equals("/")) { - //더하기 함수 + divide(nowNumber); return; } } + + private static void plus(int nowNumber) { + returnValue += nowNumber; + } + + private static void minus(int nowNumber) { + returnValue -= nowNumber; + } + + private static void multiply(int nowNumber) { + returnValue *= nowNumber; + } + + private static void divide(int nowNumber) { + returnValue /= nowNumber; + } } From 09addcaa5379144077481c936da3bc43b5e78918 Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:43:44 +0900 Subject: [PATCH 11/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EC=9E=85=EB=A0=A5=EA=B0=92?= =?UTF-8?q?=EC=9D=84=20=ED=99=95=EC=9D=B8=ED=95=98=EB=8A=94=20=ED=95=B8?= =?UTF-8?q?=EB=93=A4=EB=9F=AC=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 | 3 +- src/main/java/ExceptionHandler.java | 73 +++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+), 2 deletions(-) create mode 100644 src/main/java/ExceptionHandler.java diff --git a/src/main/java/Calculator.java b/src/main/java/Calculator.java index 3d6b1c2a..c56daef0 100644 --- a/src/main/java/Calculator.java +++ b/src/main/java/Calculator.java @@ -5,11 +5,10 @@ public class Calculator { private static final int INDEX_INIT = 1; private static final int EVEN = 0; private static final int ODD = 1; - private static Scanner scanner = new Scanner(System.in); private static String nowSign; public static void main(String args[]) { - String[] values = scanner.nextLine().split(" "); + String[] values = ExceptionHandler.inputHandler().split(" "); returnValue = Integer.parseInt(values[0]); for (int i = INDEX_INIT; i < values.length; i++) { check(i, values[i]); diff --git a/src/main/java/ExceptionHandler.java b/src/main/java/ExceptionHandler.java new file mode 100644 index 00000000..852e40f0 --- /dev/null +++ b/src/main/java/ExceptionHandler.java @@ -0,0 +1,73 @@ +import java.util.Arrays; +import java.util.InputMismatchException; +import java.util.Scanner; +import java.util.concurrent.atomic.AtomicInteger; + +public class ExceptionHandler { + private static final int EVEN = 0; + private static final int ODD = 1; + private static final int INDEX_INIT = 0; + private static Scanner scanner = new Scanner(System.in); + + public static String inputHandler() { + try { + return checkInputHandler(scanner.nextLine()); + } catch (InputMismatchException | IllegalArgumentException e) { + System.out.println("입력값을 확인해주세요."); + scanner = new Scanner(System.in); + return inputHandler(); + } + } + + private static String checkInputHandler(String input) { + if (checkString(input.split(" ")) == true) { + return input; + } + throw new IllegalArgumentException(); + } + + private static boolean checkString(String[] inputStrings) { + if (inputStrings.length % 2 == EVEN) { + return false; + } +/* for (int i = INDEX_INIT; i < inputStrings.length; i++) { + if (checkIndividual(i, inputStrings[i]) == false) { + return false; + } + }*/ + // depth 1으로 대신하는 코드 + AtomicInteger index = new AtomicInteger(); + return Arrays.stream(inputStrings) + .allMatch(x -> checkIndividual(index.getAndIncrement(), x)); + } + + private static boolean checkIndividual(int i, String inputString) { + if (i % 2 == EVEN) { + return checkNumber(inputString); + } + if (i % 2 == ODD) { + return checkSign(inputString); + } + return false; + } + + private static boolean checkNumber(String inputString) { + return inputString.matches("-?\\d+(\\.\\d+)?"); + } + + private static boolean checkSign(String inputString) { + if (inputString.equals("+")) { + return true; + } + if (inputString.equals("-")) { + return true; + } + if (inputString.equals("*")) { + return true; + } + if (inputString.equals("/")) { + return true; + } + return false; + } +} \ No newline at end of file From 889a3c65caa43629a34565336e5f0bf16cf6dd51 Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:47:43 +0900 Subject: [PATCH 12/29] =?UTF-8?q?[mod]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EC=A0=95=EC=88=98=ED=98=95?= =?UTF-8?q?=EC=9C=BC=EB=A1=9C=20=EA=B3=84=EC=82=B0=ED=95=98=EB=8D=98=20?= =?UTF-8?q?=EA=B2=83=EC=9D=84=20=EC=8B=A4=EC=88=98=ED=98=95=EC=9C=BC?= =?UTF-8?q?=EB=A1=9C=20=ED=99=95=EC=9E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Calculator.java | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/src/main/java/Calculator.java b/src/main/java/Calculator.java index c56daef0..fe832ee6 100644 --- a/src/main/java/Calculator.java +++ b/src/main/java/Calculator.java @@ -1,31 +1,34 @@ -import java.util.Scanner; - public class Calculator { - static int returnValue; + private static final double TEST_RETURN_VALUE_INIT = 10; private static final int INDEX_INIT = 1; private static final int EVEN = 0; private static final int ODD = 1; - private static String nowSign; + static double returnValue; + static String nowSign; public static void main(String args[]) { String[] values = ExceptionHandler.inputHandler().split(" "); - returnValue = Integer.parseInt(values[0]); + returnValue = Double.parseDouble(values[0]); for (int i = INDEX_INIT; i < values.length; i++) { check(i, values[i]); } + if (returnValue == (int) returnValue) { + System.out.println((int) returnValue); + return; + } System.out.println(returnValue); } private static void check(int i, String value) { if (i % 2 == EVEN) { - calculate(Integer.parseInt(value)); + calculate(Double.parseDouble(value)); } if (i % 2 == ODD) { nowSign = value; } } - private static void calculate(int nowNumber) { + private static void calculate(double nowNumber) { if (nowSign.equals("+")) { plus(nowNumber); return; @@ -44,19 +47,19 @@ private static void calculate(int nowNumber) { } } - private static void plus(int nowNumber) { + private static void plus(double nowNumber) { returnValue += nowNumber; } - private static void minus(int nowNumber) { + private static void minus(double nowNumber) { returnValue -= nowNumber; } - private static void multiply(int nowNumber) { + private static void multiply(double nowNumber) { returnValue *= nowNumber; } - private static void divide(int nowNumber) { + private static void divide(double nowNumber) { returnValue /= nowNumber; } -} +} \ No newline at end of file From d1ea865f938e8f2fa603f5dc913f2a3a763bbacd Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:58:49 +0900 Subject: [PATCH 13/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=ED=99=80=EC=88=98=20?= =?UTF-8?q?=EC=9D=B8=EB=8D=B1=EC=8A=A4=EC=99=80=20=EC=A7=9D=EC=88=98=20?= =?UTF-8?q?=EC=9D=B8=EB=8D=B1=EC=8A=A4=EB=A1=9C=20=EB=82=98=EB=88=84?= =?UTF-8?q?=EB=8A=94=20=ED=95=A8=EC=88=98=20=EB=8B=A8=EC=9C=84=20=ED=85=8C?= =?UTF-8?q?=EC=8A=A4=ED=8A=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/CalculatorTest.java | 87 +++++++++++++++++++ src/test/java/study/ExceptionHandlerTest.java | 74 ++++++++++++++++ 2 files changed, 161 insertions(+) create mode 100644 src/test/java/study/CalculatorTest.java create mode 100644 src/test/java/study/ExceptionHandlerTest.java diff --git a/src/test/java/study/CalculatorTest.java b/src/test/java/study/CalculatorTest.java new file mode 100644 index 00000000..563d9173 --- /dev/null +++ b/src/test/java/study/CalculatorTest.java @@ -0,0 +1,87 @@ +package study; + +import org.junit.jupiter.api.BeforeEach; +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.*; + +public class CalculatorTest { + private static final double TEST_RETURN_VALUE_INIT = 10; + private static final int INDEX_INIT = 1; + private static final int EVEN = 0; + private static final int ODD = 1; + static double returnValue; + static String nowSign; + + @Test + public static void main(String args[]) { + String[] values = ExceptionHandlerTest.inputHandler().split(" "); + returnValue = Double.parseDouble(values[0]); + for (int i = INDEX_INIT; i < values.length; i++) { + check(i, values[i]); + } + if(returnValue == (int) returnValue){ + System.out.println((int) returnValue); + return; + } + System.out.println(returnValue); + } + + @BeforeEach + void setUp() { + returnValue = TEST_RETURN_VALUE_INIT; + } + + private static void check(int i, String value) { + if (i % 2 == EVEN) { + calculate(Double.parseDouble(value)); + } + if (i % 2 == ODD) { + nowSign = value; + } + } + + @ParameterizedTest + @CsvSource(value = {"1:+:5:10", "2:+:10:20", "4:-:8:2", "6:*:2:20", "8:/:2:5"}, delimiter = ':') + void checkTest(int i, String sign, String input, double expected) { + nowSign = sign; + check(i, input); + assertThat(returnValue).isEqualTo(expected); + } + + private static void calculate(double nowNumber) { + if (nowSign.equals("+")) { + plus(nowNumber); + return; + } + if (nowSign.equals("-")) { + minus(nowNumber); + return; + } + if (nowSign.equals("*")) { + multiply(nowNumber); + return; + } + if (nowSign.equals("/")) { + divide(nowNumber); + return; + } + } + + private static void plus(double nowNumber) { + returnValue += nowNumber; + } + + private static void minus(double nowNumber) { + returnValue -= nowNumber; + } + + private static void multiply(double nowNumber) { + returnValue *= nowNumber; + } + + private static void divide(double nowNumber) { + returnValue /= nowNumber; + } +} \ No newline at end of file diff --git a/src/test/java/study/ExceptionHandlerTest.java b/src/test/java/study/ExceptionHandlerTest.java new file mode 100644 index 00000000..e9b3a556 --- /dev/null +++ b/src/test/java/study/ExceptionHandlerTest.java @@ -0,0 +1,74 @@ +package study; + +import java.util.Arrays; +import java.util.InputMismatchException; +import java.util.Scanner; +import java.util.concurrent.atomic.AtomicInteger; + +public class ExceptionHandlerTest { + private static final int EVEN = 0; + private static final int ODD = 1; + private static final int INDEX_INIT = 0; + private static Scanner scanner = new Scanner(System.in); + + public static String inputHandler() { + try { + return checkInputHandler(scanner.nextLine()); + } catch (InputMismatchException | IllegalArgumentException e) { + System.out.println("입력값을 확인해주세요."); + scanner = new Scanner(System.in); + return inputHandler(); + } + } + + private static String checkInputHandler(String input) { + if (checkString(input.split(" ")) == true) { + return input; + } + throw new IllegalArgumentException(); + } + + private static boolean checkString(String[] inputStrings) { + if (inputStrings.length % 2 == EVEN) { + return false; + } +/* for (int i = INDEX_INIT; i < inputStrings.length; i++) { + if (checkIndividual(i, inputStrings[i]) == false) { + return false; + } + }*/ + // depth 1으로 대신하는 코드 + AtomicInteger index = new AtomicInteger(); + return Arrays.stream(inputStrings) + .allMatch(x -> checkIndividual(index.getAndIncrement(), x)); + } + + private static boolean checkIndividual(int i, String inputString) { + if (i % 2 == EVEN) { + return checkNumber(inputString); + } + if (i % 2 == ODD) { + return checkSign(inputString); + } + return false; + } + private static boolean checkNumber(String inputString) { + return inputString.matches("-?\\d+(\\.\\d+)?"); + } + + private static boolean checkSign(String inputString) { + if (inputString.equals("+")){ + return true; + } + if (inputString.equals("-")){ + return true; + } + if (inputString.equals("*")){ + return true; + } + if (inputString.equals("/")){ + return true; + } + return false; + } +} \ No newline at end of file From 0b53410d6982c92842a827ae778a3023955d83b0 Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 13:59:55 +0900 Subject: [PATCH 14/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EB=B6=80=ED=98=B8=EC=97=90?= =?UTF-8?q?=20=EB=94=B0=EB=9D=BC=20=EA=B3=84=EC=82=B0=ED=95=98=EB=8A=94=20?= =?UTF-8?q?=ED=95=A8=EC=88=98=20=EB=8B=A8=EC=9C=84=20=ED=85=8C=EC=8A=A4?= =?UTF-8?q?=ED=8A=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/CalculatorTest.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/test/java/study/CalculatorTest.java b/src/test/java/study/CalculatorTest.java index 563d9173..66106651 100644 --- a/src/test/java/study/CalculatorTest.java +++ b/src/test/java/study/CalculatorTest.java @@ -69,6 +69,14 @@ private static void calculate(double nowNumber) { } } + @ParameterizedTest + @CsvSource(value = {"5:+:15", "5:-:5", "5:*:50", "5:/:2"}, delimiter = ':') + void calculateTest(double input, String sign, double expected) { + nowSign = sign; + calculate(input); + assertThat(returnValue).isEqualTo(expected); + } + private static void plus(double nowNumber) { returnValue += nowNumber; } From c295110f4f83a2b073175d215a928aaa17be27ac Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 14:01:59 +0900 Subject: [PATCH 15/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EC=82=AC=EC=B9=99=EC=97=B0?= =?UTF-8?q?=EC=82=B0=EC=97=90=20=ED=95=B4=EB=8B=B9=ED=95=98=EB=8A=94=20?= =?UTF-8?q?=EA=B0=81=20=ED=95=A8=EC=88=98=20=EB=8B=A8=EC=9C=84=20=ED=85=8C?= =?UTF-8?q?=EC=8A=A4=ED=8A=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/CalculatorTest.java | 30 +++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/src/test/java/study/CalculatorTest.java b/src/test/java/study/CalculatorTest.java index 66106651..896b737e 100644 --- a/src/test/java/study/CalculatorTest.java +++ b/src/test/java/study/CalculatorTest.java @@ -81,15 +81,45 @@ private static void plus(double nowNumber) { returnValue += nowNumber; } + @ParameterizedTest + @CsvSource(value = {"5:15", "10:20", "33:43"}, delimiter = ':') + void plusTest(double input, double expected) { + plus(input); + System.out.println(input); + System.out.println(expected); + assertThat(returnValue).isEqualTo(expected); + } + private static void minus(double nowNumber) { returnValue -= nowNumber; } + @ParameterizedTest + @CsvSource(value = {"5:5", "10:0", "33:-23"}, delimiter = ':') + void minusTest(double input, double expected) { + minus(input); + assertThat(returnValue).isEqualTo(expected); + } + private static void multiply(double nowNumber) { returnValue *= nowNumber; } + @ParameterizedTest + @CsvSource(value = {"5:50", "10:100", "33:330"}, delimiter = ':') + void multiplyTest(double input, double expected) { + multiply(input); + assertThat(returnValue).isEqualTo(expected); + } + private static void divide(double nowNumber) { returnValue /= nowNumber; } + + @ParameterizedTest + @CsvSource(value = {"5:2", "10:1", "4:2.5"}, delimiter = ':') + void divideTest(double input, double expected) { + divide(input); + assertThat(returnValue).isEqualTo(expected); + } } \ No newline at end of file From 750daac2032cf9cc647b67dca32fea863275e310 Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 15:11:12 +0900 Subject: [PATCH 16/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EC=9E=85=EB=A0=A5=EA=B0=92?= =?UTF-8?q?=EC=9D=84=20=ED=99=95=EC=9D=B8=ED=95=98=EB=8A=94=20=ED=95=B8?= =?UTF-8?q?=EB=93=A4=EB=9F=AC=20=EB=8B=A8=EC=9C=84=20=ED=85=8C=EC=8A=A4?= =?UTF-8?q?=ED=8A=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Calculator.java | 1 - src/test/java/study/CalculatorTest.java | 3 +- src/test/java/study/ExceptionHandlerTest.java | 42 +++++++++++++++++-- 3 files changed, 40 insertions(+), 6 deletions(-) diff --git a/src/main/java/Calculator.java b/src/main/java/Calculator.java index fe832ee6..7cd12f71 100644 --- a/src/main/java/Calculator.java +++ b/src/main/java/Calculator.java @@ -1,5 +1,4 @@ public class Calculator { - private static final double TEST_RETURN_VALUE_INIT = 10; private static final int INDEX_INIT = 1; private static final int EVEN = 0; private static final int ODD = 1; diff --git a/src/test/java/study/CalculatorTest.java b/src/test/java/study/CalculatorTest.java index 896b737e..1390cba2 100644 --- a/src/test/java/study/CalculatorTest.java +++ b/src/test/java/study/CalculatorTest.java @@ -4,6 +4,7 @@ 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.*; public class CalculatorTest { @@ -21,7 +22,7 @@ public static void main(String args[]) { for (int i = INDEX_INIT; i < values.length; i++) { check(i, values[i]); } - if(returnValue == (int) returnValue){ + if (returnValue == (int) returnValue) { System.out.println((int) returnValue); return; } diff --git a/src/test/java/study/ExceptionHandlerTest.java b/src/test/java/study/ExceptionHandlerTest.java index e9b3a556..7de94a05 100644 --- a/src/test/java/study/ExceptionHandlerTest.java +++ b/src/test/java/study/ExceptionHandlerTest.java @@ -1,10 +1,15 @@ package study; +import org.junit.jupiter.api.Test; + import java.util.Arrays; import java.util.InputMismatchException; import java.util.Scanner; import java.util.concurrent.atomic.AtomicInteger; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + public class ExceptionHandlerTest { private static final int EVEN = 0; private static final int ODD = 1; @@ -28,6 +33,14 @@ private static String checkInputHandler(String input) { throw new IllegalArgumentException(); } + @Test + public void checkInputHandlerTest() { + String str = "321 + 3 + f"; + assertThatThrownBy(() -> { + checkInputHandler(str); + }).isInstanceOf(IllegalArgumentException.class); + } + private static boolean checkString(String[] inputStrings) { if (inputStrings.length % 2 == EVEN) { return false; @@ -43,6 +56,12 @@ private static boolean checkString(String[] inputStrings) { .allMatch(x -> checkIndividual(index.getAndIncrement(), x)); } + @Test + void checkStringTest() { + String[] inputStrings = "333 + 2434343".split(" "); + assertThat(checkString(inputStrings)).isTrue(); + } + private static boolean checkIndividual(int i, String inputString) { if (i % 2 == EVEN) { return checkNumber(inputString); @@ -52,23 +71,38 @@ private static boolean checkIndividual(int i, String inputString) { } return false; } + private static boolean checkNumber(String inputString) { return inputString.matches("-?\\d+(\\.\\d+)?"); } + @Test + void checkNumberTest() { + // return이 boolean이라 isTrue, isFalse로만 판별? + String str = "g"; + assertThat(checkNumber(str)).isFalse(); + } + private static boolean checkSign(String inputString) { - if (inputString.equals("+")){ + if (inputString.equals("+")) { return true; } - if (inputString.equals("-")){ + if (inputString.equals("-")) { return true; } - if (inputString.equals("*")){ + if (inputString.equals("*")) { return true; } - if (inputString.equals("/")){ + if (inputString.equals("/")) { return true; } return false; } + + @Test + void checkSignTest() { + // return이 boolean이라 isTrue, isFalse로만 판별? + String str = "@"; + assertThat(checkSign(str)).isFalse(); + } } \ No newline at end of file From a51772322d5f606325dd2125e4fd18b21b35c292 Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 15:25:29 +0900 Subject: [PATCH 17/29] =?UTF-8?q?[add]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=200=EC=9C=BC=EB=A1=9C=20?= =?UTF-8?q?=EB=82=98=EB=88=8C=20=EA=B2=BD=EC=9A=B0=20=EC=B2=98=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 4 +++- src/main/java/ExceptionHandler.java | 9 ++++++++- src/test/java/study/ExceptionHandlerTest.java | 9 ++++++++- 3 files changed, 19 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 30b44ff9..0a0ef45f 100644 --- a/README.md +++ b/README.md @@ -13,4 +13,6 @@ 2. 홀수 인덱스일 경우에는 계산하는 함수 호출 3. 부호에 따라 계산하는 함수 구현 4. 사칙연산에 해당하는 각 함수 구현 -5. 입력값을 확인하는 핸들러 구현 \ No newline at end of file +5. 입력값을 확인하는 핸들러 구현 + 1. 양식에 맞지 않을 경우 (부호가 연속, 숫자가 연속으로 나올 경우) + 2. [예외 처리] 0으로 나눌 경우 \ No newline at end of file diff --git a/src/main/java/ExceptionHandler.java b/src/main/java/ExceptionHandler.java index 852e40f0..b7e0bab0 100644 --- a/src/main/java/ExceptionHandler.java +++ b/src/main/java/ExceptionHandler.java @@ -20,12 +20,19 @@ public static String inputHandler() { } private static String checkInputHandler(String input) { - if (checkString(input.split(" ")) == true) { + if (checkString(input.split(" ")) == true && isUndefinedValue(input) == true) { return input; } throw new IllegalArgumentException(); } + public static boolean isUndefinedValue(String str) { + if (str.replace(" ", "").contains("/0")) { + return false; + } + return true; + } + private static boolean checkString(String[] inputStrings) { if (inputStrings.length % 2 == EVEN) { return false; diff --git a/src/test/java/study/ExceptionHandlerTest.java b/src/test/java/study/ExceptionHandlerTest.java index 7de94a05..59662ae8 100644 --- a/src/test/java/study/ExceptionHandlerTest.java +++ b/src/test/java/study/ExceptionHandlerTest.java @@ -27,12 +27,19 @@ public static String inputHandler() { } private static String checkInputHandler(String input) { - if (checkString(input.split(" ")) == true) { + if (checkString(input.split(" ")) == true && isUndefinedValue(input) == true) { return input; } throw new IllegalArgumentException(); } + public static boolean isUndefinedValue(String str) { + if (str.replace(" ", "").contains("/0")) { + return false; + } + return true; + } + @Test public void checkInputHandlerTest() { String str = "321 + 3 + f"; From 8133b044d3856a0df23edee025a24ddd837652c2 Mon Sep 17 00:00:00 2001 From: hamliet Date: Fri, 7 Feb 2020 15:28:59 +0900 Subject: [PATCH 18/29] =?UTF-8?q?[mod]=20=EB=AC=B8=EC=9E=90=EC=97=B4=20?= =?UTF-8?q?=EA=B3=84=EC=82=B0=EA=B8=B0=20-=20=EC=9E=85=EB=A0=A5=EA=B0=92?= =?UTF-8?q?=EC=9D=84=20=ED=99=95=EC=9D=B8=ED=95=98=EB=8A=94=20=ED=95=B8?= =?UTF-8?q?=EB=93=A4=EB=9F=AC=20=EB=8B=A8=EC=9C=84=20=ED=85=8C=EC=8A=A4?= =?UTF-8?q?=ED=8A=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/ExceptionHandlerTest.java | 21 ++++++++++++------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/src/test/java/study/ExceptionHandlerTest.java b/src/test/java/study/ExceptionHandlerTest.java index 59662ae8..e5a936ab 100644 --- a/src/test/java/study/ExceptionHandlerTest.java +++ b/src/test/java/study/ExceptionHandlerTest.java @@ -33,13 +33,6 @@ private static String checkInputHandler(String input) { throw new IllegalArgumentException(); } - public static boolean isUndefinedValue(String str) { - if (str.replace(" ", "").contains("/0")) { - return false; - } - return true; - } - @Test public void checkInputHandlerTest() { String str = "321 + 3 + f"; @@ -108,8 +101,20 @@ private static boolean checkSign(String inputString) { @Test void checkSignTest() { - // return이 boolean이라 isTrue, isFalse로만 판별? String str = "@"; assertThat(checkSign(str)).isFalse(); } + + public static boolean isUndefinedValue(String str) { + if (str.replace(" ", "").contains("/0")) { + return false; + } + return true; + } + + @Test + void isUndefinedValueTest() { + String str = "@"; + assertThat(isUndefinedValue("0 / 0")).isFalse(); + } } \ No newline at end of file From 15767290c8dd70c228e11436be0f9917f86682a4 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Fri, 7 Feb 2020 17:15:32 +0900 Subject: [PATCH 19/29] =?UTF-8?q?mod=20:=20@Displayname=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/study/CalculatorTest.java | 15 +-------------- src/test/java/study/ExceptionHandlerTest.java | 11 ++++++++--- 2 files changed, 9 insertions(+), 17 deletions(-) diff --git a/src/test/java/study/CalculatorTest.java b/src/test/java/study/CalculatorTest.java index 1390cba2..fae7fbc8 100644 --- a/src/test/java/study/CalculatorTest.java +++ b/src/test/java/study/CalculatorTest.java @@ -1,6 +1,7 @@ package study; import org.junit.jupiter.api.BeforeEach; +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; @@ -15,20 +16,6 @@ public class CalculatorTest { static double returnValue; static String nowSign; - @Test - public static void main(String args[]) { - String[] values = ExceptionHandlerTest.inputHandler().split(" "); - returnValue = Double.parseDouble(values[0]); - for (int i = INDEX_INIT; i < values.length; i++) { - check(i, values[i]); - } - if (returnValue == (int) returnValue) { - System.out.println((int) returnValue); - return; - } - System.out.println(returnValue); - } - @BeforeEach void setUp() { returnValue = TEST_RETURN_VALUE_INIT; diff --git a/src/test/java/study/ExceptionHandlerTest.java b/src/test/java/study/ExceptionHandlerTest.java index e5a936ab..6168efbe 100644 --- a/src/test/java/study/ExceptionHandlerTest.java +++ b/src/test/java/study/ExceptionHandlerTest.java @@ -1,5 +1,6 @@ package study; +import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import java.util.Arrays; @@ -34,6 +35,7 @@ private static String checkInputHandler(String input) { } @Test + @DisplayName("입력값을 체크해주는 테스트") public void checkInputHandlerTest() { String str = "321 + 3 + f"; assertThatThrownBy(() -> { @@ -57,6 +59,7 @@ private static boolean checkString(String[] inputStrings) { } @Test + @DisplayName("문자열을 split하고 전체적으로 체크해주는 테스트") void checkStringTest() { String[] inputStrings = "333 + 2434343".split(" "); assertThat(checkString(inputStrings)).isTrue(); @@ -77,8 +80,8 @@ private static boolean checkNumber(String inputString) { } @Test + @DisplayName("숫자인지 체크해주는 테스트") void checkNumberTest() { - // return이 boolean이라 isTrue, isFalse로만 판별? String str = "g"; assertThat(checkNumber(str)).isFalse(); } @@ -100,6 +103,7 @@ private static boolean checkSign(String inputString) { } @Test + @DisplayName("사칙연산인지 체크해주는 테스트") void checkSignTest() { String str = "@"; assertThat(checkSign(str)).isFalse(); @@ -113,8 +117,9 @@ public static boolean isUndefinedValue(String str) { } @Test + @DisplayName("0으로 나누었을 때의 예외처리를 해주는 테스트") void isUndefinedValueTest() { - String str = "@"; - assertThat(isUndefinedValue("0 / 0")).isFalse(); + String str = "0 / 0"; + assertThat(isUndefinedValue(str)).isFalse(); } } \ No newline at end of file From ba76416179198d42beb6d1df483bfc2dbd0497b8 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Sat, 8 Feb 2020 14:40:32 +0900 Subject: [PATCH 20/29] =?UTF-8?q?mod=20:=20=ED=8C=A8=ED=82=A4=EC=A7=80,=20?= =?UTF-8?q?=ED=81=B4=EB=9E=98=EC=8A=A4=20=EB=B6=84=EB=A6=AC=20=EB=B0=8F=20?= =?UTF-8?q?view=20=ED=81=B4=EB=9E=98=EC=8A=A4=20=EC=83=9D=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Application.java | 8 ++++++++ src/main/java/{ => calculator/domain}/Calculator.java | 2 ++ .../java/{ => calculator/domain}/ExceptionHandler.java | 2 ++ src/main/java/calculator/view/InputView.java | 4 ++++ src/main/java/calculator/view/OutputView.java | 4 ++++ src/test/java/{study => calculator}/CalculatorTest.java | 2 +- .../java/{study => calculator}/ExceptionHandlerTest.java | 2 +- 7 files changed, 22 insertions(+), 2 deletions(-) create mode 100644 src/main/java/Application.java rename src/main/java/{ => calculator/domain}/Calculator.java (98%) rename src/main/java/{ => calculator/domain}/ExceptionHandler.java (98%) create mode 100644 src/main/java/calculator/view/InputView.java create mode 100644 src/main/java/calculator/view/OutputView.java rename src/test/java/{study => calculator}/CalculatorTest.java (99%) rename src/test/java/{study => calculator}/ExceptionHandlerTest.java (99%) diff --git a/src/main/java/Application.java b/src/main/java/Application.java new file mode 100644 index 00000000..52b565bb --- /dev/null +++ b/src/main/java/Application.java @@ -0,0 +1,8 @@ +import calculator.domain.Calculator; + +public class Application { + public static void main(String[] args){ + Calculator calculator = new Calculator(); +// calculator.run(); + } +} diff --git a/src/main/java/Calculator.java b/src/main/java/calculator/domain/Calculator.java similarity index 98% rename from src/main/java/Calculator.java rename to src/main/java/calculator/domain/Calculator.java index 7cd12f71..9049c07b 100644 --- a/src/main/java/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -1,3 +1,5 @@ +package calculator.domain; + public class Calculator { private static final int INDEX_INIT = 1; private static final int EVEN = 0; diff --git a/src/main/java/ExceptionHandler.java b/src/main/java/calculator/domain/ExceptionHandler.java similarity index 98% rename from src/main/java/ExceptionHandler.java rename to src/main/java/calculator/domain/ExceptionHandler.java index b7e0bab0..4afd551c 100644 --- a/src/main/java/ExceptionHandler.java +++ b/src/main/java/calculator/domain/ExceptionHandler.java @@ -1,3 +1,5 @@ +package calculator.domain; + import java.util.Arrays; import java.util.InputMismatchException; import java.util.Scanner; diff --git a/src/main/java/calculator/view/InputView.java b/src/main/java/calculator/view/InputView.java new file mode 100644 index 00000000..75f4ceb1 --- /dev/null +++ b/src/main/java/calculator/view/InputView.java @@ -0,0 +1,4 @@ +package calculator.view; + +public class InputView { +} diff --git a/src/main/java/calculator/view/OutputView.java b/src/main/java/calculator/view/OutputView.java new file mode 100644 index 00000000..4a2a4b0b --- /dev/null +++ b/src/main/java/calculator/view/OutputView.java @@ -0,0 +1,4 @@ +package calculator.view; + +public class OutputView { +} diff --git a/src/test/java/study/CalculatorTest.java b/src/test/java/calculator/CalculatorTest.java similarity index 99% rename from src/test/java/study/CalculatorTest.java rename to src/test/java/calculator/CalculatorTest.java index fae7fbc8..6eb81331 100644 --- a/src/test/java/study/CalculatorTest.java +++ b/src/test/java/calculator/CalculatorTest.java @@ -1,4 +1,4 @@ -package study; +package calculator; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/study/ExceptionHandlerTest.java b/src/test/java/calculator/ExceptionHandlerTest.java similarity index 99% rename from src/test/java/study/ExceptionHandlerTest.java rename to src/test/java/calculator/ExceptionHandlerTest.java index 6168efbe..74d6c973 100644 --- a/src/test/java/study/ExceptionHandlerTest.java +++ b/src/test/java/calculator/ExceptionHandlerTest.java @@ -1,4 +1,4 @@ -package study; +package calculator; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; From b0881d4dbf98aa0923bf939952867ce506c0c196 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Sat, 8 Feb 2020 14:45:37 +0900 Subject: [PATCH 21/29] =?UTF-8?q?mod=20:=20util=20=ED=8C=A8=ED=82=A4?= =?UTF-8?q?=EC=A7=80=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/calculator/domain/Calculator.java | 2 ++ src/main/java/calculator/{domain => util}/ExceptionHandler.java | 2 +- src/test/java/calculator/ExceptionHandlerTest.java | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) rename src/main/java/calculator/{domain => util}/ExceptionHandler.java (98%) diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index 9049c07b..cf1aca4b 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -1,5 +1,7 @@ package calculator.domain; +import calculator.util.ExceptionHandler; + public class Calculator { private static final int INDEX_INIT = 1; private static final int EVEN = 0; diff --git a/src/main/java/calculator/domain/ExceptionHandler.java b/src/main/java/calculator/util/ExceptionHandler.java similarity index 98% rename from src/main/java/calculator/domain/ExceptionHandler.java rename to src/main/java/calculator/util/ExceptionHandler.java index 4afd551c..cbb982ad 100644 --- a/src/main/java/calculator/domain/ExceptionHandler.java +++ b/src/main/java/calculator/util/ExceptionHandler.java @@ -1,4 +1,4 @@ -package calculator.domain; +package calculator.util; import java.util.Arrays; import java.util.InputMismatchException; diff --git a/src/test/java/calculator/ExceptionHandlerTest.java b/src/test/java/calculator/ExceptionHandlerTest.java index 74d6c973..b5a1d95a 100644 --- a/src/test/java/calculator/ExceptionHandlerTest.java +++ b/src/test/java/calculator/ExceptionHandlerTest.java @@ -55,7 +55,7 @@ private static boolean checkString(String[] inputStrings) { // depth 1으로 대신하는 코드 AtomicInteger index = new AtomicInteger(); return Arrays.stream(inputStrings) - .allMatch(x -> checkIndividual(index.getAndIncrement(), x)); + .allMatch(str -> checkIndividual(index.getAndIncrement(), str)); } @Test From 11373d9785669f7431908b7eb9fe50f1367c7e36 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Sat, 8 Feb 2020 14:57:28 +0900 Subject: [PATCH 22/29] =?UTF-8?q?mod=20:=20=EA=B0=95=EC=A0=9C=20=ED=98=95?= =?UTF-8?q?=EB=B3=80=ED=99=98=20->=20Math=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?= =?UTF-8?q?=EC=9D=B4=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/calculator/domain/Calculator.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index cf1aca4b..8e880cda 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -15,8 +15,9 @@ public static void main(String args[]) { for (int i = INDEX_INIT; i < values.length; i++) { check(i, values[i]); } - if (returnValue == (int) returnValue) { - System.out.println((int) returnValue); + + if (returnValue == Math.round(returnValue)) { + System.out.println(Math.round(returnValue)); return; } System.out.println(returnValue); From 917bd6442b2660a6b425d8867cea44cf55d081e4 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Sat, 8 Feb 2020 15:33:54 +0900 Subject: [PATCH 23/29] =?UTF-8?q?del=20:=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?= =?UTF-8?q?=ED=81=B4=EB=9E=98=EC=8A=A4=20=EC=95=88=EC=97=90=20=EC=9E=88?= =?UTF-8?q?=EB=8A=94=20=EC=84=9C=EB=B9=84=EC=8A=A4=20=EC=BD=94=EB=93=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/calculator/domain/Calculator.java | 12 +-- .../calculator/util/ExceptionHandler.java | 11 +-- src/test/java/calculator/CalculatorTest.java | 50 +------------ .../java/calculator/ExceptionHandlerTest.java | 73 +------------------ 4 files changed, 15 insertions(+), 131 deletions(-) diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index 8e880cda..e00edd79 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -23,7 +23,7 @@ public static void main(String args[]) { System.out.println(returnValue); } - private static void check(int i, String value) { + public static void check(int i, String value) { if (i % 2 == EVEN) { calculate(Double.parseDouble(value)); } @@ -32,7 +32,7 @@ private static void check(int i, String value) { } } - private static void calculate(double nowNumber) { + public static void calculate(double nowNumber) { if (nowSign.equals("+")) { plus(nowNumber); return; @@ -51,19 +51,19 @@ private static void calculate(double nowNumber) { } } - private static void plus(double nowNumber) { + public static void plus(double nowNumber) { returnValue += nowNumber; } - private static void minus(double nowNumber) { + public static void minus(double nowNumber) { returnValue -= nowNumber; } - private static void multiply(double nowNumber) { + public static void multiply(double nowNumber) { returnValue *= nowNumber; } - private static void divide(double nowNumber) { + public static void divide(double nowNumber) { returnValue /= nowNumber; } } \ No newline at end of file diff --git a/src/main/java/calculator/util/ExceptionHandler.java b/src/main/java/calculator/util/ExceptionHandler.java index cbb982ad..c4a82d0d 100644 --- a/src/main/java/calculator/util/ExceptionHandler.java +++ b/src/main/java/calculator/util/ExceptionHandler.java @@ -21,7 +21,7 @@ public static String inputHandler() { } } - private static String checkInputHandler(String input) { + public static String checkInputHandler(String input) { if (checkString(input.split(" ")) == true && isUndefinedValue(input) == true) { return input; } @@ -35,7 +35,7 @@ public static boolean isUndefinedValue(String str) { return true; } - private static boolean checkString(String[] inputStrings) { + public static boolean checkString(String[] inputStrings) { if (inputStrings.length % 2 == EVEN) { return false; } @@ -50,7 +50,7 @@ private static boolean checkString(String[] inputStrings) { .allMatch(x -> checkIndividual(index.getAndIncrement(), x)); } - private static boolean checkIndividual(int i, String inputString) { + public static boolean checkIndividual(int i, String inputString) { if (i % 2 == EVEN) { return checkNumber(inputString); } @@ -60,11 +60,11 @@ private static boolean checkIndividual(int i, String inputString) { return false; } - private static boolean checkNumber(String inputString) { + public static boolean checkNumber(String inputString) { return inputString.matches("-?\\d+(\\.\\d+)?"); } - private static boolean checkSign(String inputString) { + public static boolean checkSign(String inputString) { if (inputString.equals("+")) { return true; } @@ -79,4 +79,5 @@ private static boolean checkSign(String inputString) { } return false; } + } \ No newline at end of file diff --git a/src/test/java/calculator/CalculatorTest.java b/src/test/java/calculator/CalculatorTest.java index 6eb81331..b0f2564b 100644 --- a/src/test/java/calculator/CalculatorTest.java +++ b/src/test/java/calculator/CalculatorTest.java @@ -6,13 +6,11 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; +import static calculator.domain.Calculator.*; import static org.assertj.core.api.Assertions.*; public class CalculatorTest { - private static final double TEST_RETURN_VALUE_INIT = 10; - private static final int INDEX_INIT = 1; - private static final int EVEN = 0; - private static final int ODD = 1; + static final double TEST_RETURN_VALUE_INIT = 10; static double returnValue; static String nowSign; @@ -21,15 +19,6 @@ void setUp() { returnValue = TEST_RETURN_VALUE_INIT; } - private static void check(int i, String value) { - if (i % 2 == EVEN) { - calculate(Double.parseDouble(value)); - } - if (i % 2 == ODD) { - nowSign = value; - } - } - @ParameterizedTest @CsvSource(value = {"1:+:5:10", "2:+:10:20", "4:-:8:2", "6:*:2:20", "8:/:2:5"}, delimiter = ':') void checkTest(int i, String sign, String input, double expected) { @@ -38,25 +27,6 @@ void checkTest(int i, String sign, String input, double expected) { assertThat(returnValue).isEqualTo(expected); } - private static void calculate(double nowNumber) { - if (nowSign.equals("+")) { - plus(nowNumber); - return; - } - if (nowSign.equals("-")) { - minus(nowNumber); - return; - } - if (nowSign.equals("*")) { - multiply(nowNumber); - return; - } - if (nowSign.equals("/")) { - divide(nowNumber); - return; - } - } - @ParameterizedTest @CsvSource(value = {"5:+:15", "5:-:5", "5:*:50", "5:/:2"}, delimiter = ':') void calculateTest(double input, String sign, double expected) { @@ -65,10 +35,6 @@ void calculateTest(double input, String sign, double expected) { assertThat(returnValue).isEqualTo(expected); } - private static void plus(double nowNumber) { - returnValue += nowNumber; - } - @ParameterizedTest @CsvSource(value = {"5:15", "10:20", "33:43"}, delimiter = ':') void plusTest(double input, double expected) { @@ -78,10 +44,6 @@ void plusTest(double input, double expected) { assertThat(returnValue).isEqualTo(expected); } - private static void minus(double nowNumber) { - returnValue -= nowNumber; - } - @ParameterizedTest @CsvSource(value = {"5:5", "10:0", "33:-23"}, delimiter = ':') void minusTest(double input, double expected) { @@ -89,10 +51,6 @@ void minusTest(double input, double expected) { assertThat(returnValue).isEqualTo(expected); } - private static void multiply(double nowNumber) { - returnValue *= nowNumber; - } - @ParameterizedTest @CsvSource(value = {"5:50", "10:100", "33:330"}, delimiter = ':') void multiplyTest(double input, double expected) { @@ -100,10 +58,6 @@ void multiplyTest(double input, double expected) { assertThat(returnValue).isEqualTo(expected); } - private static void divide(double nowNumber) { - returnValue /= nowNumber; - } - @ParameterizedTest @CsvSource(value = {"5:2", "10:1", "4:2.5"}, delimiter = ':') void divideTest(double input, double expected) { diff --git a/src/test/java/calculator/ExceptionHandlerTest.java b/src/test/java/calculator/ExceptionHandlerTest.java index b5a1d95a..45466718 100644 --- a/src/test/java/calculator/ExceptionHandlerTest.java +++ b/src/test/java/calculator/ExceptionHandlerTest.java @@ -8,31 +8,11 @@ import java.util.Scanner; import java.util.concurrent.atomic.AtomicInteger; +import static calculator.util.ExceptionHandler.*; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; public class ExceptionHandlerTest { - private static final int EVEN = 0; - private static final int ODD = 1; - private static final int INDEX_INIT = 0; - private static Scanner scanner = new Scanner(System.in); - - public static String inputHandler() { - try { - return checkInputHandler(scanner.nextLine()); - } catch (InputMismatchException | IllegalArgumentException e) { - System.out.println("입력값을 확인해주세요."); - scanner = new Scanner(System.in); - return inputHandler(); - } - } - - private static String checkInputHandler(String input) { - if (checkString(input.split(" ")) == true && isUndefinedValue(input) == true) { - return input; - } - throw new IllegalArgumentException(); - } @Test @DisplayName("입력값을 체크해주는 테스트") @@ -43,21 +23,6 @@ public void checkInputHandlerTest() { }).isInstanceOf(IllegalArgumentException.class); } - private static boolean checkString(String[] inputStrings) { - if (inputStrings.length % 2 == EVEN) { - return false; - } -/* for (int i = INDEX_INIT; i < inputStrings.length; i++) { - if (checkIndividual(i, inputStrings[i]) == false) { - return false; - } - }*/ - // depth 1으로 대신하는 코드 - AtomicInteger index = new AtomicInteger(); - return Arrays.stream(inputStrings) - .allMatch(str -> checkIndividual(index.getAndIncrement(), str)); - } - @Test @DisplayName("문자열을 split하고 전체적으로 체크해주는 테스트") void checkStringTest() { @@ -65,19 +30,6 @@ void checkStringTest() { assertThat(checkString(inputStrings)).isTrue(); } - private static boolean checkIndividual(int i, String inputString) { - if (i % 2 == EVEN) { - return checkNumber(inputString); - } - if (i % 2 == ODD) { - return checkSign(inputString); - } - return false; - } - - private static boolean checkNumber(String inputString) { - return inputString.matches("-?\\d+(\\.\\d+)?"); - } @Test @DisplayName("숫자인지 체크해주는 테스트") @@ -86,22 +38,6 @@ void checkNumberTest() { assertThat(checkNumber(str)).isFalse(); } - private static boolean checkSign(String inputString) { - if (inputString.equals("+")) { - return true; - } - if (inputString.equals("-")) { - return true; - } - if (inputString.equals("*")) { - return true; - } - if (inputString.equals("/")) { - return true; - } - return false; - } - @Test @DisplayName("사칙연산인지 체크해주는 테스트") void checkSignTest() { @@ -109,13 +45,6 @@ void checkSignTest() { assertThat(checkSign(str)).isFalse(); } - public static boolean isUndefinedValue(String str) { - if (str.replace(" ", "").contains("/0")) { - return false; - } - return true; - } - @Test @DisplayName("0으로 나누었을 때의 예외처리를 해주는 테스트") void isUndefinedValueTest() { From 21c17f3ac2144762dd0de0437dd287ac6f84f252 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Sun, 9 Feb 2020 17:22:09 +0900 Subject: [PATCH 24/29] =?UTF-8?q?mod=20:=20=EC=9E=85=EC=B6=9C=EB=A0=A5=20?= =?UTF-8?q?=EB=B6=84=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/Application.java | 2 +- .../java/calculator/domain/Calculator.java | 32 ++++++++++++------- .../calculator/util/ExceptionHandler.java | 14 +++----- src/main/java/calculator/view/InputView.java | 29 +++++++++++++++++ src/main/java/calculator/view/OutputView.java | 7 ++++ 5 files changed, 61 insertions(+), 23 deletions(-) diff --git a/src/main/java/Application.java b/src/main/java/Application.java index 52b565bb..841b4f7d 100644 --- a/src/main/java/Application.java +++ b/src/main/java/Application.java @@ -3,6 +3,6 @@ public class Application { public static void main(String[] args){ Calculator calculator = new Calculator(); -// calculator.run(); + calculator.run(); } } diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index e00edd79..2d422f2f 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -1,6 +1,8 @@ package calculator.domain; import calculator.util.ExceptionHandler; +import calculator.view.InputView; +import calculator.view.OutputView; public class Calculator { private static final int INDEX_INIT = 1; @@ -9,27 +11,33 @@ public class Calculator { static double returnValue; static String nowSign; - public static void main(String args[]) { - String[] values = ExceptionHandler.inputHandler().split(" "); + public static void run() { + + String[] values = InputView.inputHandler().split(" "); returnValue = Double.parseDouble(values[0]); + + calculateNumber(values); + + OutputView.printResult(returnValue); + } + + public static void calculateNumber(String[] values) { for (int i = INDEX_INIT; i < values.length; i++) { - check(i, values[i]); + calculateEvenNumber(i, values[i]); + calculateOddNumber(i,values[i]); } + } - if (returnValue == Math.round(returnValue)) { - System.out.println(Math.round(returnValue)); - return; + public static void calculateOddNumber(int index, String value){ + if (index % 2 == ODD) { + nowSign = value; } - System.out.println(returnValue); } - public static void check(int i, String value) { - if (i % 2 == EVEN) { + public static void calculateEvenNumber(int index, String value){ + if (index % 2 == EVEN) { calculate(Double.parseDouble(value)); } - if (i % 2 == ODD) { - nowSign = value; - } } public static void calculate(double nowNumber) { diff --git a/src/main/java/calculator/util/ExceptionHandler.java b/src/main/java/calculator/util/ExceptionHandler.java index c4a82d0d..ce3cb22b 100644 --- a/src/main/java/calculator/util/ExceptionHandler.java +++ b/src/main/java/calculator/util/ExceptionHandler.java @@ -5,21 +5,15 @@ import java.util.Scanner; import java.util.concurrent.atomic.AtomicInteger; +import static calculator.view.InputView.*; + public class ExceptionHandler { private static final int EVEN = 0; private static final int ODD = 1; private static final int INDEX_INIT = 0; - private static Scanner scanner = new Scanner(System.in); - public static String inputHandler() { - try { - return checkInputHandler(scanner.nextLine()); - } catch (InputMismatchException | IllegalArgumentException e) { - System.out.println("입력값을 확인해주세요."); - scanner = new Scanner(System.in); - return inputHandler(); - } - } + + public static String checkInputHandler(String input) { if (checkString(input.split(" ")) == true && isUndefinedValue(input) == true) { diff --git a/src/main/java/calculator/view/InputView.java b/src/main/java/calculator/view/InputView.java index 75f4ceb1..ba6f60ed 100644 --- a/src/main/java/calculator/view/InputView.java +++ b/src/main/java/calculator/view/InputView.java @@ -1,4 +1,33 @@ package calculator.view; +import calculator.util.ExceptionHandler; + +import java.util.InputMismatchException; +import java.util.Scanner; + +import static calculator.util.ExceptionHandler.checkInputHandler; + public class InputView { + + private static Scanner scanner = new Scanner(System.in); + private static final String INPUT_EXPRESSION_STR = "식을 입력해주세요 : "; + private static final String CHECK_INPUT_STR = "입력값을 확인해주세요!"; + + public static String inputHandler() { + try { + return checkInputHandler(printInputExpression()); + } catch (InputMismatchException | IllegalArgumentException e) { + printInputCheck(); + return inputHandler(); + } + } + + public static String printInputExpression(){ + System.out.print(INPUT_EXPRESSION_STR); + return scanner.nextLine(); + } + + public static void printInputCheck(){ + System.out.println(CHECK_INPUT_STR); + } } diff --git a/src/main/java/calculator/view/OutputView.java b/src/main/java/calculator/view/OutputView.java index 4a2a4b0b..c4aa4d25 100644 --- a/src/main/java/calculator/view/OutputView.java +++ b/src/main/java/calculator/view/OutputView.java @@ -1,4 +1,11 @@ package calculator.view; public class OutputView { + public static void printResult(double result){ + String printFormat = "결과는 %f 입니다."; + if(result == Math.floor(result)){ + printFormat = "결과는 %.0f 입니다."; + } + System.out.printf(printFormat, result); + } } From 187f90bc5d60b64c0595e64b05e402184eed9509 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Sun, 9 Feb 2020 22:21:01 +0900 Subject: [PATCH 25/29] =?UTF-8?q?add=20:=20Operator=EB=A5=BC=20Enum?= =?UTF-8?q?=EC=9C=BC=EB=A1=9C=20=EB=B6=84=EB=A6=AC,=20refactor=20:=20?= =?UTF-8?q?=ED=95=A8=EC=88=98=EB=AA=85=EA=B3=BC=20Calculator=20=ED=81=B4?= =?UTF-8?q?=EB=9E=98=EC=8A=A4=20=EB=A6=AC=ED=8E=99=ED=86=A0=EB=A7=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/calculator/domain/Calculator.java | 44 +++++-------------- src/main/java/calculator/domain/Operator.java | 27 ++++++++++++ .../calculator/util/ExceptionHandler.java | 21 ++++----- src/test/java/calculator/CalculatorTest.java | 2 - 4 files changed, 46 insertions(+), 48 deletions(-) create mode 100644 src/main/java/calculator/domain/Operator.java diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index 2d422f2f..c838f87e 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -1,6 +1,5 @@ package calculator.domain; -import calculator.util.ExceptionHandler; import calculator.view.InputView; import calculator.view.OutputView; @@ -12,16 +11,13 @@ public class Calculator { static String nowSign; public static void run() { - String[] values = InputView.inputHandler().split(" "); returnValue = Double.parseDouble(values[0]); - - calculateNumber(values); - + selectOddNumberOrEvenNumber(values); OutputView.printResult(returnValue); } - public static void calculateNumber(String[] values) { + public static void selectOddNumberOrEvenNumber(String[] values) { for (int i = INDEX_INIT; i < values.length; i++) { calculateEvenNumber(i, values[i]); calculateOddNumber(i,values[i]); @@ -36,42 +32,22 @@ public static void calculateOddNumber(int index, String value){ public static void calculateEvenNumber(int index, String value){ if (index % 2 == EVEN) { - calculate(Double.parseDouble(value)); + selectOperators(Double.parseDouble(value)); } } - public static void calculate(double nowNumber) { - if (nowSign.equals("+")) { - plus(nowNumber); - return; - } - if (nowSign.equals("-")) { - minus(nowNumber); - return; - } - if (nowSign.equals("*")) { - multiply(nowNumber); - return; - } - if (nowSign.equals("/")) { - divide(nowNumber); - return; + public static void selectOperators(double nowNumber) { + for(Operator operators : Operator.values()){ + calculateNumber(operators, nowNumber); } } - public static void plus(double nowNumber) { - returnValue += nowNumber; + public static void calculateNumber(Operator operators, double nowNumber){ + if(operators.getOperator().equals(nowSign)){ + operators.calculate(nowNumber); + } } - public static void minus(double nowNumber) { - returnValue -= nowNumber; - } - public static void multiply(double nowNumber) { - returnValue *= nowNumber; - } - public static void divide(double nowNumber) { - returnValue /= nowNumber; - } } \ No newline at end of file diff --git a/src/main/java/calculator/domain/Operator.java b/src/main/java/calculator/domain/Operator.java new file mode 100644 index 00000000..3b2982b8 --- /dev/null +++ b/src/main/java/calculator/domain/Operator.java @@ -0,0 +1,27 @@ +package calculator.domain; + +import java.util.function.Function; + +enum Operator { + PLUS("+", nowNumber -> Calculator.returnValue += nowNumber), + MINUS("-", nowNumber -> Calculator.returnValue -= nowNumber), + MULTIPLY("*", nowNumber -> Calculator.returnValue *= nowNumber), + DIVIDE("/", nowNumber -> Calculator.returnValue /= nowNumber); + + private String operator; + private Function expression; + + Operator(String operator, Function expression) { + this.operator = operator; + this.expression = expression; + } + + public double calculate(double nowNumber){ + return expression.apply(nowNumber); + } + + public String getOperator(){ + return this.operator; + } + +} \ No newline at end of file diff --git a/src/main/java/calculator/util/ExceptionHandler.java b/src/main/java/calculator/util/ExceptionHandler.java index ce3cb22b..cb4a5735 100644 --- a/src/main/java/calculator/util/ExceptionHandler.java +++ b/src/main/java/calculator/util/ExceptionHandler.java @@ -10,20 +10,22 @@ public class ExceptionHandler { private static final int EVEN = 0; private static final int ODD = 1; - private static final int INDEX_INIT = 0; + private static final String BLANK = " "; + private static final String EMPTY_STRING = ""; + private static final String NUMBER_FORMAT = "-?\\d+(\\.\\d+)?"; public static String checkInputHandler(String input) { - if (checkString(input.split(" ")) == true && isUndefinedValue(input) == true) { + if (checkString(input.split(BLANK)) == true && checkUndefinedValue(input) == true) { return input; } throw new IllegalArgumentException(); } - public static boolean isUndefinedValue(String str) { - if (str.replace(" ", "").contains("/0")) { + public static boolean checkUndefinedValue(String str) { + if (str.replace(BLANK, EMPTY_STRING).contains("/0")) { return false; } return true; @@ -33,15 +35,10 @@ public static boolean checkString(String[] inputStrings) { if (inputStrings.length % 2 == EVEN) { return false; } -/* for (int i = INDEX_INIT; i < inputStrings.length; i++) { - if (checkIndividual(i, inputStrings[i]) == false) { - return false; - } - }*/ - // depth 1으로 대신하는 코드 + AtomicInteger index = new AtomicInteger(); return Arrays.stream(inputStrings) - .allMatch(x -> checkIndividual(index.getAndIncrement(), x)); + .allMatch(str -> checkIndividual(index.getAndIncrement(), str)); } public static boolean checkIndividual(int i, String inputString) { @@ -55,7 +52,7 @@ public static boolean checkIndividual(int i, String inputString) { } public static boolean checkNumber(String inputString) { - return inputString.matches("-?\\d+(\\.\\d+)?"); + return inputString.matches(NUMBER_FORMAT); } public static boolean checkSign(String inputString) { diff --git a/src/test/java/calculator/CalculatorTest.java b/src/test/java/calculator/CalculatorTest.java index b0f2564b..cadf77f7 100644 --- a/src/test/java/calculator/CalculatorTest.java +++ b/src/test/java/calculator/CalculatorTest.java @@ -1,8 +1,6 @@ package calculator; import org.junit.jupiter.api.BeforeEach; -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; From 41209de0935e916742f888550f0a8d7b0b47715a Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Mon, 10 Feb 2020 00:20:36 +0900 Subject: [PATCH 26/29] =?UTF-8?q?add=20:=20=ED=85=8C=EC=8A=A4=ED=8A=B8?= =?UTF-8?q?=EC=BD=94=EB=93=9C=20=EC=9E=AC=EC=9E=91=EC=84=B1=20=EB=B0=8F=20?= =?UTF-8?q?static=EC=9C=BC=EB=A1=9C=20=EC=9D=B8=ED=95=9C=20get=20set=20?= =?UTF-8?q?=EB=A9=94=EC=84=9C=EB=93=9C=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/calculator/domain/Calculator.java | 22 +++++- src/main/java/calculator/domain/Operator.java | 2 +- .../calculator/util/ExceptionHandler.java | 3 +- src/test/java/calculator/CalculatorTest.java | 70 ++++++++++--------- .../java/calculator/ExceptionHandlerTest.java | 5 +- src/test/java/calculator/OperatorTest.java | 53 ++++++++++++++ 6 files changed, 114 insertions(+), 41 deletions(-) create mode 100644 src/test/java/calculator/OperatorTest.java diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index c838f87e..05f4d6a1 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -5,14 +5,32 @@ public class Calculator { private static final int INDEX_INIT = 1; + private static final int FIRST_VALUE_INDEX = 0; private static final int EVEN = 0; private static final int ODD = 1; + private static final String DELIMITER = " "; static double returnValue; static String nowSign; + public void setNowSign(String sign){ + this.nowSign = sign; + } + + public void setReturnValue(double returnValue){ + this.returnValue = returnValue; + } + + public double getReturnValue(){ + return this.returnValue; + } + + public String getNowSign(){ + return this.nowSign; + } + public static void run() { - String[] values = InputView.inputHandler().split(" "); - returnValue = Double.parseDouble(values[0]); + String[] values = InputView.inputHandler().split(DELIMITER); + returnValue = Double.parseDouble(values[FIRST_VALUE_INDEX]); selectOddNumberOrEvenNumber(values); OutputView.printResult(returnValue); } diff --git a/src/main/java/calculator/domain/Operator.java b/src/main/java/calculator/domain/Operator.java index 3b2982b8..c65e114c 100644 --- a/src/main/java/calculator/domain/Operator.java +++ b/src/main/java/calculator/domain/Operator.java @@ -2,7 +2,7 @@ import java.util.function.Function; -enum Operator { +public enum Operator { PLUS("+", nowNumber -> Calculator.returnValue += nowNumber), MINUS("-", nowNumber -> Calculator.returnValue -= nowNumber), MULTIPLY("*", nowNumber -> Calculator.returnValue *= nowNumber), diff --git a/src/main/java/calculator/util/ExceptionHandler.java b/src/main/java/calculator/util/ExceptionHandler.java index cb4a5735..0fcc1283 100644 --- a/src/main/java/calculator/util/ExceptionHandler.java +++ b/src/main/java/calculator/util/ExceptionHandler.java @@ -10,6 +10,7 @@ public class ExceptionHandler { private static final int EVEN = 0; private static final int ODD = 1; + private static final String DELIMITER = " "; private static final String BLANK = " "; private static final String EMPTY_STRING = ""; private static final String NUMBER_FORMAT = "-?\\d+(\\.\\d+)?"; @@ -18,7 +19,7 @@ public class ExceptionHandler { public static String checkInputHandler(String input) { - if (checkString(input.split(BLANK)) == true && checkUndefinedValue(input) == true) { + if (checkString(input.split(DELIMITER)) == true && checkUndefinedValue(input) == true) { return input; } throw new IllegalArgumentException(); diff --git a/src/test/java/calculator/CalculatorTest.java b/src/test/java/calculator/CalculatorTest.java index cadf77f7..c83aa782 100644 --- a/src/test/java/calculator/CalculatorTest.java +++ b/src/test/java/calculator/CalculatorTest.java @@ -1,65 +1,67 @@ package calculator; +import calculator.domain.Calculator; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.stream.Stream; import static calculator.domain.Calculator.*; import static org.assertj.core.api.Assertions.*; public class CalculatorTest { static final double TEST_RETURN_VALUE_INIT = 10; - static double returnValue; - static String nowSign; + static final String TEST_NOW_SIGN_INIT = "+"; + Calculator calculator = new Calculator(); @BeforeEach void setUp() { - returnValue = TEST_RETURN_VALUE_INIT; + calculator.setReturnValue(TEST_RETURN_VALUE_INIT); + calculator.setNowSign(TEST_NOW_SIGN_INIT); } - @ParameterizedTest - @CsvSource(value = {"1:+:5:10", "2:+:10:20", "4:-:8:2", "6:*:2:20", "8:/:2:5"}, delimiter = ':') - void checkTest(int i, String sign, String input, double expected) { - nowSign = sign; - check(i, input); - assertThat(returnValue).isEqualTo(expected); + static Stream stringArrayProvider() { + return Stream.of( + Arguments.of(new String[]{"4", "*", "3", "/", "5", "-", "20"}, -17.6), + Arguments.of(new String[]{"2", "-", "1", "*", "3", "+", "2"}, 5) + ); } @ParameterizedTest - @CsvSource(value = {"5:+:15", "5:-:5", "5:*:50", "5:/:2"}, delimiter = ':') - void calculateTest(double input, String sign, double expected) { - nowSign = sign; - calculate(input); - assertThat(returnValue).isEqualTo(expected); + @MethodSource("stringArrayProvider") + @DisplayName("문자열을 받아 계산하는 메서드") + void selectOddNumberOrEvenNumberTest(String[] values, double expected){ + calculator.setReturnValue(Double.parseDouble(values[0])); + selectOddNumberOrEvenNumber(values); + assertThat(calculator.getReturnValue()).isEqualTo(expected); } @ParameterizedTest - @CsvSource(value = {"5:15", "10:20", "33:43"}, delimiter = ':') - void plusTest(double input, double expected) { - plus(input); - System.out.println(input); - System.out.println(expected); - assertThat(returnValue).isEqualTo(expected); + @CsvSource(value = {"0:-:+", "1:*:*", "3:-:-"}, delimiter = ':') + @DisplayName("인덱스가 홀수면 부호를 저장하는 메서드") + void calculateOddNumberTest(int index, String value, String expected){ + calculator.calculateOddNumber(index, value); + assertThat(calculator.getNowSign()).isEqualTo(expected); } @ParameterizedTest - @CsvSource(value = {"5:5", "10:0", "33:-23"}, delimiter = ':') - void minusTest(double input, double expected) { - minus(input); - assertThat(returnValue).isEqualTo(expected); + @CsvSource(value = {"0:1:11", "2:2.3:12.3", "3:4.0:10"}, delimiter = ':') + @DisplayName("인덱스가 짝수면 계산하는 메서드") + void calculateEvenNumberTest(int index, String value, double expected){ + calculator.calculateEvenNumber(index, value); + assertThat(calculator.getReturnValue()).isEqualTo(expected); } @ParameterizedTest - @CsvSource(value = {"5:50", "10:100", "33:330"}, delimiter = ':') - void multiplyTest(double input, double expected) { - multiply(input); - assertThat(returnValue).isEqualTo(expected); + @CsvSource(value = {"1:11", "2.3:12.3", "4.0:14.0"}, delimiter = ':') + @DisplayName("연산자에 따라 계산하는 메서드") + void selectOperatorsTest(double value, double expected){ + calculator.selectOperators(value); + assertThat(calculator.getReturnValue()).isEqualTo(expected); } - @ParameterizedTest - @CsvSource(value = {"5:2", "10:1", "4:2.5"}, delimiter = ':') - void divideTest(double input, double expected) { - divide(input); - assertThat(returnValue).isEqualTo(expected); - } } \ No newline at end of file diff --git a/src/test/java/calculator/ExceptionHandlerTest.java b/src/test/java/calculator/ExceptionHandlerTest.java index 45466718..483caf2b 100644 --- a/src/test/java/calculator/ExceptionHandlerTest.java +++ b/src/test/java/calculator/ExceptionHandlerTest.java @@ -30,7 +30,6 @@ void checkStringTest() { assertThat(checkString(inputStrings)).isTrue(); } - @Test @DisplayName("숫자인지 체크해주는 테스트") void checkNumberTest() { @@ -47,8 +46,8 @@ void checkSignTest() { @Test @DisplayName("0으로 나누었을 때의 예외처리를 해주는 테스트") - void isUndefinedValueTest() { + void checkUndefinedValueTest() { String str = "0 / 0"; - assertThat(isUndefinedValue(str)).isFalse(); + assertThat(checkUndefinedValue(str)).isFalse(); } } \ No newline at end of file diff --git a/src/test/java/calculator/OperatorTest.java b/src/test/java/calculator/OperatorTest.java new file mode 100644 index 00000000..d06a2c9c --- /dev/null +++ b/src/test/java/calculator/OperatorTest.java @@ -0,0 +1,53 @@ +package calculator; + +import calculator.domain.Calculator; +import calculator.domain.Operator; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class OperatorTest { + static final double TEST_RETURN_VALUE_INIT = 10; + static final double TEST_NOW_NUMBER = 5; + Calculator calculator = new Calculator(); + private Operator plusOperator; + private Operator minusOperator; + private Operator multiplyOperator; + private Operator divideOperator; + + @BeforeEach + void setUp(){ + calculator.setReturnValue(TEST_RETURN_VALUE_INIT); + plusOperator = Operator.PLUS; + minusOperator = Operator.MINUS; + multiplyOperator = Operator.MULTIPLY; + divideOperator = Operator.DIVIDE; + } + + @Test + @DisplayName("더하기 연산자 메서드 테스트") + void plusOperatorTest(){ + assertThat(plusOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT + TEST_NOW_NUMBER); + } + + @Test + @DisplayName("빼기 연산자 메서드 테스트") + void minusOperatorTest(){ + assertThat(minusOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT - TEST_NOW_NUMBER); + } + + @Test + @DisplayName("곱하기 연산자 메서드 테스트") + void multiplyOperatorTest(){ + assertThat(multiplyOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT * TEST_NOW_NUMBER); + } + + @Test + @DisplayName("나누기 연산자 메서드 테스트") + void divideOperatorTest(){ + assertThat(divideOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT / TEST_NOW_NUMBER); + } + +} From 141f92b320716abc5dd49601dd7dd61dc2e5c53b Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Mon, 10 Feb 2020 13:02:04 +0900 Subject: [PATCH 27/29] =?UTF-8?q?add=20:=20isEven,=20isOdd=20=EB=A9=94?= =?UTF-8?q?=EC=84=9C=EB=93=9C=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/calculator/domain/Calculator.java | 38 +++++++++++-------- src/main/java/calculator/domain/Operator.java | 4 +- .../calculator/util/ExceptionHandler.java | 12 +++--- 3 files changed, 30 insertions(+), 24 deletions(-) diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index 05f4d6a1..c8122356 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -6,25 +6,25 @@ public class Calculator { private static final int INDEX_INIT = 1; private static final int FIRST_VALUE_INDEX = 0; - private static final int EVEN = 0; - private static final int ODD = 1; + private static final int EVEN_NUMBER = 0; + private static final int ODD_NUMBER = 1; private static final String DELIMITER = " "; static double returnValue; static String nowSign; - public void setNowSign(String sign){ + public void setNowSign(String sign) { this.nowSign = sign; } - public void setReturnValue(double returnValue){ + public void setReturnValue(double returnValue) { this.returnValue = returnValue; } - public double getReturnValue(){ + public double getReturnValue() { return this.returnValue; } - public String getNowSign(){ + public String getNowSign() { return this.nowSign; } @@ -38,34 +38,40 @@ public static void run() { public static void selectOddNumberOrEvenNumber(String[] values) { for (int i = INDEX_INIT; i < values.length; i++) { calculateEvenNumber(i, values[i]); - calculateOddNumber(i,values[i]); + calculateOddNumber(i, values[i]); } } - public static void calculateOddNumber(int index, String value){ - if (index % 2 == ODD) { + public static boolean isOdd(int number) { + return number % 2 == ODD_NUMBER; + } + + public static boolean isEven(int number) { + return number % 2 == EVEN_NUMBER; + } + + public static void calculateOddNumber(int index, String value) { + if (isOdd(index)) { nowSign = value; } } - public static void calculateEvenNumber(int index, String value){ - if (index % 2 == EVEN) { + public static void calculateEvenNumber(int index, String value) { + if (isEven(index)) { selectOperators(Double.parseDouble(value)); } } public static void selectOperators(double nowNumber) { - for(Operator operators : Operator.values()){ + for (Operator operators : Operator.values()) { calculateNumber(operators, nowNumber); } } - public static void calculateNumber(Operator operators, double nowNumber){ - if(operators.getOperator().equals(nowSign)){ + public static void calculateNumber(Operator operators, double nowNumber) { + if (operators.getOperator().equals(nowSign)) { operators.calculate(nowNumber); } } - - } \ No newline at end of file diff --git a/src/main/java/calculator/domain/Operator.java b/src/main/java/calculator/domain/Operator.java index c65e114c..fe5a2ecd 100644 --- a/src/main/java/calculator/domain/Operator.java +++ b/src/main/java/calculator/domain/Operator.java @@ -16,11 +16,11 @@ public enum Operator { this.expression = expression; } - public double calculate(double nowNumber){ + public double calculate(double nowNumber) { return expression.apply(nowNumber); } - public String getOperator(){ + public String getOperator() { return this.operator; } diff --git a/src/main/java/calculator/util/ExceptionHandler.java b/src/main/java/calculator/util/ExceptionHandler.java index 0fcc1283..8bf617c9 100644 --- a/src/main/java/calculator/util/ExceptionHandler.java +++ b/src/main/java/calculator/util/ExceptionHandler.java @@ -5,6 +5,8 @@ import java.util.Scanner; import java.util.concurrent.atomic.AtomicInteger; +import static calculator.domain.Calculator.isEven; +import static calculator.domain.Calculator.isOdd; import static calculator.view.InputView.*; public class ExceptionHandler { @@ -14,9 +16,7 @@ public class ExceptionHandler { private static final String BLANK = " "; private static final String EMPTY_STRING = ""; private static final String NUMBER_FORMAT = "-?\\d+(\\.\\d+)?"; - - - + private static final String DIVIDE_ZERO_STRING = "/0"; public static String checkInputHandler(String input) { if (checkString(input.split(DELIMITER)) == true && checkUndefinedValue(input) == true) { @@ -26,7 +26,7 @@ public static String checkInputHandler(String input) { } public static boolean checkUndefinedValue(String str) { - if (str.replace(BLANK, EMPTY_STRING).contains("/0")) { + if (str.replace(BLANK, EMPTY_STRING).contains(DIVIDE_ZERO_STRING)) { return false; } return true; @@ -43,10 +43,10 @@ public static boolean checkString(String[] inputStrings) { } public static boolean checkIndividual(int i, String inputString) { - if (i % 2 == EVEN) { + if (isEven(i)) { return checkNumber(inputString); } - if (i % 2 == ODD) { + if (isOdd(i)) { return checkSign(inputString); } return false; From 838427e8c3a26d693ad5c2990ae5a5abc8dc1490 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Mon, 10 Feb 2020 15:23:45 +0900 Subject: [PATCH 28/29] =?UTF-8?q?refactor=20:=20checkSign=20=EB=A9=94?= =?UTF-8?q?=EC=84=9C=EB=93=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/calculator/domain/Calculator.java | 1 - src/main/java/calculator/domain/Operator.java | 1 - .../java/calculator/util/ExceptionHandler.java | 18 ++++-------------- src/main/java/calculator/view/InputView.java | 4 +--- src/test/java/calculator/CalculatorTest.java | 13 ++++++------- src/test/java/calculator/OperatorTest.java | 10 +++++----- 6 files changed, 16 insertions(+), 31 deletions(-) diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index c8122356..c60299ee 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -73,5 +73,4 @@ public static void calculateNumber(Operator operators, double nowNumber) { operators.calculate(nowNumber); } } - } \ No newline at end of file diff --git a/src/main/java/calculator/domain/Operator.java b/src/main/java/calculator/domain/Operator.java index fe5a2ecd..3ba36f28 100644 --- a/src/main/java/calculator/domain/Operator.java +++ b/src/main/java/calculator/domain/Operator.java @@ -23,5 +23,4 @@ public double calculate(double nowNumber) { public String getOperator() { return this.operator; } - } \ No newline at end of file diff --git a/src/main/java/calculator/util/ExceptionHandler.java b/src/main/java/calculator/util/ExceptionHandler.java index 8bf617c9..6e27183c 100644 --- a/src/main/java/calculator/util/ExceptionHandler.java +++ b/src/main/java/calculator/util/ExceptionHandler.java @@ -1,22 +1,21 @@ package calculator.util; + import java.util.Arrays; -import java.util.InputMismatchException; -import java.util.Scanner; +import java.util.List; import java.util.concurrent.atomic.AtomicInteger; import static calculator.domain.Calculator.isEven; import static calculator.domain.Calculator.isOdd; -import static calculator.view.InputView.*; public class ExceptionHandler { private static final int EVEN = 0; - private static final int ODD = 1; private static final String DELIMITER = " "; private static final String BLANK = " "; private static final String EMPTY_STRING = ""; private static final String NUMBER_FORMAT = "-?\\d+(\\.\\d+)?"; private static final String DIVIDE_ZERO_STRING = "/0"; + private static List operatorList = Arrays.asList("+", "-", "*", "/"); public static String checkInputHandler(String input) { if (checkString(input.split(DELIMITER)) == true && checkUndefinedValue(input) == true) { @@ -57,16 +56,7 @@ public static boolean checkNumber(String inputString) { } public static boolean checkSign(String inputString) { - if (inputString.equals("+")) { - return true; - } - if (inputString.equals("-")) { - return true; - } - if (inputString.equals("*")) { - return true; - } - if (inputString.equals("/")) { + if (operatorList.contains(inputString)) { return true; } return false; diff --git a/src/main/java/calculator/view/InputView.java b/src/main/java/calculator/view/InputView.java index ba6f60ed..adaec3e6 100644 --- a/src/main/java/calculator/view/InputView.java +++ b/src/main/java/calculator/view/InputView.java @@ -1,7 +1,5 @@ package calculator.view; -import calculator.util.ExceptionHandler; - import java.util.InputMismatchException; import java.util.Scanner; @@ -30,4 +28,4 @@ public static String printInputExpression(){ public static void printInputCheck(){ System.out.println(CHECK_INPUT_STR); } -} +} \ No newline at end of file diff --git a/src/test/java/calculator/CalculatorTest.java b/src/test/java/calculator/CalculatorTest.java index c83aa782..812e180d 100644 --- a/src/test/java/calculator/CalculatorTest.java +++ b/src/test/java/calculator/CalculatorTest.java @@ -26,15 +26,15 @@ void setUp() { static Stream stringArrayProvider() { return Stream.of( - Arguments.of(new String[]{"4", "*", "3", "/", "5", "-", "20"}, -17.6), - Arguments.of(new String[]{"2", "-", "1", "*", "3", "+", "2"}, 5) + Arguments.of(new String[]{"4", "*", "3", "/", "5", "-", "20"}, -17.6), + Arguments.of(new String[]{"2", "-", "1", "*", "3", "+", "2"}, 5) ); } @ParameterizedTest @MethodSource("stringArrayProvider") @DisplayName("문자열을 받아 계산하는 메서드") - void selectOddNumberOrEvenNumberTest(String[] values, double expected){ + void selectOddNumberOrEvenNumberTest(String[] values, double expected) { calculator.setReturnValue(Double.parseDouble(values[0])); selectOddNumberOrEvenNumber(values); assertThat(calculator.getReturnValue()).isEqualTo(expected); @@ -43,7 +43,7 @@ void selectOddNumberOrEvenNumberTest(String[] values, double expected){ @ParameterizedTest @CsvSource(value = {"0:-:+", "1:*:*", "3:-:-"}, delimiter = ':') @DisplayName("인덱스가 홀수면 부호를 저장하는 메서드") - void calculateOddNumberTest(int index, String value, String expected){ + void calculateOddNumberTest(int index, String value, String expected) { calculator.calculateOddNumber(index, value); assertThat(calculator.getNowSign()).isEqualTo(expected); } @@ -51,7 +51,7 @@ void calculateOddNumberTest(int index, String value, String expected){ @ParameterizedTest @CsvSource(value = {"0:1:11", "2:2.3:12.3", "3:4.0:10"}, delimiter = ':') @DisplayName("인덱스가 짝수면 계산하는 메서드") - void calculateEvenNumberTest(int index, String value, double expected){ + void calculateEvenNumberTest(int index, String value, double expected) { calculator.calculateEvenNumber(index, value); assertThat(calculator.getReturnValue()).isEqualTo(expected); } @@ -59,9 +59,8 @@ void calculateEvenNumberTest(int index, String value, double expected){ @ParameterizedTest @CsvSource(value = {"1:11", "2.3:12.3", "4.0:14.0"}, delimiter = ':') @DisplayName("연산자에 따라 계산하는 메서드") - void selectOperatorsTest(double value, double expected){ + void selectOperatorsTest(double value, double expected) { calculator.selectOperators(value); assertThat(calculator.getReturnValue()).isEqualTo(expected); } - } \ No newline at end of file diff --git a/src/test/java/calculator/OperatorTest.java b/src/test/java/calculator/OperatorTest.java index d06a2c9c..97cadf88 100644 --- a/src/test/java/calculator/OperatorTest.java +++ b/src/test/java/calculator/OperatorTest.java @@ -18,7 +18,7 @@ public class OperatorTest { private Operator divideOperator; @BeforeEach - void setUp(){ + void setUp() { calculator.setReturnValue(TEST_RETURN_VALUE_INIT); plusOperator = Operator.PLUS; minusOperator = Operator.MINUS; @@ -28,25 +28,25 @@ void setUp(){ @Test @DisplayName("더하기 연산자 메서드 테스트") - void plusOperatorTest(){ + void plusOperatorTest() { assertThat(plusOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT + TEST_NOW_NUMBER); } @Test @DisplayName("빼기 연산자 메서드 테스트") - void minusOperatorTest(){ + void minusOperatorTest() { assertThat(minusOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT - TEST_NOW_NUMBER); } @Test @DisplayName("곱하기 연산자 메서드 테스트") - void multiplyOperatorTest(){ + void multiplyOperatorTest() { assertThat(multiplyOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT * TEST_NOW_NUMBER); } @Test @DisplayName("나누기 연산자 메서드 테스트") - void divideOperatorTest(){ + void divideOperatorTest() { assertThat(divideOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT / TEST_NOW_NUMBER); } From 7df937bc75825ca8f26642fb9ea0877f37941863 Mon Sep 17 00:00:00 2001 From: aegis1920 Date: Mon, 10 Feb 2020 18:10:04 +0900 Subject: [PATCH 29/29] =?UTF-8?q?refactor=20:=20Operator=20=EC=9D=B8?= =?UTF-8?q?=EC=9E=90=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/calculator/domain/Calculator.java | 2 +- src/main/java/calculator/domain/Operator.java | 18 +++++++++--------- src/test/java/calculator/OperatorTest.java | 11 ++++------- 3 files changed, 14 insertions(+), 17 deletions(-) diff --git a/src/main/java/calculator/domain/Calculator.java b/src/main/java/calculator/domain/Calculator.java index c60299ee..97207dfc 100644 --- a/src/main/java/calculator/domain/Calculator.java +++ b/src/main/java/calculator/domain/Calculator.java @@ -70,7 +70,7 @@ public static void selectOperators(double nowNumber) { public static void calculateNumber(Operator operators, double nowNumber) { if (operators.getOperator().equals(nowSign)) { - operators.calculate(nowNumber); + returnValue = operators.calculate(nowNumber, returnValue); } } } \ No newline at end of file diff --git a/src/main/java/calculator/domain/Operator.java b/src/main/java/calculator/domain/Operator.java index 3ba36f28..f4bbf430 100644 --- a/src/main/java/calculator/domain/Operator.java +++ b/src/main/java/calculator/domain/Operator.java @@ -1,23 +1,23 @@ package calculator.domain; -import java.util.function.Function; +import java.util.function.BiFunction; public enum Operator { - PLUS("+", nowNumber -> Calculator.returnValue += nowNumber), - MINUS("-", nowNumber -> Calculator.returnValue -= nowNumber), - MULTIPLY("*", nowNumber -> Calculator.returnValue *= nowNumber), - DIVIDE("/", nowNumber -> Calculator.returnValue /= nowNumber); + PLUS("+", (nowNumber, returnValue) -> returnValue + nowNumber), + MINUS("-", (nowNumber, returnValue) -> returnValue - nowNumber), + MULTIPLY("*", (nowNumber, returnValue) -> returnValue * nowNumber), + DIVIDE("/", (nowNumber, returnValue) -> returnValue / nowNumber); private String operator; - private Function expression; + private BiFunction expression; - Operator(String operator, Function expression) { + Operator(String operator, BiFunction expression) { this.operator = operator; this.expression = expression; } - public double calculate(double nowNumber) { - return expression.apply(nowNumber); + public double calculate(double nowNumber, double returnValue) { + return expression.apply(nowNumber, returnValue); } public String getOperator() { diff --git a/src/test/java/calculator/OperatorTest.java b/src/test/java/calculator/OperatorTest.java index 97cadf88..ba952e45 100644 --- a/src/test/java/calculator/OperatorTest.java +++ b/src/test/java/calculator/OperatorTest.java @@ -1,6 +1,5 @@ package calculator; -import calculator.domain.Calculator; import calculator.domain.Operator; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -11,7 +10,6 @@ public class OperatorTest { static final double TEST_RETURN_VALUE_INIT = 10; static final double TEST_NOW_NUMBER = 5; - Calculator calculator = new Calculator(); private Operator plusOperator; private Operator minusOperator; private Operator multiplyOperator; @@ -19,7 +17,6 @@ public class OperatorTest { @BeforeEach void setUp() { - calculator.setReturnValue(TEST_RETURN_VALUE_INIT); plusOperator = Operator.PLUS; minusOperator = Operator.MINUS; multiplyOperator = Operator.MULTIPLY; @@ -29,25 +26,25 @@ void setUp() { @Test @DisplayName("더하기 연산자 메서드 테스트") void plusOperatorTest() { - assertThat(plusOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT + TEST_NOW_NUMBER); + assertThat(plusOperator.calculate(TEST_NOW_NUMBER, TEST_RETURN_VALUE_INIT)).isEqualTo(TEST_RETURN_VALUE_INIT + TEST_NOW_NUMBER); } @Test @DisplayName("빼기 연산자 메서드 테스트") void minusOperatorTest() { - assertThat(minusOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT - TEST_NOW_NUMBER); + assertThat(minusOperator.calculate(TEST_NOW_NUMBER, TEST_RETURN_VALUE_INIT)).isEqualTo(TEST_RETURN_VALUE_INIT - TEST_NOW_NUMBER); } @Test @DisplayName("곱하기 연산자 메서드 테스트") void multiplyOperatorTest() { - assertThat(multiplyOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT * TEST_NOW_NUMBER); + assertThat(multiplyOperator.calculate(TEST_NOW_NUMBER, TEST_RETURN_VALUE_INIT)).isEqualTo(TEST_RETURN_VALUE_INIT * TEST_NOW_NUMBER); } @Test @DisplayName("나누기 연산자 메서드 테스트") void divideOperatorTest() { - assertThat(divideOperator.calculate(TEST_NOW_NUMBER)).isEqualTo(TEST_RETURN_VALUE_INIT / TEST_NOW_NUMBER); + assertThat(divideOperator.calculate(TEST_NOW_NUMBER, TEST_RETURN_VALUE_INIT)).isEqualTo(TEST_RETURN_VALUE_INIT / TEST_NOW_NUMBER); } }