From 50e9091799e2ddf4a5e4a5400c192ad0b08e1bdf Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sat, 20 Jun 2020 15:40:17 +0900
Subject: [PATCH 01/24] feat: add hello

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index e69de29..4effa19 100644
--- a/README.md
+++ b/README.md
@@ -0,0 +1 @@
+hello!

From 22e2d1f85ace744d2ed59931b7da108a69acc977 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 21 Jun 2020 00:16:55 +0900
Subject: [PATCH 02/24] refactor: upgrade gradle version.

---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index c0e3016..0176e2b 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 #Sat Jun 20 13:56:54 KST 2020
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists

From fbe75e923d320de94f70e08e3f8c53f3760bf3b4 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 21 Jun 2020 00:17:20 +0900
Subject: [PATCH 03/24] refactor: insert source compatibility java8

---
 build.gradle | 1 +
 1 file changed, 1 insertion(+)

diff --git a/build.gradle b/build.gradle
index c7156de..fd7068c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -4,6 +4,7 @@ plugins {
 
 group 'org.example'
 version '1.0-SNAPSHOT'
+sourceCompatibility = '8'
 
 repositories {
     mavenCentral()

From 8df49031e876db32434946494c5ca736e38654da Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 15:34:55 +0900
Subject: [PATCH 04/24] =?UTF-8?q?docs:=20=EA=B5=AC=ED=98=84=20=EA=B8=B0?=
 =?UTF-8?q?=EB=8A=A5=EB=AA=A9=EB=A1=9D=20=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4effa19..d92e2d2 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,28 @@
-hello!
+# 숫자 야구 게임
+
+## 프로그램 흐름
+
+1. 컴퓨터는 세자리의 중복되지 않는 임의의 3자리 숫자를 생성한다.
+2. 플레이어는 숫자를 수동으로 입력해 컴퓨터가 생성한 숫자를 맞힌다.
+3. 컴퓨터는 플레이어가 입력한 값을 받아 게임 결과를 반환한다.
+    - 3스트라이크가 나오는 경우: 게임이 종료된다.
+    - 그 외의 경우: 2번부터 다시 수행한다.
+4. 게임 종료 후, 게임 재시작 여부를 입력 한다.
+    - 재시작(1)을 요청하는 경우
+        - 1번부터 다시 시작한다.
+    - 게임 종료(2)를 요청하는 경우
+        - 프로그램을 종료한다.
+
+--- 
+
+## 기능 구현 목록
+컴퓨터
+- 1에서 9의 범위의 중복되지 않는 3자리 숫자를 임의로 생성할 수 있다.
+- 숫자를 입력 받으면 컴퓨터가 보유한 숫자와 비교후 게임결과를 도출할 수 있다.
+    - 같은 수가 같은 자리에 있으면 스트라이크
+    - 같은 수가 다른 자리에 있으면 볼
+    - 입력받은 수가 컴퓨터의 숫자 자리에 전혀 없으면 낫싱이다.
+    
+플레이어
+- 1에서 9의 범위의 중복되지 않는 3자리 숫자를 수동으로 생성할 수 있다.
+ 
\ No newline at end of file

From 54a379682df6c4a5d8106fe556142ae8166ec654 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 17:10:36 +0900
Subject: [PATCH 05/24] =?UTF-8?q?docs:=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC?=
 =?UTF-8?q?=ED=98=84=20=EB=AA=A9=EB=A1=9D=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md               | 20 +++++++++++---------
 src/main/java/empty.txt |  0
 2 files changed, 11 insertions(+), 9 deletions(-)
 delete mode 100644 src/main/java/empty.txt

diff --git a/README.md b/README.md
index d92e2d2..b92c48f 100644
--- a/README.md
+++ b/README.md
@@ -16,13 +16,15 @@
 --- 
 
 ## 기능 구현 목록
-컴퓨터
-- 1에서 9의 범위의 중복되지 않는 3자리 숫자를 임의로 생성할 수 있다.
-- 숫자를 입력 받으면 컴퓨터가 보유한 숫자와 비교후 게임결과를 도출할 수 있다.
-    - 같은 수가 같은 자리에 있으면 스트라이크
-    - 같은 수가 다른 자리에 있으면 볼
-    - 입력받은 수가 컴퓨터의 숫자 자리에 전혀 없으면 낫싱이다.
-    
-플레이어
-- 1에서 9의 범위의 중복되지 않는 3자리 숫자를 수동으로 생성할 수 있다.
+- 숫자목록은 3자리의 값을 자동/수동으로 생성한다.
+    - 수동 생성하는 경우, 콘솔에서 값을 직접 입력 받는다.
+    - 자동 생성하는 경우, 임의로 값을 생성한다.
+- 생성되는 숫자는 1~9의 범위 값만 가질 수 있다.
+    - 1~9 외의 값을 포함하고 있으면 예외 발생
+    - 값이 3자리가 아니면 예외 발생
+    - 값들 중 중복 값이 포함되어 있으면 예외 발생
+- 숫자 목록은 다른 숫자 목록을 입력 받아 스트라이크, 볼등의 게임 결과를 계산 할 수 있다.
+- 계산한 결과는 게임의 결과(2스트라이크, 1스트라이크 1볼, 낫싱 등)을 알고 있다.
+- 계산한 결과는 게임 종료 여부를 반환할 수 있다. (3스트라이크)
+
  
\ 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 e69de29..0000000

From 6fd06358d7b1be9dfe3021d231bdd89e098a7b42 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 17:30:54 +0900
Subject: [PATCH 06/24] =?UTF-8?q?feat:=20=EC=88=AB=EC=9E=90=EB=AA=A9?=
 =?UTF-8?q?=EB=A1=9D=20=EC=A4=91=20=ED=95=98=EB=82=98=EC=9D=98=20=EC=88=AB?=
 =?UTF-8?q?=EC=9E=90=EC=97=90=20=EB=8C=80=ED=95=9C=20=EA=B0=9D=EC=B2=B4=20?=
 =?UTF-8?q?=EB=B0=8F=20=EC=83=9D=EC=84=B1=EC=9E=90=20=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 build.gradle                                  |  1 +
 src/main/java/baseball/domain/NumberBall.java | 30 +++++++++++++++++++
 .../java/baseball/domain/NumberBallTest.java  | 24 +++++++++++++++
 3 files changed, 55 insertions(+)
 create mode 100644 src/main/java/baseball/domain/NumberBall.java
 create mode 100644 src/test/java/baseball/domain/NumberBallTest.java

diff --git a/build.gradle b/build.gradle
index fd7068c..4240e7b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -12,5 +12,6 @@ repositories {
 
 dependencies {
     testCompile group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.6.0'
+    testCompile("org.junit.jupiter:junit-jupiter-params:5.4.2")
     testCompile group: 'org.assertj', name: 'assertj-core', version: '3.15.0'
 }
diff --git a/src/main/java/baseball/domain/NumberBall.java b/src/main/java/baseball/domain/NumberBall.java
new file mode 100644
index 0000000..3902baa
--- /dev/null
+++ b/src/main/java/baseball/domain/NumberBall.java
@@ -0,0 +1,30 @@
+package baseball.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class NumberBall {
+    private static final int MIN_VALUE = 1;
+    private static final int MAX_VALUE = 9;
+    private static final String OUT_OF_BOUND_BALL_NUMBER_EXCEPTION_MESSAGE = "주어진 범위 바깥의 볼은 사용할 수 없어요.";
+    private static final Map<Integer, NumberBall> BALL_CACHE = new HashMap<>();
+
+    static {
+        for (int i = MIN_VALUE; i <= MAX_VALUE; i++) {
+            BALL_CACHE.put(i, new NumberBall(i));
+        }
+    }
+
+    private final int value;
+
+    private NumberBall(int value) {
+        this.value = value;
+    }
+
+    public static NumberBall of(int value) {
+        if (BALL_CACHE.containsKey(value)) {
+            return BALL_CACHE.get(value);
+        }
+        throw new IllegalArgumentException(OUT_OF_BOUND_BALL_NUMBER_EXCEPTION_MESSAGE);
+    }
+}
diff --git a/src/test/java/baseball/domain/NumberBallTest.java b/src/test/java/baseball/domain/NumberBallTest.java
new file mode 100644
index 0000000..cc0eea7
--- /dev/null
+++ b/src/test/java/baseball/domain/NumberBallTest.java
@@ -0,0 +1,24 @@
+package baseball.domain;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class NumberBallTest {
+    @DisplayName("1-9 범위의 숫자를 입력받아 캐싱된 Ball객체를 반환한다.")
+    @ParameterizedTest
+    @ValueSource(ints = {1, 9})
+    void create_test(int value) {
+        assertThatCode(() -> NumberBall.of(value)).doesNotThrowAnyException();
+    }
+
+    @DisplayName("1-9 바깥 범위의 Ball 객체 획득 시도시, IllegalArgumentException 발생")
+    @ParameterizedTest
+    @ValueSource(ints = {0, 10})
+    void create_test_out_of_bound_exception(int invalidValue) {
+        assertThatThrownBy(() -> NumberBall.of(invalidValue))
+            .isInstanceOf(IllegalArgumentException.class);
+    }
+}
\ No newline at end of file

From eca1b85a2274c676712b4709c00d6dc9dcb92c27 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 18:11:00 +0900
Subject: [PATCH 07/24] =?UTF-8?q?feat:=20=EC=88=AB=EC=9E=90=EB=AA=A9?=
 =?UTF-8?q?=EB=A1=9D=EC=97=90=20=ED=95=B4=EB=8B=B9=ED=95=98=EB=8A=94=20?=
 =?UTF-8?q?=EA=B0=9D=EC=B2=B4,=20=EC=83=9D=EC=84=B1=EC=9E=90=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

---
 .../java/baseball/domain/NumberBalls.java     | 46 +++++++++++++++++++
 .../java/baseball/domain/NumberBallsTest.java | 38 +++++++++++++++
 2 files changed, 84 insertions(+)
 create mode 100644 src/main/java/baseball/domain/NumberBalls.java
 create mode 100644 src/test/java/baseball/domain/NumberBallsTest.java

diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
new file mode 100644
index 0000000..ef953e9
--- /dev/null
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -0,0 +1,46 @@
+package baseball.domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+public class NumberBalls {
+    public static final int BALL_NUMBER_LENGTH = 3;
+
+    private static final String INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE = "입력 값이 유효하지 않습니다.";
+    private static final String DUPLICATE_NUMBER_CONTAINS_EXCEPTION_MESSAGE = "중복된 값은 들어갈 수 없습니다.";
+    private static final String NULL_ARGUMENT_EXCEPTION_MESSAGE = "Null객체는 허용되지 않습니다.";
+
+    private final List<NumberBall> balls;
+
+    public NumberBalls(final List<NumberBall> balls) {
+        verifyArgument(balls);
+        this.balls = balls;
+    }
+
+    private void verifyArgument(List<NumberBall> balls) {
+        verifyNonNull(balls);
+        verifyNoContainsDuplicateBall(balls);
+        verifyLength(balls);
+    }
+
+    private void verifyNonNull(List<NumberBall> balls) {
+        if (Objects.isNull(balls)) {
+            throw new IllegalArgumentException(NULL_ARGUMENT_EXCEPTION_MESSAGE);
+        }
+    }
+
+    private void verifyNoContainsDuplicateBall(List<NumberBall> balls) {
+        Set<NumberBall> numberBalls = new HashSet<>(balls);
+        if (balls.size() != numberBalls.size()) {
+            throw new IllegalArgumentException(DUPLICATE_NUMBER_CONTAINS_EXCEPTION_MESSAGE);
+        }
+    }
+
+    private void verifyLength(List<NumberBall> balls) {
+        if (balls.size() != BALL_NUMBER_LENGTH) {
+            throw new IllegalArgumentException(INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE);
+        }
+    }
+}
diff --git a/src/test/java/baseball/domain/NumberBallsTest.java b/src/test/java/baseball/domain/NumberBallsTest.java
new file mode 100644
index 0000000..dfd02ad
--- /dev/null
+++ b/src/test/java/baseball/domain/NumberBallsTest.java
@@ -0,0 +1,38 @@
+package baseball.domain;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.assertj.core.util.Lists;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class NumberBallsTest {
+    @DisplayName("중복이 없고, NumberBall를 3개 입력 받는 경우 NumberBalls 생성이 된다.")
+    @Test
+    void create_test() {
+        NumberBall firstNumber = NumberBall.of(1);
+        NumberBall secondNumber = NumberBall.of(2);
+        NumberBall thirdNumber = NumberBall.of(3);
+        assertThatCode(() -> new NumberBalls(Lists.list(firstNumber, secondNumber, thirdNumber)))
+            .doesNotThrowAnyException();
+    }
+
+    @DisplayName("숫자 목록 생성시 중복된 숫자객체가 포함되어 있는 경우 IllegalArgumentException 발생")
+    @Test
+    void create_exception_when_contains_duplicate_number() {
+        NumberBall firstNumber = NumberBall.of(1);
+        NumberBall secondNumber = NumberBall.of(2);
+        NumberBall thirdNumber = NumberBall.of(1);
+        assertThatThrownBy(() -> new NumberBalls(Lists.list(firstNumber, secondNumber, thirdNumber)))
+            .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @DisplayName("숫자 목록 생성시 숫자객체의 size가 유효하지 않는 경우 (3이 아닌경우) IllegalArgumentException 발생")
+    @Test
+    void create_exception_when_balls_size_is_invalid() {
+        NumberBall firstNumber = NumberBall.of(1);
+        NumberBall secondNumber = NumberBall.of(2);
+        assertThatThrownBy(() -> new NumberBalls(Lists.list(firstNumber, secondNumber)))
+            .isInstanceOf(IllegalArgumentException.class);
+    }
+}
\ No newline at end of file

From 4ea7c931ecc328c2777da1eb1131b469683510bb Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 18:27:02 +0900
Subject: [PATCH 08/24] =?UTF-8?q?feat:=20=EB=91=90=20=EC=88=AB=EC=9E=90=20?=
 =?UTF-8?q?=EB=AA=A9=EB=A1=9D=20=EB=B9=84=EA=B5=90=ED=9B=84=20=EC=83=9D?=
 =?UTF-8?q?=EC=84=B1=EB=90=98=EB=8A=94=20=EA=B2=8C=EC=9E=84=20=EA=B2=B0?=
 =?UTF-8?q?=EA=B3=BC=20=EA=B0=9D=EC=B2=B4=20=EB=B0=8F=20=EC=83=9D=EC=84=B1?=
 =?UTF-8?q?=EC=9E=90=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/baseball/domain/Result.java     | 28 ++++++++++++++++
 src/test/java/baseball/domain/ResultTest.java | 33 +++++++++++++++++++
 2 files changed, 61 insertions(+)
 create mode 100644 src/main/java/baseball/domain/Result.java
 create mode 100644 src/test/java/baseball/domain/ResultTest.java

diff --git a/src/main/java/baseball/domain/Result.java b/src/main/java/baseball/domain/Result.java
new file mode 100644
index 0000000..e2bc9eb
--- /dev/null
+++ b/src/main/java/baseball/domain/Result.java
@@ -0,0 +1,28 @@
+package baseball.domain;
+
+public class Result {
+    private final int strikeCount;
+    private final int ballCount;
+
+    public Result(int strikeCount, int ballCount) {
+        verifyCounts(strikeCount, ballCount);
+        this.strikeCount = strikeCount;
+        this.ballCount = ballCount;
+    }
+
+    private void verifyCounts(int strikeCount, int ballCount) {
+        if (strikeCount < 0 || strikeCount > NumberBalls.BALL_NUMBER_LENGTH) {
+            throw new IllegalArgumentException();
+        }
+        if (ballCount < 0 || ballCount > NumberBalls.BALL_NUMBER_LENGTH) {
+            throw new IllegalArgumentException();
+        }
+        if (strikeCount + ballCount > NumberBalls.BALL_NUMBER_LENGTH) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public boolean isAllStrike() {
+        return strikeCount == NumberBalls.BALL_NUMBER_LENGTH;
+    }
+}
diff --git a/src/test/java/baseball/domain/ResultTest.java b/src/test/java/baseball/domain/ResultTest.java
new file mode 100644
index 0000000..e72a871
--- /dev/null
+++ b/src/test/java/baseball/domain/ResultTest.java
@@ -0,0 +1,33 @@
+package baseball.domain;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class ResultTest {
+    @DisplayName("스트라이크, 볼 카운트가 0~3 범위이고 두 카운트의 합이 3을 넘지 않는 경우 결과 객체 생성.")
+    @ParameterizedTest
+    @CsvSource(value = {"0, 0", "1, 2", "2, 1", "3, 0", "0, 3"})
+    void createTest(int strikeCount, int ballCount) {
+        assertThatCode(() -> new Result(strikeCount, ballCount))
+            .doesNotThrowAnyException();
+    }
+
+    @DisplayName("스트라이크, 볼 카운트가 0~3 범위 밖이거나 두 카운트의 합이 3을 넘는 경우 결과 생성시 IllegalArgumentException 발생")
+    @ParameterizedTest
+    @CsvSource(value = {"-1, 0", "0, 4", "-1, 4", "1, 3"})
+    void create_fail_when_invalid_count_include(int strikeCount, int ballCount) {
+        assertThatThrownBy(() -> new Result(strikeCount, ballCount))
+            .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @DisplayName("결과 객체가 풀 스트라이크 여부를 반환할 수 있다.")
+    @ParameterizedTest
+    @CsvSource(value = {"3, true", "2, false"})
+    void isAllStrikeTest(int strikeCount, boolean isAllStrike) {
+        Result result = new Result(strikeCount, 0);
+        assertThat(result.isAllStrike()).isEqualTo(isAllStrike);
+    }
+}
\ No newline at end of file

From a9991e633cccd4997002ab122d0ed168d9a578a6 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 19:03:58 +0900
Subject: [PATCH 09/24] =?UTF-8?q?feat:=20=EB=91=90=20=EC=88=AB=EC=9E=90=20?=
 =?UTF-8?q?=EB=AA=A9=EB=A1=9D=20=EB=B9=84=EA=B5=90=20=EA=B2=B0=EA=B3=BC=20?=
 =?UTF-8?q?=EA=B3=84=EC=82=B0=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/baseball/domain/NumberBalls.java     | 28 +++++++++
 src/main/java/baseball/domain/Result.java     | 18 ++++++
 .../java/baseball/domain/NumberBallsTest.java | 57 ++++++++++++++++---
 3 files changed, 95 insertions(+), 8 deletions(-)

diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
index ef953e9..8b49b58 100644
--- a/src/main/java/baseball/domain/NumberBalls.java
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -43,4 +43,32 @@ private void verifyLength(List<NumberBall> balls) {
             throw new IllegalArgumentException(INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE);
         }
     }
+
+    public Result compute(NumberBalls otherBalls) {
+        int strikeCount = computeStrike(otherBalls);
+        int ballCount = computeBall(otherBalls, strikeCount);
+        return new Result(strikeCount, ballCount);
+    }
+
+    private int computeStrike(NumberBalls comparer) {
+        int strikeCount = 0;
+        for (int i = 0; i < this.balls.size(); i++) {
+            if (this.balls.get(i).equals(comparer.balls.get(i))) {
+                strikeCount++;
+            }
+        }
+        return strikeCount;
+    }
+
+    private int computeBall(NumberBalls otherBalls, int strikeCount) {
+        int ballCandidateCount = getBallCandidateCount(otherBalls);
+        return ballCandidateCount - strikeCount;
+    }
+
+    private int getBallCandidateCount(NumberBalls comparer) {
+        List<NumberBall> otherBalls = comparer.balls;
+        Set<NumberBall> distinctNumbers = new HashSet<>(this.balls);
+        distinctNumbers.addAll(otherBalls);
+        return this.balls.size() + otherBalls.size() - distinctNumbers.size();
+    }
 }
diff --git a/src/main/java/baseball/domain/Result.java b/src/main/java/baseball/domain/Result.java
index e2bc9eb..7bab9f5 100644
--- a/src/main/java/baseball/domain/Result.java
+++ b/src/main/java/baseball/domain/Result.java
@@ -1,5 +1,7 @@
 package baseball.domain;
 
+import java.util.Objects;
+
 public class Result {
     private final int strikeCount;
     private final int ballCount;
@@ -25,4 +27,20 @@ private void verifyCounts(int strikeCount, int ballCount) {
     public boolean isAllStrike() {
         return strikeCount == NumberBalls.BALL_NUMBER_LENGTH;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        Result result = (Result)o;
+        return strikeCount == result.strikeCount &&
+            ballCount == result.ballCount;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(strikeCount, ballCount);
+    }
 }
diff --git a/src/test/java/baseball/domain/NumberBallsTest.java b/src/test/java/baseball/domain/NumberBallsTest.java
index dfd02ad..67c1533 100644
--- a/src/test/java/baseball/domain/NumberBallsTest.java
+++ b/src/test/java/baseball/domain/NumberBallsTest.java
@@ -2,28 +2,40 @@
 
 import static org.assertj.core.api.Assertions.*;
 
+import java.util.stream.Stream;
+
 import org.assertj.core.util.Lists;
+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.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class NumberBallsTest {
+    private NumberBall numberOne;
+    private NumberBall numberTwo;
+    private NumberBall numberThree;
+
+    @BeforeEach
+    void setUp() {
+        numberOne = NumberBall.of(1);
+        numberTwo = NumberBall.of(2);
+        numberThree = NumberBall.of(3);
+    }
+
     @DisplayName("중복이 없고, NumberBall를 3개 입력 받는 경우 NumberBalls 생성이 된다.")
     @Test
     void create_test() {
-        NumberBall firstNumber = NumberBall.of(1);
-        NumberBall secondNumber = NumberBall.of(2);
-        NumberBall thirdNumber = NumberBall.of(3);
-        assertThatCode(() -> new NumberBalls(Lists.list(firstNumber, secondNumber, thirdNumber)))
+        assertThatCode(() -> new NumberBalls(Lists.list(numberOne, numberTwo, numberThree)))
             .doesNotThrowAnyException();
     }
 
     @DisplayName("숫자 목록 생성시 중복된 숫자객체가 포함되어 있는 경우 IllegalArgumentException 발생")
     @Test
     void create_exception_when_contains_duplicate_number() {
-        NumberBall firstNumber = NumberBall.of(1);
-        NumberBall secondNumber = NumberBall.of(2);
-        NumberBall thirdNumber = NumberBall.of(1);
-        assertThatThrownBy(() -> new NumberBalls(Lists.list(firstNumber, secondNumber, thirdNumber)))
+        NumberBall sameBallWithFirstBall = numberOne;
+        assertThatThrownBy(() -> new NumberBalls(Lists.list(numberOne, numberTwo, sameBallWithFirstBall)))
             .isInstanceOf(IllegalArgumentException.class);
     }
 
@@ -35,4 +47,33 @@ void create_exception_when_balls_size_is_invalid() {
         assertThatThrownBy(() -> new NumberBalls(Lists.list(firstNumber, secondNumber)))
             .isInstanceOf(IllegalArgumentException.class);
     }
+
+    @DisplayName("두 숫자 목록을 비교후, 게임 룰에 따른 결과 객체를 반환.")
+    @ParameterizedTest
+    @MethodSource("getPlayerBallsAndResultSet")
+    void compute_baseball_result(NumberBalls playerBalls, Result gameResult) {
+        NumberBalls computerBalls = new NumberBalls(Lists.list(numberOne, numberTwo, numberThree));
+        assertThat(computerBalls.compute(playerBalls)).isEqualTo(gameResult);
+    }
+
+    private static Stream<Arguments> getPlayerBallsAndResultSet() {
+        NumberBall one = NumberBall.of(1);
+        NumberBall two = NumberBall.of(2);
+        NumberBall three = NumberBall.of(3);
+        NumberBall four = NumberBall.of(4);
+        NumberBall five = NumberBall.of(5);
+        NumberBall six = NumberBall.of(6);
+
+        return Stream.of(
+            Arguments.of(new NumberBalls(Lists.list(one, two, three)), new Result(3, 0)),
+            Arguments.of(new NumberBalls(Lists.list(one, four, three)), new Result(2, 0)),
+            Arguments.of(new NumberBalls(Lists.list(five, two, six)), new Result(1, 0)),
+            Arguments.of(new NumberBalls(Lists.list(five, four, six)), new Result(0, 0)),
+            Arguments.of(new NumberBalls(Lists.list(one, five, two)), new Result(1, 1)),
+            Arguments.of(new NumberBalls(Lists.list(five, three, six)), new Result(0, 1)),
+            Arguments.of(new NumberBalls(Lists.list(two, one, three)), new Result(1, 2)),
+            Arguments.of(new NumberBalls(Lists.list(three, four, two)), new Result(0, 2)),
+            Arguments.of(new NumberBalls(Lists.list(three, one, two)), new Result(0, 3))
+        );
+    }
 }
\ No newline at end of file

From c29176d73e2aab4dabac764cef74b347cf7ef3e3 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 19:06:23 +0900
Subject: [PATCH 10/24] =?UTF-8?q?refactor:=20=ED=95=98=EB=82=98=EC=9D=98?=
 =?UTF-8?q?=20=EC=88=AB=EC=9E=90=20=EA=B0=92=20=EA=B0=9D=EC=B2=B4=20equals?=
 =?UTF-8?q?=20=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

---
 src/main/java/baseball/domain/NumberBall.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/main/java/baseball/domain/NumberBall.java b/src/main/java/baseball/domain/NumberBall.java
index 3902baa..5ce76e4 100644
--- a/src/main/java/baseball/domain/NumberBall.java
+++ b/src/main/java/baseball/domain/NumberBall.java
@@ -2,6 +2,7 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
 public class NumberBall {
     private static final int MIN_VALUE = 1;
@@ -27,4 +28,19 @@ public static NumberBall of(int value) {
         }
         throw new IllegalArgumentException(OUT_OF_BOUND_BALL_NUMBER_EXCEPTION_MESSAGE);
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        NumberBall that = (NumberBall)o;
+        return value == that.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
 }

From d4de1f22c70b137f4f887f98414b66bc0f0f5dc8 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 19:45:10 +0900
Subject: [PATCH 11/24] =?UTF-8?q?refactor:=20=EC=88=98=EB=8F=99=20?=
 =?UTF-8?q?=EC=88=AB=EC=9E=90=EB=AA=A9=EB=A1=9D=20=EC=83=9D=EC=84=B1=20?=
 =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../domain/ManualNumberBallsFactory.java      | 36 +++++++++++++++++++
 .../java/baseball/domain/NumberBalls.java     | 15 ++++++++
 .../baseball/domain/NumberBallsFactory.java   |  5 +++
 .../domain/ManualNumberBallsFactoryTest.java  | 27 ++++++++++++++
 4 files changed, 83 insertions(+)
 create mode 100644 src/main/java/baseball/domain/ManualNumberBallsFactory.java
 create mode 100644 src/main/java/baseball/domain/NumberBallsFactory.java
 create mode 100644 src/test/java/baseball/domain/ManualNumberBallsFactoryTest.java

diff --git a/src/main/java/baseball/domain/ManualNumberBallsFactory.java b/src/main/java/baseball/domain/ManualNumberBallsFactory.java
new file mode 100644
index 0000000..e2cb941
--- /dev/null
+++ b/src/main/java/baseball/domain/ManualNumberBallsFactory.java
@@ -0,0 +1,36 @@
+package baseball.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public class ManualNumberBallsFactory implements NumberBallsFactory {
+    private static final int EXTRACT_COMPLETE_CRITERIA = 0;
+    private static final int EXTRACT_BALL_NUMBER_DIVIDER = 10;
+
+    private final int number;
+
+    public ManualNumberBallsFactory(int number) {
+        this.number = number;
+    }
+
+    @Override
+    public NumberBalls generateBalls() {
+        List<NumberBall> result = new ArrayList<>();
+        Stack<NumberBall> numberBalls = extractNumberBalls();
+        while (!numberBalls.empty()) {
+            result.add(numberBalls.pop());
+        }
+        return new NumberBalls(result);
+    }
+
+    private Stack<NumberBall> extractNumberBalls() {
+        Stack<NumberBall> numberBallStack = new Stack<>();
+        int num = number;
+        while (num > EXTRACT_COMPLETE_CRITERIA) {
+            numberBallStack.push(NumberBall.of(num % EXTRACT_BALL_NUMBER_DIVIDER));
+            num /= EXTRACT_BALL_NUMBER_DIVIDER;
+        }
+        return numberBallStack;
+    }
+}
diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
index 8b49b58..e22c936 100644
--- a/src/main/java/baseball/domain/NumberBalls.java
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -71,4 +71,19 @@ private int getBallCandidateCount(NumberBalls comparer) {
         distinctNumbers.addAll(otherBalls);
         return this.balls.size() + otherBalls.size() - distinctNumbers.size();
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        NumberBalls that = (NumberBalls)o;
+        return Objects.equals(balls, that.balls);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(balls);
+    }
 }
diff --git a/src/main/java/baseball/domain/NumberBallsFactory.java b/src/main/java/baseball/domain/NumberBallsFactory.java
new file mode 100644
index 0000000..6d43392
--- /dev/null
+++ b/src/main/java/baseball/domain/NumberBallsFactory.java
@@ -0,0 +1,5 @@
+package baseball.domain;
+
+public interface NumberBallsFactory {
+    NumberBalls generateBalls();
+}
diff --git a/src/test/java/baseball/domain/ManualNumberBallsFactoryTest.java b/src/test/java/baseball/domain/ManualNumberBallsFactoryTest.java
new file mode 100644
index 0000000..22a6511
--- /dev/null
+++ b/src/test/java/baseball/domain/ManualNumberBallsFactoryTest.java
@@ -0,0 +1,27 @@
+package baseball.domain;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.assertj.core.util.Lists;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class ManualNumberBallsFactoryTest {
+    @DisplayName("중복이 없고 0이 포함되지 않은 세자리의 자연수를 숫자 목록 객체로 생성한다.")
+    @Test
+    void generateBalls_test() {
+        NumberBallsFactory numberBallsFactory = new ManualNumberBallsFactory(321);
+        assertThat(numberBallsFactory.generateBalls())
+            .isEqualTo(new NumberBalls(Lists.list(NumberBall.of(3), NumberBall.of(2), NumberBall.of(1))));
+    }
+
+    @DisplayName("중복값 포함 혹은 세자리가 아니거나 음수인경우 생성도중 IllegalArgumentException 발생")
+    @ParameterizedTest
+    @ValueSource(ints = {333, 1234, 75, -152, -10})
+    void generateBalls_test_fail(int value) {
+        NumberBallsFactory numberBallsFactory = new ManualNumberBallsFactory(value);
+        assertThatThrownBy(numberBallsFactory::generateBalls).isInstanceOf(IllegalArgumentException.class);
+    }
+}
\ No newline at end of file

From c449683e24d889157f5a9336fa32e76437a9a745 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 20:00:50 +0900
Subject: [PATCH 12/24] =?UTF-8?q?refactor:=20=EC=9E=90=EB=8F=99=20?=
 =?UTF-8?q?=EC=88=AB=EC=9E=90=EB=AA=A9=EB=A1=9D=20=EC=83=9D=EC=84=B1=20?=
 =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../domain/AutoNumberBallsFactory.java        | 27 +++++++++++++++++++
 src/main/java/baseball/domain/NumberBall.java |  4 +--
 .../java/baseball/domain/NumberBalls.java     |  3 +--
 .../domain/AutoNumberBallsFactoryTest.java    | 21 +++++++++++++++
 4 files changed, 51 insertions(+), 4 deletions(-)
 create mode 100644 src/main/java/baseball/domain/AutoNumberBallsFactory.java
 create mode 100644 src/test/java/baseball/domain/AutoNumberBallsFactoryTest.java

diff --git a/src/main/java/baseball/domain/AutoNumberBallsFactory.java b/src/main/java/baseball/domain/AutoNumberBallsFactory.java
new file mode 100644
index 0000000..91cdc80
--- /dev/null
+++ b/src/main/java/baseball/domain/AutoNumberBallsFactory.java
@@ -0,0 +1,27 @@
+package baseball.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class AutoNumberBallsFactory implements NumberBallsFactory {
+    private static final int BALLS_FIRST_INDEX = 0;
+
+    private final List<NumberBall> allDistinctNumbers = new ArrayList<>();
+
+    public AutoNumberBallsFactory() {
+        init();
+    }
+
+    private void init() {
+        for (int i = NumberBall.MIN_VALUE; i < NumberBall.MAX_VALUE; i++) {
+            allDistinctNumbers.add(NumberBall.of(i));
+        }
+    }
+
+    @Override
+    public NumberBalls generateBalls() {
+        Collections.shuffle(allDistinctNumbers);
+        return new NumberBalls(allDistinctNumbers.subList(BALLS_FIRST_INDEX, NumberBalls.BALL_NUMBER_LENGTH));
+    }
+}
diff --git a/src/main/java/baseball/domain/NumberBall.java b/src/main/java/baseball/domain/NumberBall.java
index 5ce76e4..c8e9518 100644
--- a/src/main/java/baseball/domain/NumberBall.java
+++ b/src/main/java/baseball/domain/NumberBall.java
@@ -5,8 +5,8 @@
 import java.util.Objects;
 
 public class NumberBall {
-    private static final int MIN_VALUE = 1;
-    private static final int MAX_VALUE = 9;
+    static final int MIN_VALUE = 1;
+    static final int MAX_VALUE = 9;
     private static final String OUT_OF_BOUND_BALL_NUMBER_EXCEPTION_MESSAGE = "주어진 범위 바깥의 볼은 사용할 수 없어요.";
     private static final Map<Integer, NumberBall> BALL_CACHE = new HashMap<>();
 
diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
index e22c936..b914ee5 100644
--- a/src/main/java/baseball/domain/NumberBalls.java
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -6,8 +6,7 @@
 import java.util.Set;
 
 public class NumberBalls {
-    public static final int BALL_NUMBER_LENGTH = 3;
-
+    static final int BALL_NUMBER_LENGTH = 3;
     private static final String INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE = "입력 값이 유효하지 않습니다.";
     private static final String DUPLICATE_NUMBER_CONTAINS_EXCEPTION_MESSAGE = "중복된 값은 들어갈 수 없습니다.";
     private static final String NULL_ARGUMENT_EXCEPTION_MESSAGE = "Null객체는 허용되지 않습니다.";
diff --git a/src/test/java/baseball/domain/AutoNumberBallsFactoryTest.java b/src/test/java/baseball/domain/AutoNumberBallsFactoryTest.java
new file mode 100644
index 0000000..0384b57
--- /dev/null
+++ b/src/test/java/baseball/domain/AutoNumberBallsFactoryTest.java
@@ -0,0 +1,21 @@
+package baseball.domain;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class AutoNumberBallsFactoryTest {
+    @DisplayName("숫자목록 자동 생성시 예외 발생 없이 숫자목록 객체가 정상 생성 된다.")
+    @Test
+    void generatingTest() {
+        NumberBallsFactory numberBallsFactory = new AutoNumberBallsFactory();
+        assertThatCode(() -> generateNumberByAuto(numberBallsFactory, 500)).doesNotThrowAnyException();
+    }
+
+    private void generateNumberByAuto(NumberBallsFactory numberBallsFactory, int times) {
+        for (int i = 0; i < times; i++) {
+            numberBallsFactory.generateBalls();
+        }
+    }
+}
\ No newline at end of file

From ee13756c383773c1aa05cfbb31f258b40eb19739 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 21:15:04 +0900
Subject: [PATCH 13/24] =?UTF-8?q?feat:=20=EA=B2=8C=EC=9E=84=20=EC=A2=85?=
 =?UTF-8?q?=EB=A3=8C=20=EC=97=AC=EB=B6=80=20=EA=B5=AC=EB=B6=84=20=EA=B8=B0?=
 =?UTF-8?q?=EB=8A=A5=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/baseball/domain/PlayerChoice.java    | 26 +++++++++++++++++++
 .../baseball/domain/PlayerChoiceTest.java     | 24 +++++++++++++++++
 2 files changed, 50 insertions(+)
 create mode 100644 src/main/java/baseball/domain/PlayerChoice.java
 create mode 100644 src/test/java/baseball/domain/PlayerChoiceTest.java

diff --git a/src/main/java/baseball/domain/PlayerChoice.java b/src/main/java/baseball/domain/PlayerChoice.java
new file mode 100644
index 0000000..b9b46cc
--- /dev/null
+++ b/src/main/java/baseball/domain/PlayerChoice.java
@@ -0,0 +1,26 @@
+package baseball.domain;
+
+import java.util.Arrays;
+
+public enum PlayerChoice {
+    PLAY_AGAIN("1"), GAME_END("2");
+
+    private static final String INVALID_PLAYER_CHOICE_CODE_EXCEPTION_MESSAGE = "유효한 값이 아닙니다.";
+
+    private final String chooseCode;
+
+    PlayerChoice(String chooseCode) {
+        this.chooseCode = chooseCode;
+    }
+
+    public static PlayerChoice of(String value) {
+        return Arrays.stream(values())
+            .filter(playerChoiceValue -> playerChoiceValue.chooseCode.equals(value))
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException(INVALID_PLAYER_CHOICE_CODE_EXCEPTION_MESSAGE));
+    }
+
+    public boolean isPlayAgain() {
+        return this == PLAY_AGAIN;
+    }
+}
diff --git a/src/test/java/baseball/domain/PlayerChoiceTest.java b/src/test/java/baseball/domain/PlayerChoiceTest.java
new file mode 100644
index 0000000..989b564
--- /dev/null
+++ b/src/test/java/baseball/domain/PlayerChoiceTest.java
@@ -0,0 +1,24 @@
+package baseball.domain;
+
+import static org.assertj.core.api.Assertions.*;
+
+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;
+
+class PlayerChoiceTest {
+    @DisplayName("1, 2 값 이외의 값을 입력받은 경우, IllegalArgumentException 발생")
+    @Test
+    void create_fail() {
+        assertThatThrownBy(() -> PlayerChoice.of("3")).isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @DisplayName("1을 넣는 경우, 게임 재시작 여부 true, 2를 넣는 경우, 게임 재시작 여부 false를 반환")
+    @ParameterizedTest
+    @CsvSource(value = {"1, true", "2, false"})
+    void playAgainTest(String inputValue, boolean expected) {
+        PlayerChoice playerChoice = PlayerChoice.of(inputValue);
+        assertThat(playerChoice.isPlayAgain()).isEqualTo(expected);
+    }
+}
\ No newline at end of file

From 3620ee1d8257bed951bca5940b86247538200f23 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 21:15:51 +0900
Subject: [PATCH 14/24] =?UTF-8?q?feat:=20input,=20output=20view,=20main=20?=
 =?UTF-8?q?=EB=A9=94=EC=86=8C=EB=93=9C=20=EC=97=B0=EA=B2=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../baseball/BaseBallMainApplication.java     | 54 +++++++++++++++++++
 src/main/java/baseball/domain/NumberBall.java |  3 +-
 .../java/baseball/domain/NumberBalls.java     |  1 +
 src/main/java/baseball/domain/Result.java     |  8 +++
 src/main/java/baseball/view/InputView.java    | 25 +++++++++
 src/main/java/baseball/view/OutputView.java   | 15 ++++++
 6 files changed, 105 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/baseball/BaseBallMainApplication.java
 create mode 100644 src/main/java/baseball/view/InputView.java
 create mode 100644 src/main/java/baseball/view/OutputView.java

diff --git a/src/main/java/baseball/BaseBallMainApplication.java b/src/main/java/baseball/BaseBallMainApplication.java
new file mode 100644
index 0000000..676028b
--- /dev/null
+++ b/src/main/java/baseball/BaseBallMainApplication.java
@@ -0,0 +1,54 @@
+package baseball;
+
+import baseball.domain.AutoNumberBallsFactory;
+import baseball.domain.ManualNumberBallsFactory;
+import baseball.domain.NumberBalls;
+import baseball.domain.NumberBallsFactory;
+import baseball.domain.PlayerChoice;
+import baseball.domain.Result;
+import baseball.view.InputView;
+import baseball.view.OutputView;
+
+public class BaseBallMainApplication {
+    public static void main(String[] args) {
+        NumberBallsFactory numberBallsFactory = new AutoNumberBallsFactory();
+        do {
+            NumberBalls computerBalls = numberBallsFactory.generateBalls();
+            inputPlayerBallsWhileAllStrike(computerBalls);
+            OutputView.printWinningMessage();
+        } while (inputPlayGameAgain().isPlayAgain());
+    }
+
+    private static void inputPlayerBallsWhileAllStrike(NumberBalls computerBalls) {
+        while (true) {
+            NumberBalls playerBalls = inputPlayerNumberBalls();
+            Result compute = computerBalls.compute(playerBalls);
+            OutputView.printCompareResult(compute);
+            if (compute.isAllStrike()) {
+                break;
+            }
+        }
+    }
+
+    private static NumberBalls inputPlayerNumberBalls() {
+        while (true) {
+            try {
+                NumberBallsFactory manualNumberBallsFactory = new ManualNumberBallsFactory(
+                    InputView.inputBaseBallNumbers());
+                return manualNumberBallsFactory.generateBalls();
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+        }
+    }
+
+    private static PlayerChoice inputPlayGameAgain() {
+        while (true) {
+            try {
+                return PlayerChoice.of(InputView.inputPlayAgain());
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+        }
+    }
+}
diff --git a/src/main/java/baseball/domain/NumberBall.java b/src/main/java/baseball/domain/NumberBall.java
index c8e9518..ecec9f3 100644
--- a/src/main/java/baseball/domain/NumberBall.java
+++ b/src/main/java/baseball/domain/NumberBall.java
@@ -7,9 +7,10 @@
 public class NumberBall {
     static final int MIN_VALUE = 1;
     static final int MAX_VALUE = 9;
-    private static final String OUT_OF_BOUND_BALL_NUMBER_EXCEPTION_MESSAGE = "주어진 범위 바깥의 볼은 사용할 수 없어요.";
     private static final Map<Integer, NumberBall> BALL_CACHE = new HashMap<>();
 
+    private static final String OUT_OF_BOUND_BALL_NUMBER_EXCEPTION_MESSAGE = "주어진 범위 바깥의 볼은 사용할 수 없어요.";
+
     static {
         for (int i = MIN_VALUE; i <= MAX_VALUE; i++) {
             BALL_CACHE.put(i, new NumberBall(i));
diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
index b914ee5..6026714 100644
--- a/src/main/java/baseball/domain/NumberBalls.java
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -7,6 +7,7 @@
 
 public class NumberBalls {
     static final int BALL_NUMBER_LENGTH = 3;
+
     private static final String INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE = "입력 값이 유효하지 않습니다.";
     private static final String DUPLICATE_NUMBER_CONTAINS_EXCEPTION_MESSAGE = "중복된 값은 들어갈 수 없습니다.";
     private static final String NULL_ARGUMENT_EXCEPTION_MESSAGE = "Null객체는 허용되지 않습니다.";
diff --git a/src/main/java/baseball/domain/Result.java b/src/main/java/baseball/domain/Result.java
index 7bab9f5..023b17d 100644
--- a/src/main/java/baseball/domain/Result.java
+++ b/src/main/java/baseball/domain/Result.java
@@ -28,6 +28,14 @@ public boolean isAllStrike() {
         return strikeCount == NumberBalls.BALL_NUMBER_LENGTH;
     }
 
+    public int getStrikeCount() {
+        return strikeCount;
+    }
+
+    public int getBallCount() {
+        return ballCount;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o)
diff --git a/src/main/java/baseball/view/InputView.java b/src/main/java/baseball/view/InputView.java
new file mode 100644
index 0000000..9e2644a
--- /dev/null
+++ b/src/main/java/baseball/view/InputView.java
@@ -0,0 +1,25 @@
+package baseball.view;
+
+import java.util.Scanner;
+
+public class InputView {
+    private static final Scanner SCANNER = new Scanner(System.in);
+
+    public static Integer inputBaseBallNumbers() {
+        System.out.print("숫자를 입력해주세요 : ");
+        return parseInt(SCANNER.next());
+    }
+
+    private static Integer parseInt(String inputValue) {
+        try {
+            return Integer.parseInt(inputValue);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("숫자 외의 값은 입력 받을 수 없습니다.");
+        }
+    }
+
+    public static String inputPlayAgain() {
+        System.out.print("게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.: ");
+        return SCANNER.next();
+    }
+}
diff --git a/src/main/java/baseball/view/OutputView.java b/src/main/java/baseball/view/OutputView.java
new file mode 100644
index 0000000..8a5f9a0
--- /dev/null
+++ b/src/main/java/baseball/view/OutputView.java
@@ -0,0 +1,15 @@
+package baseball.view;
+
+import baseball.domain.Result;
+
+public class OutputView {
+    public static void printCompareResult(Result compute) {
+        int strikeCount = compute.getStrikeCount();
+        int ballCount = compute.getBallCount();
+        System.out.printf("%d 스트라이크, %d 볼\n", strikeCount, ballCount);
+    }
+
+    public static void printWinningMessage() {
+        System.out.println("3개의 숫자를 모두 맞혔습니다. 게임종료.");
+    }
+}

From 3d15b397448fe6ece884a3bf9701f2396873946e Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 22:52:27 +0900
Subject: [PATCH 15/24] =?UTF-8?q?refactor:=20=EA=B0=92=20=ED=83=80?=
 =?UTF-8?q?=EC=9E=85=20=ED=81=B4=EB=9E=98=EC=8A=A4=20final=20=EC=B6=94?=
 =?UTF-8?q?=EA=B0=80,=20result=20=EA=B0=9D=EC=B2=B4=20=ED=95=84=EB=93=9C?=
 =?UTF-8?q?=20count=20=EA=B0=9D=EC=B2=B4=EB=A1=9C=20=ED=8F=AC=EC=9E=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/baseball/domain/Count.java      | 67 +++++++++++++++++++
 src/main/java/baseball/domain/NumberBall.java | 13 +++-
 .../java/baseball/domain/NumberBalls.java     |  8 ++-
 src/main/java/baseball/domain/Result.java     | 33 ++++-----
 src/main/java/baseball/view/OutputView.java   |  7 +-
 src/test/java/baseball/domain/CountTest.java  | 41 ++++++++++++
 .../java/baseball/domain/NumberBallsTest.java | 18 ++---
 src/test/java/baseball/domain/ResultTest.java |  6 +-
 8 files changed, 156 insertions(+), 37 deletions(-)
 create mode 100644 src/main/java/baseball/domain/Count.java
 create mode 100644 src/test/java/baseball/domain/CountTest.java

diff --git a/src/main/java/baseball/domain/Count.java b/src/main/java/baseball/domain/Count.java
new file mode 100644
index 0000000..d564a9e
--- /dev/null
+++ b/src/main/java/baseball/domain/Count.java
@@ -0,0 +1,67 @@
+package baseball.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+public final class Count {
+    private static final int MIN_COUNT_VALUE = 0;
+    private static final int MAX_COUNT_VALUE = NumberBalls.BALL_NUMBER_LENGTH;
+    private static final Map<Integer, Count> COUNT_CACHE;
+
+    private static final String INVALID_COUNT_VALUE_BOUNDARY_EXCEPTION_MESSAGE = "볼, 스트라이크수를 계산할 수 있는 유효한 값의 범위가 아닙니다.";
+
+    static {
+        COUNT_CACHE = new HashMap<>();
+        for (int i = MIN_COUNT_VALUE; i <= MAX_COUNT_VALUE; i++) {
+            COUNT_CACHE.put(i, new Count(i));
+        }
+    }
+
+    private final int value;
+
+    private Count(int value) {
+        verifyCountValue(value);
+        this.value = value;
+    }
+
+    private void verifyCountValue(int value) {
+        if (value < MIN_COUNT_VALUE || value > MAX_COUNT_VALUE) {
+            throw new IllegalArgumentException(INVALID_COUNT_VALUE_BOUNDARY_EXCEPTION_MESSAGE);
+        }
+    }
+
+    public static Count of(int value) {
+        if (COUNT_CACHE.containsKey(value)) {
+            return COUNT_CACHE.get(value);
+        }
+        throw new IllegalArgumentException(INVALID_COUNT_VALUE_BOUNDARY_EXCEPTION_MESSAGE);
+    }
+
+    public boolean isSameValue(int countValue) {
+        return this.value == countValue;
+    }
+
+    public boolean isSumOfValueGreaterThanMax(Count otherCount) {
+        return (this.value + otherCount.value) > NumberBalls.BALL_NUMBER_LENGTH;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        Count count1 = (Count)o;
+        return value == count1.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(value);
+    }
+}
diff --git a/src/main/java/baseball/domain/NumberBall.java b/src/main/java/baseball/domain/NumberBall.java
index ecec9f3..96f6e61 100644
--- a/src/main/java/baseball/domain/NumberBall.java
+++ b/src/main/java/baseball/domain/NumberBall.java
@@ -4,12 +4,12 @@
 import java.util.Map;
 import java.util.Objects;
 
-public class NumberBall {
+public final class NumberBall {
     static final int MIN_VALUE = 1;
     static final int MAX_VALUE = 9;
     private static final Map<Integer, NumberBall> BALL_CACHE = new HashMap<>();
 
-    private static final String OUT_OF_BOUND_BALL_NUMBER_EXCEPTION_MESSAGE = "주어진 범위 바깥의 볼은 사용할 수 없어요.";
+    private static final String INVALID_BALL_NUMBER_BOUNDARY_EXCEPTION_MESSAGE = "주어진 범위 바깥의 볼은 사용할 수 없어요.";
 
     static {
         for (int i = MIN_VALUE; i <= MAX_VALUE; i++) {
@@ -20,14 +20,21 @@ public class NumberBall {
     private final int value;
 
     private NumberBall(int value) {
+        verifyNumberBall(value);
         this.value = value;
     }
 
+    private void verifyNumberBall(int value) {
+        if (value < MIN_VALUE || value > MAX_VALUE) {
+            throw new IllegalArgumentException(INVALID_BALL_NUMBER_BOUNDARY_EXCEPTION_MESSAGE);
+        }
+    }
+
     public static NumberBall of(int value) {
         if (BALL_CACHE.containsKey(value)) {
             return BALL_CACHE.get(value);
         }
-        throw new IllegalArgumentException(OUT_OF_BOUND_BALL_NUMBER_EXCEPTION_MESSAGE);
+        throw new IllegalArgumentException(INVALID_BALL_NUMBER_BOUNDARY_EXCEPTION_MESSAGE);
     }
 
     @Override
diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
index 6026714..7cf94b0 100644
--- a/src/main/java/baseball/domain/NumberBalls.java
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -1,11 +1,13 @@
 package baseball.domain;
 
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 
-public class NumberBalls {
+public final class NumberBalls {
     static final int BALL_NUMBER_LENGTH = 3;
 
     private static final String INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE = "입력 값이 유효하지 않습니다.";
@@ -16,7 +18,7 @@ public class NumberBalls {
 
     public NumberBalls(final List<NumberBall> balls) {
         verifyArgument(balls);
-        this.balls = balls;
+        this.balls = Collections.unmodifiableList(new ArrayList<>(balls));
     }
 
     private void verifyArgument(List<NumberBall> balls) {
@@ -47,7 +49,7 @@ private void verifyLength(List<NumberBall> balls) {
     public Result compute(NumberBalls otherBalls) {
         int strikeCount = computeStrike(otherBalls);
         int ballCount = computeBall(otherBalls, strikeCount);
-        return new Result(strikeCount, ballCount);
+        return Result.of(strikeCount, ballCount);
     }
 
     private int computeStrike(NumberBalls comparer) {
diff --git a/src/main/java/baseball/domain/Result.java b/src/main/java/baseball/domain/Result.java
index 023b17d..21e19a8 100644
--- a/src/main/java/baseball/domain/Result.java
+++ b/src/main/java/baseball/domain/Result.java
@@ -2,37 +2,38 @@
 
 import java.util.Objects;
 
-public class Result {
-    private final int strikeCount;
-    private final int ballCount;
+public final class Result {
+    private static final String INVALID_TOTAL_COUNT_OF_STRIKE_BALL_EXCEPTION_MESSAGE =
+        "스트라이크와 볼의 값의 합이 현재 가능한 값을 넘었습니다.";
 
-    public Result(int strikeCount, int ballCount) {
+    private final Count strikeCount;
+    private final Count ballCount;
+
+    private Result(Count strikeCount, Count ballCount) {
         verifyCounts(strikeCount, ballCount);
         this.strikeCount = strikeCount;
         this.ballCount = ballCount;
     }
 
-    private void verifyCounts(int strikeCount, int ballCount) {
-        if (strikeCount < 0 || strikeCount > NumberBalls.BALL_NUMBER_LENGTH) {
-            throw new IllegalArgumentException();
-        }
-        if (ballCount < 0 || ballCount > NumberBalls.BALL_NUMBER_LENGTH) {
-            throw new IllegalArgumentException();
-        }
-        if (strikeCount + ballCount > NumberBalls.BALL_NUMBER_LENGTH) {
-            throw new IllegalArgumentException();
+    private void verifyCounts(Count strikeCount, Count ballCount) {
+        if (strikeCount.isSumOfValueGreaterThanMax(ballCount)) {
+            throw new IllegalArgumentException(INVALID_TOTAL_COUNT_OF_STRIKE_BALL_EXCEPTION_MESSAGE);
         }
     }
 
+    public static Result of(int strikeCount, int ballCount) {
+        return new Result(Count.of(strikeCount), Count.of(ballCount));
+    }
+
     public boolean isAllStrike() {
-        return strikeCount == NumberBalls.BALL_NUMBER_LENGTH;
+        return strikeCount.isSameValue(NumberBalls.BALL_NUMBER_LENGTH);
     }
 
-    public int getStrikeCount() {
+    public Count getStrikeCount() {
         return strikeCount;
     }
 
-    public int getBallCount() {
+    public Count getBallCount() {
         return ballCount;
     }
 
diff --git a/src/main/java/baseball/view/OutputView.java b/src/main/java/baseball/view/OutputView.java
index 8a5f9a0..2458795 100644
--- a/src/main/java/baseball/view/OutputView.java
+++ b/src/main/java/baseball/view/OutputView.java
@@ -1,12 +1,13 @@
 package baseball.view;
 
+import baseball.domain.Count;
 import baseball.domain.Result;
 
 public class OutputView {
     public static void printCompareResult(Result compute) {
-        int strikeCount = compute.getStrikeCount();
-        int ballCount = compute.getBallCount();
-        System.out.printf("%d 스트라이크, %d 볼\n", strikeCount, ballCount);
+        Count strikeCount = compute.getStrikeCount();
+        Count ballCount = compute.getBallCount();
+        System.out.printf("%d 스트라이크, %d 볼\n", strikeCount.getValue(), ballCount.getValue());
     }
 
     public static void printWinningMessage() {
diff --git a/src/test/java/baseball/domain/CountTest.java b/src/test/java/baseball/domain/CountTest.java
new file mode 100644
index 0000000..794466e
--- /dev/null
+++ b/src/test/java/baseball/domain/CountTest.java
@@ -0,0 +1,41 @@
+package baseball.domain;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class CountTest {
+    @DisplayName("스트라이크 혹은 볼의 최소, 최대 가능 갯수를 인자로 count 객체 생성시 정상적으로 객체 생성")
+    @ParameterizedTest
+    @ValueSource(ints = {0, 3})
+    void create_test(int count) {
+        assertThatCode(() -> Count.of(count)).doesNotThrowAnyException();
+    }
+
+    @DisplayName("스트라이크 혹은 볼의 갯수로 가능하지 않는 값을 인자로 count 객체 생성시 IllegalArgumentException 발생")
+    @ParameterizedTest
+    @ValueSource(ints = {-1, 4})
+    void create_test_fail(int count) {
+        assertThatThrownBy(() -> Count.of(count)).isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @DisplayName("count 객체가 인자값에 해당하는 값을 가지고 있으면 true, 그렇지 않으면 false 반환")
+    @ParameterizedTest
+    @CsvSource(value = {"3, 3, true", "2, 3, false"})
+    void isSameValueTest(int countValue, int comparer, boolean expected) {
+        Count count = Count.of(countValue);
+        assertThat(count.isSameValue(comparer)).isEqualTo(expected);
+    }
+
+    @DisplayName("두 count객체의 value의 값의 합이 숫자의 자릿수를 넘으면 true, 넘지 않으면 false 반환")
+    @ParameterizedTest
+    @CsvSource(value = {"3, 3, true", "0, 3, false", "1, 2, false", "0, 0, false"})
+    void isSumOfValueGreaterThanMax(int firstValue, int secondValue, boolean expected) {
+        Count firstCount = Count.of(firstValue);
+        Count secondCount = Count.of(secondValue);
+        assertThat(firstCount.isSumOfValueGreaterThanMax(secondCount)).isEqualTo(expected);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/baseball/domain/NumberBallsTest.java b/src/test/java/baseball/domain/NumberBallsTest.java
index 67c1533..59fdbf1 100644
--- a/src/test/java/baseball/domain/NumberBallsTest.java
+++ b/src/test/java/baseball/domain/NumberBallsTest.java
@@ -65,15 +65,15 @@ private static Stream<Arguments> getPlayerBallsAndResultSet() {
         NumberBall six = NumberBall.of(6);
 
         return Stream.of(
-            Arguments.of(new NumberBalls(Lists.list(one, two, three)), new Result(3, 0)),
-            Arguments.of(new NumberBalls(Lists.list(one, four, three)), new Result(2, 0)),
-            Arguments.of(new NumberBalls(Lists.list(five, two, six)), new Result(1, 0)),
-            Arguments.of(new NumberBalls(Lists.list(five, four, six)), new Result(0, 0)),
-            Arguments.of(new NumberBalls(Lists.list(one, five, two)), new Result(1, 1)),
-            Arguments.of(new NumberBalls(Lists.list(five, three, six)), new Result(0, 1)),
-            Arguments.of(new NumberBalls(Lists.list(two, one, three)), new Result(1, 2)),
-            Arguments.of(new NumberBalls(Lists.list(three, four, two)), new Result(0, 2)),
-            Arguments.of(new NumberBalls(Lists.list(three, one, two)), new Result(0, 3))
+            Arguments.of(new NumberBalls(Lists.list(one, two, three)), Result.of(3, 0)),
+            Arguments.of(new NumberBalls(Lists.list(one, four, three)), Result.of(2, 0)),
+            Arguments.of(new NumberBalls(Lists.list(five, two, six)), Result.of(1, 0)),
+            Arguments.of(new NumberBalls(Lists.list(five, four, six)), Result.of(0, 0)),
+            Arguments.of(new NumberBalls(Lists.list(one, five, two)), Result.of(1, 1)),
+            Arguments.of(new NumberBalls(Lists.list(five, three, six)), Result.of(0, 1)),
+            Arguments.of(new NumberBalls(Lists.list(two, one, three)), Result.of(1, 2)),
+            Arguments.of(new NumberBalls(Lists.list(three, four, two)), Result.of(0, 2)),
+            Arguments.of(new NumberBalls(Lists.list(three, one, two)), Result.of(0, 3))
         );
     }
 }
\ No newline at end of file
diff --git a/src/test/java/baseball/domain/ResultTest.java b/src/test/java/baseball/domain/ResultTest.java
index e72a871..1ce5116 100644
--- a/src/test/java/baseball/domain/ResultTest.java
+++ b/src/test/java/baseball/domain/ResultTest.java
@@ -11,7 +11,7 @@ class ResultTest {
     @ParameterizedTest
     @CsvSource(value = {"0, 0", "1, 2", "2, 1", "3, 0", "0, 3"})
     void createTest(int strikeCount, int ballCount) {
-        assertThatCode(() -> new Result(strikeCount, ballCount))
+        assertThatCode(() -> Result.of(strikeCount, ballCount))
             .doesNotThrowAnyException();
     }
 
@@ -19,7 +19,7 @@ void createTest(int strikeCount, int ballCount) {
     @ParameterizedTest
     @CsvSource(value = {"-1, 0", "0, 4", "-1, 4", "1, 3"})
     void create_fail_when_invalid_count_include(int strikeCount, int ballCount) {
-        assertThatThrownBy(() -> new Result(strikeCount, ballCount))
+        assertThatThrownBy(() -> Result.of(strikeCount, ballCount))
             .isInstanceOf(IllegalArgumentException.class);
     }
 
@@ -27,7 +27,7 @@ void create_fail_when_invalid_count_include(int strikeCount, int ballCount) {
     @ParameterizedTest
     @CsvSource(value = {"3, true", "2, false"})
     void isAllStrikeTest(int strikeCount, boolean isAllStrike) {
-        Result result = new Result(strikeCount, 0);
+        Result result = Result.of(strikeCount, 0);
         assertThat(result.isAllStrike()).isEqualTo(isAllStrike);
     }
 }
\ No newline at end of file

From dde588a4a9b25926f70ac77111a91be846c87ea8 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 23:16:08 +0900
Subject: [PATCH 16/24] =?UTF-8?q?refactor:=20=EB=A7=A4=EA=B0=9C=EB=B3=80?=
 =?UTF-8?q?=EC=88=98,=20=EC=A7=80=EC=97=AD=EB=B3=80=EC=88=98=20final=20?=
 =?UTF-8?q?=ED=82=A4=EC=9B=8C=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

---
 .../baseball/BaseBallMainApplication.java     | 14 +++++-----
 src/main/java/baseball/domain/Count.java      | 10 +++----
 .../domain/ManualNumberBallsFactory.java      | 17 ++++++++---
 src/main/java/baseball/domain/NumberBall.java |  6 ++--
 .../java/baseball/domain/NumberBalls.java     | 28 +++++++++----------
 .../java/baseball/domain/PlayerChoice.java    |  4 +--
 src/main/java/baseball/domain/Result.java     | 10 +++++--
 src/main/java/baseball/view/InputView.java    | 11 +++++---
 src/main/java/baseball/view/OutputView.java   |  6 ++--
 .../java/baseball/domain/NumberBallsTest.java | 28 +++++++++----------
 10 files changed, 75 insertions(+), 59 deletions(-)

diff --git a/src/main/java/baseball/BaseBallMainApplication.java b/src/main/java/baseball/BaseBallMainApplication.java
index 676028b..2034e45 100644
--- a/src/main/java/baseball/BaseBallMainApplication.java
+++ b/src/main/java/baseball/BaseBallMainApplication.java
@@ -11,18 +11,18 @@
 
 public class BaseBallMainApplication {
     public static void main(String[] args) {
-        NumberBallsFactory numberBallsFactory = new AutoNumberBallsFactory();
+        final NumberBallsFactory numberBallsFactory = new AutoNumberBallsFactory();
         do {
-            NumberBalls computerBalls = numberBallsFactory.generateBalls();
-            inputPlayerBallsWhileAllStrike(computerBalls);
+            final NumberBalls computerBalls = numberBallsFactory.generateBalls();
+            inputNumberWhileAllStrike(computerBalls);
             OutputView.printWinningMessage();
         } while (inputPlayGameAgain().isPlayAgain());
     }
 
-    private static void inputPlayerBallsWhileAllStrike(NumberBalls computerBalls) {
+    private static void inputNumberWhileAllStrike(final NumberBalls computerBalls) {
         while (true) {
-            NumberBalls playerBalls = inputPlayerNumberBalls();
-            Result compute = computerBalls.compute(playerBalls);
+            final NumberBalls playerBalls = inputPlayerNumberBalls();
+            final Result compute = computerBalls.compute(playerBalls);
             OutputView.printCompareResult(compute);
             if (compute.isAllStrike()) {
                 break;
@@ -33,7 +33,7 @@ private static void inputPlayerBallsWhileAllStrike(NumberBalls computerBalls) {
     private static NumberBalls inputPlayerNumberBalls() {
         while (true) {
             try {
-                NumberBallsFactory manualNumberBallsFactory = new ManualNumberBallsFactory(
+                final NumberBallsFactory manualNumberBallsFactory = new ManualNumberBallsFactory(
                     InputView.inputBaseBallNumbers());
                 return manualNumberBallsFactory.generateBalls();
             } catch (IllegalArgumentException e) {
diff --git a/src/main/java/baseball/domain/Count.java b/src/main/java/baseball/domain/Count.java
index d564a9e..b73f03a 100644
--- a/src/main/java/baseball/domain/Count.java
+++ b/src/main/java/baseball/domain/Count.java
@@ -20,29 +20,29 @@ public final class Count {
 
     private final int value;
 
-    private Count(int value) {
+    private Count(final int value) {
         verifyCountValue(value);
         this.value = value;
     }
 
-    private void verifyCountValue(int value) {
+    private void verifyCountValue(final int value) {
         if (value < MIN_COUNT_VALUE || value > MAX_COUNT_VALUE) {
             throw new IllegalArgumentException(INVALID_COUNT_VALUE_BOUNDARY_EXCEPTION_MESSAGE);
         }
     }
 
-    public static Count of(int value) {
+    public static Count of(final int value) {
         if (COUNT_CACHE.containsKey(value)) {
             return COUNT_CACHE.get(value);
         }
         throw new IllegalArgumentException(INVALID_COUNT_VALUE_BOUNDARY_EXCEPTION_MESSAGE);
     }
 
-    public boolean isSameValue(int countValue) {
+    public boolean isSameValue(final int countValue) {
         return this.value == countValue;
     }
 
-    public boolean isSumOfValueGreaterThanMax(Count otherCount) {
+    public boolean isSumOfValueGreaterThanMax(final Count otherCount) {
         return (this.value + otherCount.value) > NumberBalls.BALL_NUMBER_LENGTH;
     }
 
diff --git a/src/main/java/baseball/domain/ManualNumberBallsFactory.java b/src/main/java/baseball/domain/ManualNumberBallsFactory.java
index e2cb941..8e3de28 100644
--- a/src/main/java/baseball/domain/ManualNumberBallsFactory.java
+++ b/src/main/java/baseball/domain/ManualNumberBallsFactory.java
@@ -8,16 +8,25 @@ public class ManualNumberBallsFactory implements NumberBallsFactory {
     private static final int EXTRACT_COMPLETE_CRITERIA = 0;
     private static final int EXTRACT_BALL_NUMBER_DIVIDER = 10;
 
+    private static final String NEGATIVE_NUMBER_EXCEPTION_MESSAGE = "음수는 허용되지 않습니다.";
+
     private final int number;
 
-    public ManualNumberBallsFactory(int number) {
+    public ManualNumberBallsFactory(final int number) {
+        validateNumber(number);
         this.number = number;
     }
 
+    private void validateNumber(final int number) {
+        if (number < EXTRACT_COMPLETE_CRITERIA) {
+            throw new IllegalArgumentException(NEGATIVE_NUMBER_EXCEPTION_MESSAGE);
+        }
+    }
+
     @Override
     public NumberBalls generateBalls() {
-        List<NumberBall> result = new ArrayList<>();
-        Stack<NumberBall> numberBalls = extractNumberBalls();
+        final List<NumberBall> result = new ArrayList<>();
+        final Stack<NumberBall> numberBalls = extractNumberBalls();
         while (!numberBalls.empty()) {
             result.add(numberBalls.pop());
         }
@@ -25,7 +34,7 @@ public NumberBalls generateBalls() {
     }
 
     private Stack<NumberBall> extractNumberBalls() {
-        Stack<NumberBall> numberBallStack = new Stack<>();
+        final Stack<NumberBall> numberBallStack = new Stack<>();
         int num = number;
         while (num > EXTRACT_COMPLETE_CRITERIA) {
             numberBallStack.push(NumberBall.of(num % EXTRACT_BALL_NUMBER_DIVIDER));
diff --git a/src/main/java/baseball/domain/NumberBall.java b/src/main/java/baseball/domain/NumberBall.java
index 96f6e61..185b056 100644
--- a/src/main/java/baseball/domain/NumberBall.java
+++ b/src/main/java/baseball/domain/NumberBall.java
@@ -19,18 +19,18 @@ public final class NumberBall {
 
     private final int value;
 
-    private NumberBall(int value) {
+    private NumberBall(final int value) {
         verifyNumberBall(value);
         this.value = value;
     }
 
-    private void verifyNumberBall(int value) {
+    private void verifyNumberBall(final int value) {
         if (value < MIN_VALUE || value > MAX_VALUE) {
             throw new IllegalArgumentException(INVALID_BALL_NUMBER_BOUNDARY_EXCEPTION_MESSAGE);
         }
     }
 
-    public static NumberBall of(int value) {
+    public static NumberBall of(final int value) {
         if (BALL_CACHE.containsKey(value)) {
             return BALL_CACHE.get(value);
         }
diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
index 7cf94b0..86aa1b5 100644
--- a/src/main/java/baseball/domain/NumberBalls.java
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -21,38 +21,38 @@ public NumberBalls(final List<NumberBall> balls) {
         this.balls = Collections.unmodifiableList(new ArrayList<>(balls));
     }
 
-    private void verifyArgument(List<NumberBall> balls) {
+    private void verifyArgument(final List<NumberBall> balls) {
         verifyNonNull(balls);
         verifyNoContainsDuplicateBall(balls);
         verifyLength(balls);
     }
 
-    private void verifyNonNull(List<NumberBall> balls) {
+    private void verifyNonNull(final List<NumberBall> balls) {
         if (Objects.isNull(balls)) {
             throw new IllegalArgumentException(NULL_ARGUMENT_EXCEPTION_MESSAGE);
         }
     }
 
-    private void verifyNoContainsDuplicateBall(List<NumberBall> balls) {
-        Set<NumberBall> numberBalls = new HashSet<>(balls);
+    private void verifyNoContainsDuplicateBall(final List<NumberBall> balls) {
+        final Set<NumberBall> numberBalls = new HashSet<>(balls);
         if (balls.size() != numberBalls.size()) {
             throw new IllegalArgumentException(DUPLICATE_NUMBER_CONTAINS_EXCEPTION_MESSAGE);
         }
     }
 
-    private void verifyLength(List<NumberBall> balls) {
+    private void verifyLength(final List<NumberBall> balls) {
         if (balls.size() != BALL_NUMBER_LENGTH) {
             throw new IllegalArgumentException(INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE);
         }
     }
 
-    public Result compute(NumberBalls otherBalls) {
-        int strikeCount = computeStrike(otherBalls);
-        int ballCount = computeBall(otherBalls, strikeCount);
+    public Result compute(final NumberBalls otherBalls) {
+        final int strikeCount = computeStrike(otherBalls);
+        final int ballCount = computeBall(otherBalls, strikeCount);
         return Result.of(strikeCount, ballCount);
     }
 
-    private int computeStrike(NumberBalls comparer) {
+    private int computeStrike(final NumberBalls comparer) {
         int strikeCount = 0;
         for (int i = 0; i < this.balls.size(); i++) {
             if (this.balls.get(i).equals(comparer.balls.get(i))) {
@@ -62,14 +62,14 @@ private int computeStrike(NumberBalls comparer) {
         return strikeCount;
     }
 
-    private int computeBall(NumberBalls otherBalls, int strikeCount) {
-        int ballCandidateCount = getBallCandidateCount(otherBalls);
+    private int computeBall(final NumberBalls otherBalls, final int strikeCount) {
+        final int ballCandidateCount = getBallCandidateCount(otherBalls);
         return ballCandidateCount - strikeCount;
     }
 
-    private int getBallCandidateCount(NumberBalls comparer) {
-        List<NumberBall> otherBalls = comparer.balls;
-        Set<NumberBall> distinctNumbers = new HashSet<>(this.balls);
+    private int getBallCandidateCount(final NumberBalls comparer) {
+        final List<NumberBall> otherBalls = comparer.balls;
+        final Set<NumberBall> distinctNumbers = new HashSet<>(this.balls);
         distinctNumbers.addAll(otherBalls);
         return this.balls.size() + otherBalls.size() - distinctNumbers.size();
     }
diff --git a/src/main/java/baseball/domain/PlayerChoice.java b/src/main/java/baseball/domain/PlayerChoice.java
index b9b46cc..15c2f49 100644
--- a/src/main/java/baseball/domain/PlayerChoice.java
+++ b/src/main/java/baseball/domain/PlayerChoice.java
@@ -9,11 +9,11 @@ public enum PlayerChoice {
 
     private final String chooseCode;
 
-    PlayerChoice(String chooseCode) {
+    PlayerChoice(final String chooseCode) {
         this.chooseCode = chooseCode;
     }
 
-    public static PlayerChoice of(String value) {
+    public static PlayerChoice of(final String value) {
         return Arrays.stream(values())
             .filter(playerChoiceValue -> playerChoiceValue.chooseCode.equals(value))
             .findFirst()
diff --git a/src/main/java/baseball/domain/Result.java b/src/main/java/baseball/domain/Result.java
index 21e19a8..230fed9 100644
--- a/src/main/java/baseball/domain/Result.java
+++ b/src/main/java/baseball/domain/Result.java
@@ -5,23 +5,27 @@
 public final class Result {
     private static final String INVALID_TOTAL_COUNT_OF_STRIKE_BALL_EXCEPTION_MESSAGE =
         "스트라이크와 볼의 값의 합이 현재 가능한 값을 넘었습니다.";
+    private static final String NULL_COUNT_EXCEPTION_MESSAGE = "NULL값이 들어갈 수 없습니다.";
 
     private final Count strikeCount;
     private final Count ballCount;
 
-    private Result(Count strikeCount, Count ballCount) {
+    private Result(final Count strikeCount, final Count ballCount) {
         verifyCounts(strikeCount, ballCount);
         this.strikeCount = strikeCount;
         this.ballCount = ballCount;
     }
 
-    private void verifyCounts(Count strikeCount, Count ballCount) {
+    private void verifyCounts(final Count strikeCount, final Count ballCount) {
+        if (Objects.isNull(strikeCount) || Objects.isNull(ballCount)) {
+            throw new IllegalArgumentException(NULL_COUNT_EXCEPTION_MESSAGE);
+        }
         if (strikeCount.isSumOfValueGreaterThanMax(ballCount)) {
             throw new IllegalArgumentException(INVALID_TOTAL_COUNT_OF_STRIKE_BALL_EXCEPTION_MESSAGE);
         }
     }
 
-    public static Result of(int strikeCount, int ballCount) {
+    public static Result of(final int strikeCount, final int ballCount) {
         return new Result(Count.of(strikeCount), Count.of(ballCount));
     }
 
diff --git a/src/main/java/baseball/view/InputView.java b/src/main/java/baseball/view/InputView.java
index 9e2644a..1a46b0b 100644
--- a/src/main/java/baseball/view/InputView.java
+++ b/src/main/java/baseball/view/InputView.java
@@ -4,22 +4,25 @@
 
 public class InputView {
     private static final Scanner SCANNER = new Scanner(System.in);
+    private static final String NON_NUMBER_INPUT_EXCEPTION_MESSAGE = "숫자 외의 값은 입력 받을 수 없습니다.";
+    private static final String INPUT_PLAY_AGAIN_INTRO_MESSAGE = "게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.: ";
+    private static final String INPUT_BASEBALL_NUMBER_INTRO_MESSAGE = "숫자를 입력해주세요 : ";
 
     public static Integer inputBaseBallNumbers() {
-        System.out.print("숫자를 입력해주세요 : ");
+        System.out.print(INPUT_BASEBALL_NUMBER_INTRO_MESSAGE);
         return parseInt(SCANNER.next());
     }
 
-    private static Integer parseInt(String inputValue) {
+    private static Integer parseInt(final String inputValue) {
         try {
             return Integer.parseInt(inputValue);
         } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("숫자 외의 값은 입력 받을 수 없습니다.");
+            throw new IllegalArgumentException(NON_NUMBER_INPUT_EXCEPTION_MESSAGE);
         }
     }
 
     public static String inputPlayAgain() {
-        System.out.print("게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.: ");
+        System.out.print(INPUT_PLAY_AGAIN_INTRO_MESSAGE);
         return SCANNER.next();
     }
 }
diff --git a/src/main/java/baseball/view/OutputView.java b/src/main/java/baseball/view/OutputView.java
index 2458795..d7a125a 100644
--- a/src/main/java/baseball/view/OutputView.java
+++ b/src/main/java/baseball/view/OutputView.java
@@ -4,9 +4,9 @@
 import baseball.domain.Result;
 
 public class OutputView {
-    public static void printCompareResult(Result compute) {
-        Count strikeCount = compute.getStrikeCount();
-        Count ballCount = compute.getBallCount();
+    public static void printCompareResult(final Result compute) {
+        final Count strikeCount = compute.getStrikeCount();
+        final Count ballCount = compute.getBallCount();
         System.out.printf("%d 스트라이크, %d 볼\n", strikeCount.getValue(), ballCount.getValue());
     }
 
diff --git a/src/test/java/baseball/domain/NumberBallsTest.java b/src/test/java/baseball/domain/NumberBallsTest.java
index 59fdbf1..c612ba5 100644
--- a/src/test/java/baseball/domain/NumberBallsTest.java
+++ b/src/test/java/baseball/domain/NumberBallsTest.java
@@ -1,10 +1,10 @@
 package baseball.domain;
 
 import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.util.Lists.*;
 
 import java.util.stream.Stream;
 
-import org.assertj.core.util.Lists;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -27,7 +27,7 @@ void setUp() {
     @DisplayName("중복이 없고, NumberBall를 3개 입력 받는 경우 NumberBalls 생성이 된다.")
     @Test
     void create_test() {
-        assertThatCode(() -> new NumberBalls(Lists.list(numberOne, numberTwo, numberThree)))
+        assertThatCode(() -> new NumberBalls(list(numberOne, numberTwo, numberThree)))
             .doesNotThrowAnyException();
     }
 
@@ -35,7 +35,7 @@ void create_test() {
     @Test
     void create_exception_when_contains_duplicate_number() {
         NumberBall sameBallWithFirstBall = numberOne;
-        assertThatThrownBy(() -> new NumberBalls(Lists.list(numberOne, numberTwo, sameBallWithFirstBall)))
+        assertThatThrownBy(() -> new NumberBalls(list(numberOne, numberTwo, sameBallWithFirstBall)))
             .isInstanceOf(IllegalArgumentException.class);
     }
 
@@ -44,7 +44,7 @@ void create_exception_when_contains_duplicate_number() {
     void create_exception_when_balls_size_is_invalid() {
         NumberBall firstNumber = NumberBall.of(1);
         NumberBall secondNumber = NumberBall.of(2);
-        assertThatThrownBy(() -> new NumberBalls(Lists.list(firstNumber, secondNumber)))
+        assertThatThrownBy(() -> new NumberBalls(list(firstNumber, secondNumber)))
             .isInstanceOf(IllegalArgumentException.class);
     }
 
@@ -52,7 +52,7 @@ void create_exception_when_balls_size_is_invalid() {
     @ParameterizedTest
     @MethodSource("getPlayerBallsAndResultSet")
     void compute_baseball_result(NumberBalls playerBalls, Result gameResult) {
-        NumberBalls computerBalls = new NumberBalls(Lists.list(numberOne, numberTwo, numberThree));
+        NumberBalls computerBalls = new NumberBalls(list(numberOne, numberTwo, numberThree));
         assertThat(computerBalls.compute(playerBalls)).isEqualTo(gameResult);
     }
 
@@ -65,15 +65,15 @@ private static Stream<Arguments> getPlayerBallsAndResultSet() {
         NumberBall six = NumberBall.of(6);
 
         return Stream.of(
-            Arguments.of(new NumberBalls(Lists.list(one, two, three)), Result.of(3, 0)),
-            Arguments.of(new NumberBalls(Lists.list(one, four, three)), Result.of(2, 0)),
-            Arguments.of(new NumberBalls(Lists.list(five, two, six)), Result.of(1, 0)),
-            Arguments.of(new NumberBalls(Lists.list(five, four, six)), Result.of(0, 0)),
-            Arguments.of(new NumberBalls(Lists.list(one, five, two)), Result.of(1, 1)),
-            Arguments.of(new NumberBalls(Lists.list(five, three, six)), Result.of(0, 1)),
-            Arguments.of(new NumberBalls(Lists.list(two, one, three)), Result.of(1, 2)),
-            Arguments.of(new NumberBalls(Lists.list(three, four, two)), Result.of(0, 2)),
-            Arguments.of(new NumberBalls(Lists.list(three, one, two)), Result.of(0, 3))
+            Arguments.of(new NumberBalls(list(one, two, three)), Result.of(3, 0)),
+            Arguments.of(new NumberBalls(list(one, four, three)), Result.of(2, 0)),
+            Arguments.of(new NumberBalls(list(five, two, six)), Result.of(1, 0)),
+            Arguments.of(new NumberBalls(list(five, four, six)), Result.of(0, 0)),
+            Arguments.of(new NumberBalls(list(one, five, two)), Result.of(1, 1)),
+            Arguments.of(new NumberBalls(list(five, three, six)), Result.of(0, 1)),
+            Arguments.of(new NumberBalls(list(two, one, three)), Result.of(1, 2)),
+            Arguments.of(new NumberBalls(list(three, four, two)), Result.of(0, 2)),
+            Arguments.of(new NumberBalls(list(three, one, two)), Result.of(0, 3))
         );
     }
 }
\ No newline at end of file

From 2b728bde73b04a0e26cd6bfc6b4cdb61b61efd0c Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 23:42:39 +0900
Subject: [PATCH 17/24] =?UTF-8?q?refactor:=20=EA=B2=8C=EC=9E=84=20?=
 =?UTF-8?q?=EA=B2=B0=EA=B3=BC=EC=97=90=20=EB=94=B0=EB=9D=BC=20=EC=8A=A4?=
 =?UTF-8?q?=ED=8A=B8=EB=9D=BC=EC=9D=B4=ED=81=AC,=20=EB=B3=BC,=20=EB=82=AB?=
 =?UTF-8?q?=EC=8B=B1=20=EC=B6=9C=EB=A0=A5=ED=95=98=EB=8F=84=EB=A1=9D=20?=
 =?UTF-8?q?=EB=B3=80=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/baseball/view/OutputView.java | 46 +++++++++++++++++++--
 1 file changed, 42 insertions(+), 4 deletions(-)

diff --git a/src/main/java/baseball/view/OutputView.java b/src/main/java/baseball/view/OutputView.java
index d7a125a..ed63d08 100644
--- a/src/main/java/baseball/view/OutputView.java
+++ b/src/main/java/baseball/view/OutputView.java
@@ -4,13 +4,51 @@
 import baseball.domain.Result;
 
 public class OutputView {
+    private static final String STRIKE_MESSAGE = "스트라이크";
+    private static final String BALL_MESSAGE = "볼";
+    private static final String NOTHING_MESSAGE = "낫싱";
+    private static final String GAME_END_MESSAGE = "3개의 숫자를 모두 맞혔습니다. 게임종료.";
+
+    private static final String SPLITTER = ", ";
+    private static final String LINE_SEPARATOR = System.lineSeparator();
+
     public static void printCompareResult(final Result compute) {
-        final Count strikeCount = compute.getStrikeCount();
-        final Count ballCount = compute.getBallCount();
-        System.out.printf("%d 스트라이크, %d 볼\n", strikeCount.getValue(), ballCount.getValue());
+        final Count strike = compute.getStrikeCount();
+        final Count ball = compute.getBallCount();
+        if (isNothing(strike, ball)) {
+            System.out.println(NOTHING_MESSAGE);
+            return;
+        }
+        printResultWithAnyMatchingInfo(strike, ball);
+    }
+
+    private static boolean isNothing(final Count strike, final Count ball) {
+        return strike.getValue() == 0 && ball.getValue() == 0;
+    }
+
+    private static void printResultWithAnyMatchingInfo(final Count strike, final Count ball) {
+        final StringBuilder result = new StringBuilder();
+        appendMessageIfValueExists(result, strike.getValue(), STRIKE_MESSAGE);
+        appendCommaIfAllResultExists(result, strike.getValue(), ball.getValue());
+        appendMessageIfValueExists(result, ball.getValue(), BALL_MESSAGE);
+        result.append(LINE_SEPARATOR);
+        System.out.print(result);
+    }
+
+    private static void appendCommaIfAllResultExists(final StringBuilder result, final int strike, final int ball) {
+        if (strike * ball != 0) {
+            result.append(SPLITTER);
+        }
+    }
+
+    private static void appendMessageIfValueExists(final StringBuilder result, final int value, final String message) {
+        if (value != 0) {
+            result.append(value);
+            result.append(message);
+        }
     }
 
     public static void printWinningMessage() {
-        System.out.println("3개의 숫자를 모두 맞혔습니다. 게임종료.");
+        System.out.println(GAME_END_MESSAGE);
     }
 }

From 913c7439258ec2814ffca01e061009788b43df02 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 23:44:01 +0900
Subject: [PATCH 18/24] =?UTF-8?q?refactor:=20=EC=88=AB=EC=9E=90=20?=
 =?UTF-8?q?=EB=AA=A9=EB=A1=9D=20=EC=83=9D=EC=84=B1=EA=B8=B0=20factory=20->?=
 =?UTF-8?q?=20=20generator=EB=A1=9C=20=EB=B3=80=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/baseball/BaseBallMainApplication.java  | 12 ++++++------
 ...llsFactory.java => AutoNumberBallsGenerator.java} |  4 ++--
 .../baseball/domain/ManualNumberBallsFactory.java    |  2 +-
 ...erBallsFactory.java => NumberBallsGenerator.java} |  2 +-
 ...ryTest.java => AutoNumberBallsGeneratorTest.java} | 10 +++++-----
 ...Test.java => ManualNumberBallsGeneratorTest.java} | 10 +++++-----
 6 files changed, 20 insertions(+), 20 deletions(-)
 rename src/main/java/baseball/domain/{AutoNumberBallsFactory.java => AutoNumberBallsGenerator.java} (85%)
 rename src/main/java/baseball/domain/{NumberBallsFactory.java => NumberBallsGenerator.java} (60%)
 rename src/test/java/baseball/domain/{AutoNumberBallsFactoryTest.java => AutoNumberBallsGeneratorTest.java} (50%)
 rename src/test/java/baseball/domain/{ManualNumberBallsFactoryTest.java => ManualNumberBallsGeneratorTest.java} (68%)

diff --git a/src/main/java/baseball/BaseBallMainApplication.java b/src/main/java/baseball/BaseBallMainApplication.java
index 2034e45..2cfbbd7 100644
--- a/src/main/java/baseball/BaseBallMainApplication.java
+++ b/src/main/java/baseball/BaseBallMainApplication.java
@@ -1,9 +1,9 @@
 package baseball;
 
-import baseball.domain.AutoNumberBallsFactory;
+import baseball.domain.AutoNumberBallsGenerator;
 import baseball.domain.ManualNumberBallsFactory;
 import baseball.domain.NumberBalls;
-import baseball.domain.NumberBallsFactory;
+import baseball.domain.NumberBallsGenerator;
 import baseball.domain.PlayerChoice;
 import baseball.domain.Result;
 import baseball.view.InputView;
@@ -11,9 +11,9 @@
 
 public class BaseBallMainApplication {
     public static void main(String[] args) {
-        final NumberBallsFactory numberBallsFactory = new AutoNumberBallsFactory();
+        final NumberBallsGenerator numberBallsGenerator = new AutoNumberBallsGenerator();
         do {
-            final NumberBalls computerBalls = numberBallsFactory.generateBalls();
+            final NumberBalls computerBalls = numberBallsGenerator.generateBalls();
             inputNumberWhileAllStrike(computerBalls);
             OutputView.printWinningMessage();
         } while (inputPlayGameAgain().isPlayAgain());
@@ -33,9 +33,9 @@ private static void inputNumberWhileAllStrike(final NumberBalls computerBalls) {
     private static NumberBalls inputPlayerNumberBalls() {
         while (true) {
             try {
-                final NumberBallsFactory manualNumberBallsFactory = new ManualNumberBallsFactory(
+                final NumberBallsGenerator manualNumberBallsGenerator = new ManualNumberBallsFactory(
                     InputView.inputBaseBallNumbers());
-                return manualNumberBallsFactory.generateBalls();
+                return manualNumberBallsGenerator.generateBalls();
             } catch (IllegalArgumentException e) {
                 System.out.println(e.getMessage());
             }
diff --git a/src/main/java/baseball/domain/AutoNumberBallsFactory.java b/src/main/java/baseball/domain/AutoNumberBallsGenerator.java
similarity index 85%
rename from src/main/java/baseball/domain/AutoNumberBallsFactory.java
rename to src/main/java/baseball/domain/AutoNumberBallsGenerator.java
index 91cdc80..22d0923 100644
--- a/src/main/java/baseball/domain/AutoNumberBallsFactory.java
+++ b/src/main/java/baseball/domain/AutoNumberBallsGenerator.java
@@ -4,12 +4,12 @@
 import java.util.Collections;
 import java.util.List;
 
-public class AutoNumberBallsFactory implements NumberBallsFactory {
+public class AutoNumberBallsGenerator implements NumberBallsGenerator {
     private static final int BALLS_FIRST_INDEX = 0;
 
     private final List<NumberBall> allDistinctNumbers = new ArrayList<>();
 
-    public AutoNumberBallsFactory() {
+    public AutoNumberBallsGenerator() {
         init();
     }
 
diff --git a/src/main/java/baseball/domain/ManualNumberBallsFactory.java b/src/main/java/baseball/domain/ManualNumberBallsFactory.java
index 8e3de28..172afdb 100644
--- a/src/main/java/baseball/domain/ManualNumberBallsFactory.java
+++ b/src/main/java/baseball/domain/ManualNumberBallsFactory.java
@@ -4,7 +4,7 @@
 import java.util.List;
 import java.util.Stack;
 
-public class ManualNumberBallsFactory implements NumberBallsFactory {
+public class ManualNumberBallsFactory implements NumberBallsGenerator {
     private static final int EXTRACT_COMPLETE_CRITERIA = 0;
     private static final int EXTRACT_BALL_NUMBER_DIVIDER = 10;
 
diff --git a/src/main/java/baseball/domain/NumberBallsFactory.java b/src/main/java/baseball/domain/NumberBallsGenerator.java
similarity index 60%
rename from src/main/java/baseball/domain/NumberBallsFactory.java
rename to src/main/java/baseball/domain/NumberBallsGenerator.java
index 6d43392..465cfbd 100644
--- a/src/main/java/baseball/domain/NumberBallsFactory.java
+++ b/src/main/java/baseball/domain/NumberBallsGenerator.java
@@ -1,5 +1,5 @@
 package baseball.domain;
 
-public interface NumberBallsFactory {
+public interface NumberBallsGenerator {
     NumberBalls generateBalls();
 }
diff --git a/src/test/java/baseball/domain/AutoNumberBallsFactoryTest.java b/src/test/java/baseball/domain/AutoNumberBallsGeneratorTest.java
similarity index 50%
rename from src/test/java/baseball/domain/AutoNumberBallsFactoryTest.java
rename to src/test/java/baseball/domain/AutoNumberBallsGeneratorTest.java
index 0384b57..d2b8617 100644
--- a/src/test/java/baseball/domain/AutoNumberBallsFactoryTest.java
+++ b/src/test/java/baseball/domain/AutoNumberBallsGeneratorTest.java
@@ -5,17 +5,17 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
-class AutoNumberBallsFactoryTest {
+class AutoNumberBallsGeneratorTest {
     @DisplayName("숫자목록 자동 생성시 예외 발생 없이 숫자목록 객체가 정상 생성 된다.")
     @Test
     void generatingTest() {
-        NumberBallsFactory numberBallsFactory = new AutoNumberBallsFactory();
-        assertThatCode(() -> generateNumberByAuto(numberBallsFactory, 500)).doesNotThrowAnyException();
+        NumberBallsGenerator numberBallsGenerator = new AutoNumberBallsGenerator();
+        assertThatCode(() -> generateNumberByAuto(numberBallsGenerator, 500)).doesNotThrowAnyException();
     }
 
-    private void generateNumberByAuto(NumberBallsFactory numberBallsFactory, int times) {
+    private void generateNumberByAuto(NumberBallsGenerator numberBallsGenerator, int times) {
         for (int i = 0; i < times; i++) {
-            numberBallsFactory.generateBalls();
+            numberBallsGenerator.generateBalls();
         }
     }
 }
\ No newline at end of file
diff --git a/src/test/java/baseball/domain/ManualNumberBallsFactoryTest.java b/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
similarity index 68%
rename from src/test/java/baseball/domain/ManualNumberBallsFactoryTest.java
rename to src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
index 22a6511..9c6d996 100644
--- a/src/test/java/baseball/domain/ManualNumberBallsFactoryTest.java
+++ b/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
@@ -8,12 +8,12 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
-class ManualNumberBallsFactoryTest {
+class ManualNumberBallsGeneratorTest {
     @DisplayName("중복이 없고 0이 포함되지 않은 세자리의 자연수를 숫자 목록 객체로 생성한다.")
     @Test
     void generateBalls_test() {
-        NumberBallsFactory numberBallsFactory = new ManualNumberBallsFactory(321);
-        assertThat(numberBallsFactory.generateBalls())
+        NumberBallsGenerator numberBallsGenerator = new ManualNumberBallsFactory(321);
+        assertThat(numberBallsGenerator.generateBalls())
             .isEqualTo(new NumberBalls(Lists.list(NumberBall.of(3), NumberBall.of(2), NumberBall.of(1))));
     }
 
@@ -21,7 +21,7 @@ void generateBalls_test() {
     @ParameterizedTest
     @ValueSource(ints = {333, 1234, 75, -152, -10})
     void generateBalls_test_fail(int value) {
-        NumberBallsFactory numberBallsFactory = new ManualNumberBallsFactory(value);
-        assertThatThrownBy(numberBallsFactory::generateBalls).isInstanceOf(IllegalArgumentException.class);
+        NumberBallsGenerator numberBallsGenerator = new ManualNumberBallsFactory(value);
+        assertThatThrownBy(numberBallsGenerator::generateBalls).isInstanceOf(IllegalArgumentException.class);
     }
 }
\ No newline at end of file

From a45e753cc6e26ed7f811fc3d417f480689b23c2c Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 23:47:57 +0900
Subject: [PATCH 19/24] =?UTF-8?q?refactor:=20=EC=98=88=EC=99=B8=EB=A9=94?=
 =?UTF-8?q?=EC=8B=9C=EC=A7=80=20=EC=B6=9C=EB=A0=A5=20=EA=B8=B0=EB=8A=A5=20?=
 =?UTF-8?q?output=20view=20=ED=81=B4=EB=9E=98=EC=8A=A4=20=EC=9C=84?=
 =?UTF-8?q?=EC=9E=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/baseball/BaseBallMainApplication.java | 18 +++++++++---------
 src/main/java/baseball/view/OutputView.java    |  4 ++++
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/main/java/baseball/BaseBallMainApplication.java b/src/main/java/baseball/BaseBallMainApplication.java
index 2cfbbd7..17644ad 100644
--- a/src/main/java/baseball/BaseBallMainApplication.java
+++ b/src/main/java/baseball/BaseBallMainApplication.java
@@ -11,9 +11,9 @@
 
 public class BaseBallMainApplication {
     public static void main(String[] args) {
-        final NumberBallsGenerator numberBallsGenerator = new AutoNumberBallsGenerator();
+        final NumberBallsGenerator autoGenerator = new AutoNumberBallsGenerator();
         do {
-            final NumberBalls computerBalls = numberBallsGenerator.generateBalls();
+            final NumberBalls computerBalls = autoGenerator.generateBalls();
             inputNumberWhileAllStrike(computerBalls);
             OutputView.printWinningMessage();
         } while (inputPlayGameAgain().isPlayAgain());
@@ -22,9 +22,9 @@ public static void main(String[] args) {
     private static void inputNumberWhileAllStrike(final NumberBalls computerBalls) {
         while (true) {
             final NumberBalls playerBalls = inputPlayerNumberBalls();
-            final Result compute = computerBalls.compute(playerBalls);
-            OutputView.printCompareResult(compute);
-            if (compute.isAllStrike()) {
+            final Result computeResult = computerBalls.compute(playerBalls);
+            OutputView.printCompareResult(computeResult);
+            if (computeResult.isAllStrike()) {
                 break;
             }
         }
@@ -33,11 +33,11 @@ private static void inputNumberWhileAllStrike(final NumberBalls computerBalls) {
     private static NumberBalls inputPlayerNumberBalls() {
         while (true) {
             try {
-                final NumberBallsGenerator manualNumberBallsGenerator = new ManualNumberBallsFactory(
+                final NumberBallsGenerator manualBallsGenerator = new ManualNumberBallsFactory(
                     InputView.inputBaseBallNumbers());
-                return manualNumberBallsGenerator.generateBalls();
+                return manualBallsGenerator.generateBalls();
             } catch (IllegalArgumentException e) {
-                System.out.println(e.getMessage());
+                OutputView.printErrorMessage(e);
             }
         }
     }
@@ -47,7 +47,7 @@ private static PlayerChoice inputPlayGameAgain() {
             try {
                 return PlayerChoice.of(InputView.inputPlayAgain());
             } catch (IllegalArgumentException e) {
-                System.out.println(e.getMessage());
+                OutputView.printErrorMessage(e);
             }
         }
     }
diff --git a/src/main/java/baseball/view/OutputView.java b/src/main/java/baseball/view/OutputView.java
index ed63d08..34be3af 100644
--- a/src/main/java/baseball/view/OutputView.java
+++ b/src/main/java/baseball/view/OutputView.java
@@ -51,4 +51,8 @@ private static void appendMessageIfValueExists(final StringBuilder result, final
     public static void printWinningMessage() {
         System.out.println(GAME_END_MESSAGE);
     }
+
+    public static void printErrorMessage(final Exception e) {
+        System.out.println(e.getMessage());
+    }
 }

From e048b8afa0471e60a0dce247802ddab59c141f60 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 23:54:58 +0900
Subject: [PATCH 20/24] =?UTF-8?q?refactor:=20=EB=A7=A4=EC=A7=81=EB=84=98?=
 =?UTF-8?q?=EB=B2=84=20=EC=B6=94=EC=B6=9C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/baseball/domain/NumberBalls.java | 7 ++++---
 src/main/java/baseball/view/OutputView.java    | 8 +++++---
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
index 86aa1b5..a3d8550 100644
--- a/src/main/java/baseball/domain/NumberBalls.java
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -9,6 +9,7 @@
 
 public final class NumberBalls {
     static final int BALL_NUMBER_LENGTH = 3;
+    private static final int DEFAULT_STRIKE_COUNT = 0;
 
     private static final String INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE = "입력 값이 유효하지 않습니다.";
     private static final String DUPLICATE_NUMBER_CONTAINS_EXCEPTION_MESSAGE = "중복된 값은 들어갈 수 없습니다.";
@@ -17,11 +18,11 @@ public final class NumberBalls {
     private final List<NumberBall> balls;
 
     public NumberBalls(final List<NumberBall> balls) {
-        verifyArgument(balls);
+        verifyBalls(balls);
         this.balls = Collections.unmodifiableList(new ArrayList<>(balls));
     }
 
-    private void verifyArgument(final List<NumberBall> balls) {
+    private void verifyBalls(final List<NumberBall> balls) {
         verifyNonNull(balls);
         verifyNoContainsDuplicateBall(balls);
         verifyLength(balls);
@@ -53,7 +54,7 @@ public Result compute(final NumberBalls otherBalls) {
     }
 
     private int computeStrike(final NumberBalls comparer) {
-        int strikeCount = 0;
+        int strikeCount = DEFAULT_STRIKE_COUNT;
         for (int i = 0; i < this.balls.size(); i++) {
             if (this.balls.get(i).equals(comparer.balls.get(i))) {
                 strikeCount++;
diff --git a/src/main/java/baseball/view/OutputView.java b/src/main/java/baseball/view/OutputView.java
index 34be3af..9cd170a 100644
--- a/src/main/java/baseball/view/OutputView.java
+++ b/src/main/java/baseball/view/OutputView.java
@@ -4,6 +4,8 @@
 import baseball.domain.Result;
 
 public class OutputView {
+    private static final int NOT_EXIST_VALUE = 0;
+
     private static final String STRIKE_MESSAGE = "스트라이크";
     private static final String BALL_MESSAGE = "볼";
     private static final String NOTHING_MESSAGE = "낫싱";
@@ -23,7 +25,7 @@ public static void printCompareResult(final Result compute) {
     }
 
     private static boolean isNothing(final Count strike, final Count ball) {
-        return strike.getValue() == 0 && ball.getValue() == 0;
+        return strike.getValue() == NOT_EXIST_VALUE && ball.getValue() == NOT_EXIST_VALUE;
     }
 
     private static void printResultWithAnyMatchingInfo(final Count strike, final Count ball) {
@@ -36,13 +38,13 @@ private static void printResultWithAnyMatchingInfo(final Count strike, final Cou
     }
 
     private static void appendCommaIfAllResultExists(final StringBuilder result, final int strike, final int ball) {
-        if (strike * ball != 0) {
+        if (strike * ball != NOT_EXIST_VALUE) {
             result.append(SPLITTER);
         }
     }
 
     private static void appendMessageIfValueExists(final StringBuilder result, final int value, final String message) {
-        if (value != 0) {
+        if (value != NOT_EXIST_VALUE) {
             result.append(value);
             result.append(message);
         }

From 35d601a327c8ea199f8c2503b6cc0a34df3c53f5 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Sun, 28 Jun 2020 23:58:13 +0900
Subject: [PATCH 21/24] =?UTF-8?q?refactor:=20=ED=95=84=EB=93=9C=EB=AA=85?=
 =?UTF-8?q?=20=EB=B3=80=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/baseball/domain/Result.java   | 28 ++++++++++-----------
 src/main/java/baseball/view/OutputView.java |  4 +--
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/main/java/baseball/domain/Result.java b/src/main/java/baseball/domain/Result.java
index 230fed9..b186946 100644
--- a/src/main/java/baseball/domain/Result.java
+++ b/src/main/java/baseball/domain/Result.java
@@ -7,13 +7,13 @@ public final class Result {
         "스트라이크와 볼의 값의 합이 현재 가능한 값을 넘었습니다.";
     private static final String NULL_COUNT_EXCEPTION_MESSAGE = "NULL값이 들어갈 수 없습니다.";
 
-    private final Count strikeCount;
-    private final Count ballCount;
+    private final Count strike;
+    private final Count ball;
 
-    private Result(final Count strikeCount, final Count ballCount) {
-        verifyCounts(strikeCount, ballCount);
-        this.strikeCount = strikeCount;
-        this.ballCount = ballCount;
+    private Result(final Count strike, final Count ball) {
+        verifyCounts(strike, ball);
+        this.strike = strike;
+        this.ball = ball;
     }
 
     private void verifyCounts(final Count strikeCount, final Count ballCount) {
@@ -30,15 +30,15 @@ public static Result of(final int strikeCount, final int ballCount) {
     }
 
     public boolean isAllStrike() {
-        return strikeCount.isSameValue(NumberBalls.BALL_NUMBER_LENGTH);
+        return strike.isSameValue(NumberBalls.BALL_NUMBER_LENGTH);
     }
 
-    public Count getStrikeCount() {
-        return strikeCount;
+    public Count getStrike() {
+        return strike;
     }
 
-    public Count getBallCount() {
-        return ballCount;
+    public Count getBall() {
+        return ball;
     }
 
     @Override
@@ -48,12 +48,12 @@ public boolean equals(Object o) {
         if (o == null || getClass() != o.getClass())
             return false;
         Result result = (Result)o;
-        return strikeCount == result.strikeCount &&
-            ballCount == result.ballCount;
+        return strike == result.strike &&
+            ball == result.ball;
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(strikeCount, ballCount);
+        return Objects.hash(strike, ball);
     }
 }
diff --git a/src/main/java/baseball/view/OutputView.java b/src/main/java/baseball/view/OutputView.java
index 9cd170a..3feef6c 100644
--- a/src/main/java/baseball/view/OutputView.java
+++ b/src/main/java/baseball/view/OutputView.java
@@ -15,8 +15,8 @@ public class OutputView {
     private static final String LINE_SEPARATOR = System.lineSeparator();
 
     public static void printCompareResult(final Result compute) {
-        final Count strike = compute.getStrikeCount();
-        final Count ball = compute.getBallCount();
+        final Count strike = compute.getStrike();
+        final Count ball = compute.getBall();
         if (isNothing(strike, ball)) {
             System.out.println(NOTHING_MESSAGE);
             return;

From 86493d440f15c827152f6832a60038a997e0d55d Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Mon, 29 Jun 2020 00:09:54 +0900
Subject: [PATCH 22/24] =?UTF-8?q?fix:=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?=
 =?UTF-8?q?=EC=8B=A4=ED=8C=A8=20=EA=B5=AC=EA=B0=84=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../baseball/domain/ManualNumberBallsGeneratorTest.java     | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java b/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
index 9c6d996..d23fa8c 100644
--- a/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
+++ b/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
@@ -21,7 +21,9 @@ void generateBalls_test() {
     @ParameterizedTest
     @ValueSource(ints = {333, 1234, 75, -152, -10})
     void generateBalls_test_fail(int value) {
-        NumberBallsGenerator numberBallsGenerator = new ManualNumberBallsFactory(value);
-        assertThatThrownBy(numberBallsGenerator::generateBalls).isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> {
+            NumberBallsGenerator numberBallsGenerator = new ManualNumberBallsFactory(value);
+            numberBallsGenerator.generateBalls();
+        }).isInstanceOf(IllegalArgumentException.class);
     }
 }
\ No newline at end of file

From 2e4083e6a566bf1a0237b90a132b963ebbc60a07 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Mon, 29 Jun 2020 00:25:01 +0900
Subject: [PATCH 23/24] =?UTF-8?q?refactor:=20=EB=B3=80=EC=88=98,=20?=
 =?UTF-8?q?=ED=81=B4=EB=9E=98=EC=8A=A4=20rename?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../baseball/BaseBallMainApplication.java     | 14 ++++-----
 .../java/baseball/domain/NumberBalls.java     | 30 +++++++++----------
 src/main/java/baseball/domain/Result.java     |  2 +-
 .../{PlayerChoice.java => WhetherReplay.java} | 14 ++++-----
 src/main/java/baseball/view/InputView.java    |  2 +-
 src/test/java/baseball/domain/ResultTest.java |  2 +-
 ...ChoiceTest.java => WhetherReplayTest.java} |  8 ++---
 7 files changed, 36 insertions(+), 36 deletions(-)
 rename src/main/java/baseball/domain/{PlayerChoice.java => WhetherReplay.java} (57%)
 rename src/test/java/baseball/domain/{PlayerChoiceTest.java => WhetherReplayTest.java} (71%)

diff --git a/src/main/java/baseball/BaseBallMainApplication.java b/src/main/java/baseball/BaseBallMainApplication.java
index 17644ad..e273419 100644
--- a/src/main/java/baseball/BaseBallMainApplication.java
+++ b/src/main/java/baseball/BaseBallMainApplication.java
@@ -4,7 +4,7 @@
 import baseball.domain.ManualNumberBallsFactory;
 import baseball.domain.NumberBalls;
 import baseball.domain.NumberBallsGenerator;
-import baseball.domain.PlayerChoice;
+import baseball.domain.WhetherReplay;
 import baseball.domain.Result;
 import baseball.view.InputView;
 import baseball.view.OutputView;
@@ -16,21 +16,21 @@ public static void main(String[] args) {
             final NumberBalls computerBalls = autoGenerator.generateBalls();
             inputNumberWhileAllStrike(computerBalls);
             OutputView.printWinningMessage();
-        } while (inputPlayGameAgain().isPlayAgain());
+        } while (inputWhetherReplay().isReplay());
     }
 
     private static void inputNumberWhileAllStrike(final NumberBalls computerBalls) {
         while (true) {
-            final NumberBalls playerBalls = inputPlayerNumberBalls();
+            final NumberBalls playerBalls = inputPlayerBalls();
             final Result computeResult = computerBalls.compute(playerBalls);
             OutputView.printCompareResult(computeResult);
-            if (computeResult.isAllStrike()) {
+            if (computeResult.isAllStrikes()) {
                 break;
             }
         }
     }
 
-    private static NumberBalls inputPlayerNumberBalls() {
+    private static NumberBalls inputPlayerBalls() {
         while (true) {
             try {
                 final NumberBallsGenerator manualBallsGenerator = new ManualNumberBallsFactory(
@@ -42,10 +42,10 @@ private static NumberBalls inputPlayerNumberBalls() {
         }
     }
 
-    private static PlayerChoice inputPlayGameAgain() {
+    private static WhetherReplay inputWhetherReplay() {
         while (true) {
             try {
-                return PlayerChoice.of(InputView.inputPlayAgain());
+                return WhetherReplay.of(InputView.inputWhetherReplay());
             } catch (IllegalArgumentException e) {
                 OutputView.printErrorMessage(e);
             }
diff --git a/src/main/java/baseball/domain/NumberBalls.java b/src/main/java/baseball/domain/NumberBalls.java
index a3d8550..e0b1fd6 100644
--- a/src/main/java/baseball/domain/NumberBalls.java
+++ b/src/main/java/baseball/domain/NumberBalls.java
@@ -9,7 +9,7 @@
 
 public final class NumberBalls {
     static final int BALL_NUMBER_LENGTH = 3;
-    private static final int DEFAULT_STRIKE_COUNT = 0;
+    private static final int DEFAULT_STRIKE_COUNT_NUMBER = 0;
 
     private static final String INVALID_BALLS_ARGUMENT_EXCEPTION_MESSAGE = "입력 값이 유효하지 않습니다.";
     private static final String DUPLICATE_NUMBER_CONTAINS_EXCEPTION_MESSAGE = "중복된 값은 들어갈 수 없습니다.";
@@ -47,29 +47,29 @@ private void verifyLength(final List<NumberBall> balls) {
         }
     }
 
-    public Result compute(final NumberBalls otherBalls) {
-        final int strikeCount = computeStrike(otherBalls);
-        final int ballCount = computeBall(otherBalls, strikeCount);
-        return Result.of(strikeCount, ballCount);
+    public Result compute(final NumberBalls other) {
+        final int strike = computeStrike(other);
+        final int ball = computeBall(other, strike);
+        return Result.of(strike, ball);
     }
 
-    private int computeStrike(final NumberBalls comparer) {
-        int strikeCount = DEFAULT_STRIKE_COUNT;
+    private int computeStrike(final NumberBalls other) {
+        int strike = DEFAULT_STRIKE_COUNT_NUMBER;
         for (int i = 0; i < this.balls.size(); i++) {
-            if (this.balls.get(i).equals(comparer.balls.get(i))) {
-                strikeCount++;
+            if (this.balls.get(i).equals(other.balls.get(i))) {
+                strike++;
             }
         }
-        return strikeCount;
+        return strike;
     }
 
-    private int computeBall(final NumberBalls otherBalls, final int strikeCount) {
-        final int ballCandidateCount = getBallCandidateCount(otherBalls);
-        return ballCandidateCount - strikeCount;
+    private int computeBall(final NumberBalls other, final int strike) {
+        final int ballCandidateCount = computeCountOfBallCandidate(other);
+        return ballCandidateCount - strike;
     }
 
-    private int getBallCandidateCount(final NumberBalls comparer) {
-        final List<NumberBall> otherBalls = comparer.balls;
+    private int computeCountOfBallCandidate(final NumberBalls other) {
+        final List<NumberBall> otherBalls = other.balls;
         final Set<NumberBall> distinctNumbers = new HashSet<>(this.balls);
         distinctNumbers.addAll(otherBalls);
         return this.balls.size() + otherBalls.size() - distinctNumbers.size();
diff --git a/src/main/java/baseball/domain/Result.java b/src/main/java/baseball/domain/Result.java
index b186946..74a2db1 100644
--- a/src/main/java/baseball/domain/Result.java
+++ b/src/main/java/baseball/domain/Result.java
@@ -29,7 +29,7 @@ public static Result of(final int strikeCount, final int ballCount) {
         return new Result(Count.of(strikeCount), Count.of(ballCount));
     }
 
-    public boolean isAllStrike() {
+    public boolean isAllStrikes() {
         return strike.isSameValue(NumberBalls.BALL_NUMBER_LENGTH);
     }
 
diff --git a/src/main/java/baseball/domain/PlayerChoice.java b/src/main/java/baseball/domain/WhetherReplay.java
similarity index 57%
rename from src/main/java/baseball/domain/PlayerChoice.java
rename to src/main/java/baseball/domain/WhetherReplay.java
index 15c2f49..d1e4213 100644
--- a/src/main/java/baseball/domain/PlayerChoice.java
+++ b/src/main/java/baseball/domain/WhetherReplay.java
@@ -2,25 +2,25 @@
 
 import java.util.Arrays;
 
-public enum PlayerChoice {
-    PLAY_AGAIN("1"), GAME_END("2");
+public enum WhetherReplay {
+    YES("1"), NO("2");
 
     private static final String INVALID_PLAYER_CHOICE_CODE_EXCEPTION_MESSAGE = "유효한 값이 아닙니다.";
 
     private final String chooseCode;
 
-    PlayerChoice(final String chooseCode) {
+    WhetherReplay(final String chooseCode) {
         this.chooseCode = chooseCode;
     }
 
-    public static PlayerChoice of(final String value) {
+    public static WhetherReplay of(final String value) {
         return Arrays.stream(values())
-            .filter(playerChoiceValue -> playerChoiceValue.chooseCode.equals(value))
+            .filter(whetherReplayValue -> whetherReplayValue.chooseCode.equals(value))
             .findFirst()
             .orElseThrow(() -> new IllegalArgumentException(INVALID_PLAYER_CHOICE_CODE_EXCEPTION_MESSAGE));
     }
 
-    public boolean isPlayAgain() {
-        return this == PLAY_AGAIN;
+    public boolean isReplay() {
+        return this == YES;
     }
 }
diff --git a/src/main/java/baseball/view/InputView.java b/src/main/java/baseball/view/InputView.java
index 1a46b0b..486bb40 100644
--- a/src/main/java/baseball/view/InputView.java
+++ b/src/main/java/baseball/view/InputView.java
@@ -21,7 +21,7 @@ private static Integer parseInt(final String inputValue) {
         }
     }
 
-    public static String inputPlayAgain() {
+    public static String inputWhetherReplay() {
         System.out.print(INPUT_PLAY_AGAIN_INTRO_MESSAGE);
         return SCANNER.next();
     }
diff --git a/src/test/java/baseball/domain/ResultTest.java b/src/test/java/baseball/domain/ResultTest.java
index 1ce5116..8414e19 100644
--- a/src/test/java/baseball/domain/ResultTest.java
+++ b/src/test/java/baseball/domain/ResultTest.java
@@ -28,6 +28,6 @@ void create_fail_when_invalid_count_include(int strikeCount, int ballCount) {
     @CsvSource(value = {"3, true", "2, false"})
     void isAllStrikeTest(int strikeCount, boolean isAllStrike) {
         Result result = Result.of(strikeCount, 0);
-        assertThat(result.isAllStrike()).isEqualTo(isAllStrike);
+        assertThat(result.isAllStrikes()).isEqualTo(isAllStrike);
     }
 }
\ No newline at end of file
diff --git a/src/test/java/baseball/domain/PlayerChoiceTest.java b/src/test/java/baseball/domain/WhetherReplayTest.java
similarity index 71%
rename from src/test/java/baseball/domain/PlayerChoiceTest.java
rename to src/test/java/baseball/domain/WhetherReplayTest.java
index 989b564..68327cf 100644
--- a/src/test/java/baseball/domain/PlayerChoiceTest.java
+++ b/src/test/java/baseball/domain/WhetherReplayTest.java
@@ -7,18 +7,18 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
 
-class PlayerChoiceTest {
+class WhetherReplayTest {
     @DisplayName("1, 2 값 이외의 값을 입력받은 경우, IllegalArgumentException 발생")
     @Test
     void create_fail() {
-        assertThatThrownBy(() -> PlayerChoice.of("3")).isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> WhetherReplay.of("3")).isInstanceOf(IllegalArgumentException.class);
     }
 
     @DisplayName("1을 넣는 경우, 게임 재시작 여부 true, 2를 넣는 경우, 게임 재시작 여부 false를 반환")
     @ParameterizedTest
     @CsvSource(value = {"1, true", "2, false"})
     void playAgainTest(String inputValue, boolean expected) {
-        PlayerChoice playerChoice = PlayerChoice.of(inputValue);
-        assertThat(playerChoice.isPlayAgain()).isEqualTo(expected);
+        WhetherReplay whetherReplay = WhetherReplay.of(inputValue);
+        assertThat(whetherReplay.isReplay()).isEqualTo(expected);
     }
 }
\ No newline at end of file

From 4d86e5521264fde6279e837c14f41be4f3da9de6 Mon Sep 17 00:00:00 2001
From: taejinseok <stj930@gmail.com>
Date: Mon, 29 Jun 2020 00:27:08 +0900
Subject: [PATCH 24/24] =?UTF-8?q?refactor:=20=EB=B3=80=EC=88=98,=20?=
 =?UTF-8?q?=ED=81=B4=EB=9E=98=EC=8A=A4=20rename?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/baseball/BaseBallMainApplication.java           | 4 ++--
 ...umberBallsFactory.java => ManualNumberBallsGenerator.java} | 4 ++--
 .../java/baseball/domain/ManualNumberBallsGeneratorTest.java  | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)
 rename src/main/java/baseball/domain/{ManualNumberBallsFactory.java => ManualNumberBallsGenerator.java} (90%)

diff --git a/src/main/java/baseball/BaseBallMainApplication.java b/src/main/java/baseball/BaseBallMainApplication.java
index e273419..da8d41c 100644
--- a/src/main/java/baseball/BaseBallMainApplication.java
+++ b/src/main/java/baseball/BaseBallMainApplication.java
@@ -1,7 +1,7 @@
 package baseball;
 
 import baseball.domain.AutoNumberBallsGenerator;
-import baseball.domain.ManualNumberBallsFactory;
+import baseball.domain.ManualNumberBallsGenerator;
 import baseball.domain.NumberBalls;
 import baseball.domain.NumberBallsGenerator;
 import baseball.domain.WhetherReplay;
@@ -33,7 +33,7 @@ private static void inputNumberWhileAllStrike(final NumberBalls computerBalls) {
     private static NumberBalls inputPlayerBalls() {
         while (true) {
             try {
-                final NumberBallsGenerator manualBallsGenerator = new ManualNumberBallsFactory(
+                final NumberBallsGenerator manualBallsGenerator = new ManualNumberBallsGenerator(
                     InputView.inputBaseBallNumbers());
                 return manualBallsGenerator.generateBalls();
             } catch (IllegalArgumentException e) {
diff --git a/src/main/java/baseball/domain/ManualNumberBallsFactory.java b/src/main/java/baseball/domain/ManualNumberBallsGenerator.java
similarity index 90%
rename from src/main/java/baseball/domain/ManualNumberBallsFactory.java
rename to src/main/java/baseball/domain/ManualNumberBallsGenerator.java
index 172afdb..42c96a9 100644
--- a/src/main/java/baseball/domain/ManualNumberBallsFactory.java
+++ b/src/main/java/baseball/domain/ManualNumberBallsGenerator.java
@@ -4,7 +4,7 @@
 import java.util.List;
 import java.util.Stack;
 
-public class ManualNumberBallsFactory implements NumberBallsGenerator {
+public class ManualNumberBallsGenerator implements NumberBallsGenerator {
     private static final int EXTRACT_COMPLETE_CRITERIA = 0;
     private static final int EXTRACT_BALL_NUMBER_DIVIDER = 10;
 
@@ -12,7 +12,7 @@ public class ManualNumberBallsFactory implements NumberBallsGenerator {
 
     private final int number;
 
-    public ManualNumberBallsFactory(final int number) {
+    public ManualNumberBallsGenerator(final int number) {
         validateNumber(number);
         this.number = number;
     }
diff --git a/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java b/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
index d23fa8c..bf214f4 100644
--- a/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
+++ b/src/test/java/baseball/domain/ManualNumberBallsGeneratorTest.java
@@ -12,7 +12,7 @@ class ManualNumberBallsGeneratorTest {
     @DisplayName("중복이 없고 0이 포함되지 않은 세자리의 자연수를 숫자 목록 객체로 생성한다.")
     @Test
     void generateBalls_test() {
-        NumberBallsGenerator numberBallsGenerator = new ManualNumberBallsFactory(321);
+        NumberBallsGenerator numberBallsGenerator = new ManualNumberBallsGenerator(321);
         assertThat(numberBallsGenerator.generateBalls())
             .isEqualTo(new NumberBalls(Lists.list(NumberBall.of(3), NumberBall.of(2), NumberBall.of(1))));
     }
@@ -22,7 +22,7 @@ void generateBalls_test() {
     @ValueSource(ints = {333, 1234, 75, -152, -10})
     void generateBalls_test_fail(int value) {
         assertThatThrownBy(() -> {
-            NumberBallsGenerator numberBallsGenerator = new ManualNumberBallsFactory(value);
+            NumberBallsGenerator numberBallsGenerator = new ManualNumberBallsGenerator(value);
             numberBallsGenerator.generateBalls();
         }).isInstanceOf(IllegalArgumentException.class);
     }