From f1590cd9250e765ee146cbcfabc7e8dca9c52d6d Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Thu, 30 Oct 2025 23:41:46 +0900
Subject: [PATCH 01/21] =?UTF-8?q?=EB=A6=AC=EB=93=9C=EB=AF=B8=20=EC=B4=88?=
 =?UTF-8?q?=EC=95=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 401 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 400 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5fa2560b46..c319296c7d 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,400 @@
-# java-lotto-precourse
+# 🎰 로또 게임 (java-lotto-precourse)
+
+## 📖 프로젝트 소개
+
+> 우아한테크코스 프리코스 3주차 미션입니다.
+>
+> 로또 구매부터 당첨 확인까지 전체 프로세스를 구현한 콘솔 기반 로또 게임입니다.
+
+### 주요 기능
+- 💰 구매 금액 입력 및 로또 자동 발행
+- 🎲 1~45 범위의 중복되지 않는 번호 6개 생성
+- 🎯 당첨 번호 및 보너스 번호 입력
+- 🏆 당첨 통계 및 수익률 계산
+- ✅ 입력값 검증 및 예외 처리
+
+---
+
+## 🚀 실행 방법
+
+### 요구사항
+- Java 21
+- Gradle
+
+### 실행
+```bash
+./gradlew run
+```
+
+### 입출력 예시
+
+**입력:**
+```
+구입금액을 입력해 주세요.
+8000
+
+당첨 번호를 입력해 주세요.
+1,2,3,4,5,6
+
+보너스 번호를 입력해 주세요.
+7
+```
+
+**출력:**
+```
+8개를 구매했습니다.
+[8, 21, 23, 41, 42, 43] 
+[3, 5, 11, 16, 32, 38] 
+[7, 11, 16, 35, 36, 44] 
+[1, 8, 11, 31, 41, 42] 
+[13, 14, 16, 38, 42, 45] 
+[7, 11, 30, 40, 42, 43] 
+[2, 13, 22, 32, 38, 45] 
+[1, 3, 5, 14, 22, 45]
+
+당첨 통계
+---
+3개 일치 (5,000원) - 1개
+4개 일치 (50,000원) - 0개
+5개 일치 (1,500,000원) - 0개
+5개 일치, 보너스 볼 일치 (30,000,000원) - 0개
+6개 일치 (2,000,000,000원) - 0개
+총 수익률은 62.5%입니다.
+```
+
+---
+
+## 🛠️ 기술 스택
+
+- **Language:** Java 21
+- **Build Tool:** Gradle
+- **Testing:** JUnit 5, AssertJ
+- **Library:** camp.nextstep.edu.missionutils
+
+---
+
+## 📦 패키지 구조
+```
+src/main/java/lotto/
+├── Application.java              # 프로그램 진입점
+├── domain/                       # 핵심 비즈니스 로직
+│   ├── Lotto.java               # 로또 번호 (6개)
+│   ├── LottoTickets.java        # 여러 로또 관리
+│   ├── WinningLotto.java        # 당첨 번호 + 보너스 번호
+│   ├── Rank.java                # 당첨 등수 (Enum)
+│   └── LottoResult.java         # 당첨 결과 및 수익률
+├── service/                      # 게임 진행 조율
+│   └── LottoGameService.java
+├── view/                         # 입출력 처리
+│   ├── InputView.java           # 사용자 입력
+│   └── OutputView.java          # 결과 출력
+├── validator/                    # 입력 검증
+│   └── InputValidator.java
+└── util/                         # 유틸리티
+    └── LottoGenerator.java       # 로또 번호 생성
+```
+
+---
+
+## ⚙️ 기능 구현 목록
+
+### 1. 도메인 객체 구현
+
+#### 1.1 Lotto 객체 구현
+
+**정상 케이스:**
+- [ ] 6개의 로또 번호를 저장한다
+- [ ] 로또 번호는 1~45 범위의 중복되지 않는 숫자이다
+- [ ] 로또 번호를 오름차순으로 정렬하여 반환한다
+- [ ] 주어진 번호 리스트와 일치하는 개수를 반환한다
+- [ ] 특정 번호 포함 여부를 확인한다
+
+**예외 케이스:**
+- [ ] 로또 번호가 6개가 아니면 예외 발생
+- [ ] 중복된 번호가 있으면 예외 발생
+- [ ] 1~45 범위를 벗어나면 예외 발생
+
+**커밋:** `feat(domain): Lotto 객체 기본 기능 구현`
+
+#### 1.2 Rank 열거형 구현
+
+**정상 케이스:**
+- [ ] 일치 개수와 보너스 일치 여부로 등수를 판별한다
+- [ ] 각 등수별 상금을 반환한다
+- [ ] 5등: 3개 일치 / 5,000원
+- [ ] 4등: 4개 일치 / 50,000원
+- [ ] 3등: 5개 일치 / 1,500,000원
+- [ ] 2등: 5개 + 보너스 일치 / 30,000,000원
+- [ ] 1등: 6개 일치 / 2,000,000,000원
+- [ ] 당첨되지 않으면 NONE 반환
+
+**커밋:** `feat(domain): Rank 열거형 구현`
+
+#### 1.3 WinningLotto 객체 구현
+
+**정상 케이스:**
+- [ ] 당첨 번호 6개와 보너스 번호 1개를 저장한다
+- [ ] 로또와 비교하여 등수를 판별한다
+
+**예외 케이스:**
+- [ ] 보너스 번호가 당첨 번호와 중복되면 예외 발생
+- [ ] 보너스 번호가 1~45 범위를 벗어나면 예외 발생
+
+**커밋:** `feat(domain): WinningLotto 객체 구현`
+
+#### 1.4 LottoTickets 객체 구현
+
+**정상 케이스:**
+- [ ] 여러 개의 로또를 관리한다
+- [ ] 구매한 로또 개수를 반환한다
+- [ ] 모든 로또를 반환한다
+
+**커밋:** `feat(domain): LottoTickets 객체 구현`
+
+#### 1.5 LottoResult 객체 구현
+
+**정상 케이스:**
+- [ ] 등수별 당첨 개수를 저장한다
+- [ ] 총 수익금을 계산한다
+- [ ] 수익률을 계산한다 (소수점 둘째 자리 반올림)
+- [ ] 등수별 당첨 개수를 반환한다
+
+**커밋:** `feat(domain): LottoResult 객체 구현`
+
+---
+
+### 2. 입력 검증 구현
+
+#### 2.1 구매 금액 검증
+
+**정상 케이스:**
+- [ ] 1,000원 이상의 금액이면 통과
+- [ ] 1,000원 단위로 나누어떨어지면 통과
+
+**예외 케이스:**
+- [ ] 숫자가 아니면 예외 발생
+- [ ] 1,000원 미만이면 예외 발생
+- [ ] 1,000원으로 나누어떨어지지 않으면 예외 발생
+- [ ] null이거나 빈 문자열이면 예외 발생
+
+**커밋:** `feat(validator): 구매 금액 검증 구현`
+
+#### 2.2 당첨 번호 검증
+
+**정상 케이스:**
+- [ ] 쉼표로 구분된 6개의 번호면 통과
+- [ ] 각 번호가 1~45 범위 내에 있으면 통과
+- [ ] 중복되지 않으면 통과
+
+**예외 케이스:**
+- [ ] 번호가 6개가 아니면 예외 발생
+- [ ] 1~45 범위를 벗어나면 예외 발생
+- [ ] 중복된 번호가 있으면 예외 발생
+- [ ] 숫자가 아닌 값이 포함되면 예외 발생
+- [ ] null이거나 빈 문자열이면 예외 발생
+
+**커밋:** `feat(validator): 당첨 번호 검증 구현`
+
+#### 2.3 보너스 번호 검증
+
+**정상 케이스:**
+- [ ] 1~45 범위의 숫자면 통과
+- [ ] 당첨 번호와 중복되지 않으면 통과
+
+**예외 케이스:**
+- [ ] 숫자가 아니면 예외 발생
+- [ ] 1~45 범위를 벗어나면 예외 발생
+- [ ] 당첨 번호와 중복되면 예외 발생
+- [ ] null이거나 빈 문자열이면 예외 발생
+
+**커밋:** `feat(validator): 보너스 번호 검증 구현`
+
+---
+
+### 3. 로또 번호 생성
+
+#### 3.1 자동 로또 번호 생성
+
+**정상 케이스:**
+- [ ] 1~45 범위에서 중복되지 않는 6개의 숫자를 생성한다
+- [ ] `Randoms.pickUniqueNumbersInRange()` 사용
+- [ ] 구매 금액에 맞는 개수만큼 로또를 생성한다
+
+**커밋:** `feat(util): 로또 번호 자동 생성 구현`
+
+---
+
+### 4. 입출력 기능
+
+#### 4.1 구매 금액 입력
+- [ ] 입력 안내 메시지 출력
+- [ ] 문자열을 정수로 변환
+
+**커밋:** `feat(view): 구매 금액 입력 기능 구현`
+
+#### 4.2 당첨 번호 입력
+- [ ] 입력 안내 메시지 출력
+- [ ] 쉼표 기준으로 번호 분리
+- [ ] 각 번호의 공백 제거 및 정수 변환
+
+**커밋:** `feat(view): 당첨 번호 입력 기능 구현`
+
+#### 4.3 보너스 번호 입력
+- [ ] 입력 안내 메시지 출력
+- [ ] 문자열을 정수로 변환
+
+**커밋:** `feat(view): 보너스 번호 입력 기능 구현`
+
+#### 4.4 구매한 로또 출력
+- [ ] "n개를 구매했습니다." 출력
+- [ ] 각 로또를 오름차순 정렬하여 출력
+- [ ] 형식: [번호1, 번호2, 번호3, 번호4, 번호5, 번호6]
+
+**커밋:** `feat(view): 구매 로또 출력 기능 구현`
+
+#### 4.5 당첨 통계 출력
+- [ ] "당첨 통계" 헤더 출력
+- [ ] 구분선 "---" 출력
+- [ ] 각 등수별 당첨 개수 출력
+- [ ] 형식: "n개 일치 (금액원) - m개"
+- [ ] 2등: "5개 일치, 보너스 볼 일치 (금액원) - m개"
+
+**커밋:** `feat(view): 당첨 통계 출력 기능 구현`
+
+#### 4.6 수익률 출력
+- [ ] "총 수익률은 n%입니다." 형식으로 출력
+- [ ] 소수점 둘째 자리에서 반올림
+
+**커밋:** `feat(view): 수익률 출력 기능 구현`
+
+#### 4.7 에러 메시지 출력
+- [ ] "[ERROR]"로 시작하는 에러 메시지 출력
+- [ ] 에러 발생 후 해당 입력부터 재시도
+
+**커밋:** `feat(view): 에러 메시지 출력 기능 구현`
+
+---
+
+### 5. 게임 진행 서비스
+
+#### 5.1 LottoGameService 구현
+- [ ] 구매 금액 입력 및 검증
+- [ ] 로또 자동 발행
+- [ ] 구매한 로또 출력
+- [ ] 당첨 번호 입력 및 검증
+- [ ] 보너스 번호 입력 및 검증
+- [ ] 당첨 결과 계산
+- [ ] 당첨 통계 및 수익률 출력
+- [ ] 예외 발생 시 해당 단계부터 재시도
+
+**커밋:** `feat(service): LottoGameService 게임 진행 로직 구현`
+
+---
+
+### 6. 메인 실행
+
+#### 6.1 Application 진입점
+- [ ] LottoGameService 실행
+- [ ] 예외 발생 시 적절한 처리
+
+**커밋:** `feat(app): Application 메인 실행 구현`
+
+---
+
+## 🏗️ 아키텍처
+
+- **레이어드 아키텍처** (Layered Architecture) 기반
+- **Package by Layer** 방식
+- **Inside-Out 개발** (Domain → Validator → Util → View → Service → Application)
+
+```
+┌─────────────────┐
+│  Application    │ (진입점)
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│    Service      │ (조율 + 재시도 로직)
+└────┬────────────┘
+     │
+     ├──────────┬──────────┐
+     ▼          ▼          ▼
+┌─────────┐  ┌──────────┐ ┌──────────┐
+│ Domain  │  │   View   │ │   Util   │
+└─────────┘  └──────────┘ └──────────┘
+     ▲          ▲
+     │          │
+┌────┴──────────┴────┐
+│    Validator       │
+└────────────────────┘
+```
+
+---
+
+## ✅ 프로그래밍 요구사항 준수
+
+- [ ] JDK 21에서 실행 가능
+- [ ] indent depth 2 이하
+- [ ] 3항 연산자 미사용
+- [ ] else 예약어 미사용
+- [ ] 함수 길이 15라인 이하
+- [ ] 함수가 한 가지 일만 수행
+- [ ] Java Enum 활용
+- [ ] JUnit 5, AssertJ 테스트 작성
+- [ ] `Randoms.pickUniqueNumbersInRange()` 사용
+- [ ] `Console.readLine()` 사용
+- [ ] 제공된 Lotto 클래스 활용
+- [ ] UI 로직 제외 단위 테스트 작성
+
+---
+
+## 🧪 테스트
+
+### 테스트 실행
+```bash
+./gradlew test
+```
+
+### 테스트 구조
+```
+src/test/java/lotto/
+├── domain/
+│   ├── LottoTest.java
+│   ├── RankTest.java
+│   ├── WinningLottoTest.java
+│   ├── LottoTicketsTest.java
+│   └── LottoResultTest.java
+├── validator/
+│   └── InputValidatorTest.java
+├── util/
+│   └── LottoGeneratorTest.java
+└── service/
+    └── LottoGameServiceTest.java
+```
+
+---
+
+## 💭 회고
+
+### 이번 주차 학습 목표
+- [ ] Java Enum을 활용한 등수 관리
+- [ ] 일급 컬렉션 패턴 적용
+- [ ] 예외 발생 시 재입력 로직 구현
+- [ ] 2주차 공통 피드백 반영
+
+### 2주차 피드백 반영 사항
+- [ ] 함수 분리를 통한 indent depth 관리
+- [ ] Early return 패턴으로 else 제거
+- [ ] 매직 넘버 상수화
+- [ ] 도메인 로직과 UI 로직 분리
+
+---
+
+## 📚 학습 내용
+
+- Java Enum 활용
+- 일급 컬렉션 (First-Class Collection)
+- 예외 처리 및 재입력 로직
+- 객체 간 협력 설계
+- 단위 테스트 작성
+- 수익률 계산 및 포맷팅
\ No newline at end of file

From 51878c28d010afbdf95c927b6c7b395bdacb7acf Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Sat, 1 Nov 2025 11:00:17 +0900
Subject: [PATCH 02/21] =?UTF-8?q?feat(readme):=20README=20=EC=9E=AC?=
 =?UTF-8?q?=EC=BB=B4=ED=86=A0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1. parsor 패키지 분리
2. 예외처리 정의
---
 README.md | 347 ++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 256 insertions(+), 91 deletions(-)

diff --git a/README.md b/README.md
index c319296c7d..91ffab6bb2 100644
--- a/README.md
+++ b/README.md
@@ -11,22 +11,20 @@
 - 🎲 1~45 범위의 중복되지 않는 번호 6개 생성
 - 🎯 당첨 번호 및 보너스 번호 입력
 - 🏆 당첨 통계 및 수익률 계산
-- ✅ 입력값 검증 및 예외 처리
+- ✅ 입력값 검증 및 예외 처리 (재시도 로직)
 
 ---
 
-## 🚀 실행 방법
+## 🛠️ 기술 스택
 
-### 요구사항
-- Java 21
-- Gradle
+- **Language:** Java 21
+- **Build Tool:** Gradle
+- **Testing:** JUnit 5, AssertJ
+- **Library:** camp.nextstep.edu.missionutils
 
-### 실행
-```bash
-./gradlew run
-```
+---
 
-### 입출력 예시
+## 🚀  입출력 예시
 
 **입력:**
 ```
@@ -64,16 +62,16 @@
 
 ---
 
-## 🛠️ 기술 스택
-
-- **Language:** Java 21
-- **Build Tool:** Gradle
-- **Testing:** JUnit 5, AssertJ
-- **Library:** camp.nextstep.edu.missionutils
-
----
-
 ## 📦 패키지 구조
+**레이어별 책임:**
+- **Application**: 프로그램 시작점
+- **Domain**: 핵심 비즈니스 로직
+- **Service**: 전체 게임 흐름 조율 및 예외 재시도 처리
+- **View**: 입출력 담당 (`Console.readLine()`, `System.out.println()`)
+- **Parser**: 문자열 → 객체 변환
+- **Validator**: 비즈니스 규칙 검증
+- **Util**: 로또 번호 생성 등 유틸리티
+
 ```
 src/main/java/lotto/
 ├── Application.java              # 프로그램 진입점
@@ -86,8 +84,12 @@ src/main/java/lotto/
 ├── service/                      # 게임 진행 조율
 │   └── LottoGameService.java
 ├── view/                         # 입출력 처리
-│   ├── InputView.java           # 사용자 입력
+│   ├── InputView.java           # 사용자 입력 (Console.readLine())
 │   └── OutputView.java          # 결과 출력
+├── parser/                       # 문자열 파싱
+│   ├── PurchaseAmountParser.java
+│   ├── WinningNumbersParser.java
+│   └── BonusNumberParser.java
 ├── validator/                    # 입력 검증
 │   └── InputValidator.java
 └── util/                         # 유틸리티
@@ -110,9 +112,14 @@ src/main/java/lotto/
 - [ ] 특정 번호 포함 여부를 확인한다
 
 **예외 케이스:**
-- [ ] 로또 번호가 6개가 아니면 예외 발생
-- [ ] 중복된 번호가 있으면 예외 발생
-- [ ] 1~45 범위를 벗어나면 예외 발생
+- [ ] 로또 번호가 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호를 입력해주세요.`
+- [ ] 로또 번호가 6개가 아니면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호는 6개여야 합니다.`
+- [ ] 중복된 번호가 있으면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호는 중복될 수 없습니다.`
+- [ ] 1~45 범위를 벗어나면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.`
 
 **커밋:** `feat(domain): Lotto 객체 기본 기능 구현`
 
@@ -135,10 +142,16 @@ src/main/java/lotto/
 **정상 케이스:**
 - [ ] 당첨 번호 6개와 보너스 번호 1개를 저장한다
 - [ ] 로또와 비교하여 등수를 판별한다
+- [ ] 일치 개수를 계산한다
+- [ ] 보너스 번호 일치 여부를 확인한다
 
 **예외 케이스:**
-- [ ] 보너스 번호가 당첨 번호와 중복되면 예외 발생
-- [ ] 보너스 번호가 1~45 범위를 벗어나면 예외 발생
+- [ ] 당첨 번호가 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호를 입력해주세요.`
+- [ ] 보너스 번호가 당첨 번호와 중복되면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`
+- [ ] 보너스 번호가 1~45 범위를 벗어나면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.`
 
 **커밋:** `feat(domain): WinningLotto 객체 구현`
 
@@ -148,6 +161,13 @@ src/main/java/lotto/
 - [ ] 여러 개의 로또를 관리한다
 - [ ] 구매한 로또 개수를 반환한다
 - [ ] 모든 로또를 반환한다
+- [ ] 당첨 번호와 비교하여 각 로또의 등수를 판별한다
+
+**예외 케이스:**
+- [ ] 로또 리스트가 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 목록이 없습니다.`
+- [ ] 로또 리스트가 비어있으면 `IllegalArgumentException` 발생
+    - `[ERROR] 최소 1개 이상의 로또를 구매해야 합니다.`
 
 **커밋:** `feat(domain): LottoTickets 객체 구현`
 
@@ -159,153 +179,285 @@ src/main/java/lotto/
 - [ ] 수익률을 계산한다 (소수점 둘째 자리 반올림)
 - [ ] 등수별 당첨 개수를 반환한다
 
+**예외 케이스:**
+- [ ] 구매 금액이 0 이하면 `IllegalArgumentException` 발생
+    - `[ERROR] 구매 금액은 0보다 커야 합니다.`
+
 **커밋:** `feat(domain): LottoResult 객체 구현`
 
 ---
 
-### 2. 입력 검증 구현
+### 2. 입력 파싱 구현
+
+#### 2.1 PurchaseAmountParser 구현
+
+**정상 케이스:**
+- [ ] 문자열을 정수로 변환한다
+- [ ] 앞뒤 공백을 제거한다
+
+**예외 케이스:**
+- [ ] 입력이 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액을 입력해주세요.`
+- [ ] 입력이 빈 문자열이면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액을 입력해주세요.`
+- [ ] 숫자가 아닌 문자가 포함되면 `NumberFormatException` 발생
+    - `[ERROR] 구입 금액은 숫자여야 합니다.`
+
+**커밋:** `feat(parser): 구매 금액 파싱 구현`
+
+#### 2.2 WinningNumbersParser 구현
+
+**정상 케이스:**
+- [ ] 쉼표 기준으로 문자열을 분리한다
+- [ ] 각 번호의 앞뒤 공백을 제거한다
+- [ ] 문자열 리스트를 정수 리스트로 변환한다
+
+**예외 케이스:**
+- [ ] 입력이 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호를 입력해주세요.`
+- [ ] 입력이 빈 문자열이면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호를 입력해주세요.`
+- [ ] 쉼표로 구분되지 않은 경우 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호는 쉼표(,)로 구분해야 합니다.`
+- [ ] 숫자가 아닌 값이 포함되면 `NumberFormatException` 발생
+    - `[ERROR] 당첨 번호는 숫자여야 합니다.`
+- [ ] 공백만 있는 번호가 있으면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호는 빈 값일 수 없습니다.`
+
+**커밋:** `feat(parser): 당첨 번호 파싱 구현`
+
+#### 2.3 BonusNumberParser 구현
+
+**정상 케이스:**
+- [ ] 문자열을 정수로 변환한다
+- [ ] 앞뒤 공백을 제거한다
+
+**예외 케이스:**
+- [ ] 입력이 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호를 입력해주세요.`
+- [ ] 입력이 빈 문자열이면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호를 입력해주세요.`
+- [ ] 숫자가 아닌 문자가 포함되면 `NumberFormatException` 발생
+    - `[ERROR] 보너스 번호는 숫자여야 합니다.`
+
+**커밋:** `feat(parser): 보너스 번호 파싱 구현`
+
+---
+
+### 3. 입력 검증 구현
 
-#### 2.1 구매 금액 검증
+#### 3.1 구매 금액 검증
 
 **정상 케이스:**
 - [ ] 1,000원 이상의 금액이면 통과
 - [ ] 1,000원 단위로 나누어떨어지면 통과
 
 **예외 케이스:**
-- [ ] 숫자가 아니면 예외 발생
-- [ ] 1,000원 미만이면 예외 발생
-- [ ] 1,000원으로 나누어떨어지지 않으면 예외 발생
-- [ ] null이거나 빈 문자열이면 예외 발생
+- [ ] 음수를 입력하면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액은 양수여야 합니다.`
+- [ ] 0을 입력하면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액은 0보다 커야 합니다.`
+- [ ] 1,000원 미만이면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액은 1,000원 이상이어야 합니다.`
+- [ ] 1,000원으로 나누어떨어지지 않으면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액은 1,000원 단위여야 합니다.`
 
 **커밋:** `feat(validator): 구매 금액 검증 구현`
 
-#### 2.2 당첨 번호 검증
+#### 3.2 당첨 번호 검증
 
 **정상 케이스:**
-- [ ] 쉼표로 구분된 6개의 번호면 통과
+- [ ] 6개의 번호면 통과
 - [ ] 각 번호가 1~45 범위 내에 있으면 통과
 - [ ] 중복되지 않으면 통과
 
 **예외 케이스:**
-- [ ] 번호가 6개가 아니면 예외 발생
-- [ ] 1~45 범위를 벗어나면 예외 발생
-- [ ] 중복된 번호가 있으면 예외 발생
-- [ ] 숫자가 아닌 값이 포함되면 예외 발생
-- [ ] null이거나 빈 문자열이면 예외 발생
+- [ ] 번호 리스트가 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호를 입력해주세요.`
+- [ ] 번호가 6개가 아니면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호는 6개여야 합니다.`
+- [ ] 1~45 범위를 벗어나면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.`
+- [ ] 중복된 번호가 있으면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호는 중복될 수 없습니다.`
 
 **커밋:** `feat(validator): 당첨 번호 검증 구현`
 
-#### 2.3 보너스 번호 검증
+#### 3.3 보너스 번호 검증
 
 **정상 케이스:**
 - [ ] 1~45 범위의 숫자면 통과
 - [ ] 당첨 번호와 중복되지 않으면 통과
 
 **예외 케이스:**
-- [ ] 숫자가 아니면 예외 발생
-- [ ] 1~45 범위를 벗어나면 예외 발생
-- [ ] 당첨 번호와 중복되면 예외 발생
-- [ ] null이거나 빈 문자열이면 예외 발생
+- [ ] 1~45 범위를 벗어나면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.`
+- [ ] 당첨 번호와 중복되면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`
 
 **커밋:** `feat(validator): 보너스 번호 검증 구현`
 
 ---
 
-### 3. 로또 번호 생성
+### 4. 로또 번호 생성
 
-#### 3.1 자동 로또 번호 생성
+#### 4.1 자동 로또 번호 생성
 
 **정상 케이스:**
 - [ ] 1~45 범위에서 중복되지 않는 6개의 숫자를 생성한다
 - [ ] `Randoms.pickUniqueNumbersInRange()` 사용
 - [ ] 구매 금액에 맞는 개수만큼 로또를 생성한다
 
+**예외 케이스:**
+- [ ] 생성할 로또 개수가 0 이하면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 개수는 1개 이상이어야 합니다.`
+
 **커밋:** `feat(util): 로또 번호 자동 생성 구현`
 
 ---
 
-### 4. 입출력 기능
+### 5. 입출력 기능
 
-#### 4.1 구매 금액 입력
-- [ ] 입력 안내 메시지 출력
-- [ ] 문자열을 정수로 변환
+#### 5.1 구매 금액 입력
+- [ ] 입력 안내 메시지 출력: "구입금액을 입력해 주세요."
+- [ ] `Console.readLine()`으로 입력 받기
+- [ ] 입력받은 문자열을 그대로 반환
 
 **커밋:** `feat(view): 구매 금액 입력 기능 구현`
 
-#### 4.2 당첨 번호 입력
-- [ ] 입력 안내 메시지 출력
-- [ ] 쉼표 기준으로 번호 분리
-- [ ] 각 번호의 공백 제거 및 정수 변환
+#### 5.2 당첨 번호 입력
+- [ ] 빈 줄 출력
+- [ ] 입력 안내 메시지 출력: "당첨 번호를 입력해 주세요."
+- [ ] `Console.readLine()`으로 입력 받기
+- [ ] 입력받은 문자열을 그대로 반환
 
 **커밋:** `feat(view): 당첨 번호 입력 기능 구현`
 
-#### 4.3 보너스 번호 입력
-- [ ] 입력 안내 메시지 출력
-- [ ] 문자열을 정수로 변환
+#### 5.3 보너스 번호 입력
+- [ ] 빈 줄 출력
+- [ ] 입력 안내 메시지 출력: "보너스 번호를 입력해 주세요."
+- [ ] `Console.readLine()`으로 입력 받기
+- [ ] 입력받은 문자열을 그대로 반환
 
 **커밋:** `feat(view): 보너스 번호 입력 기능 구현`
 
-#### 4.4 구매한 로또 출력
+#### 5.4 구매한 로또 출력
+- [ ] 빈 줄 출력
 - [ ] "n개를 구매했습니다." 출력
 - [ ] 각 로또를 오름차순 정렬하여 출력
-- [ ] 형식: [번호1, 번호2, 번호3, 번호4, 번호5, 번호6]
+- [ ] 형식: `[번호1, 번호2, 번호3, 번호4, 번호5, 번호6]`
+- [ ] 각 로또마다 줄바꿈
 
 **커밋:** `feat(view): 구매 로또 출력 기능 구현`
 
-#### 4.5 당첨 통계 출력
+#### 5.5 당첨 통계 출력
+- [ ] 빈 줄 출력
 - [ ] "당첨 통계" 헤더 출력
 - [ ] 구분선 "---" 출력
-- [ ] 각 등수별 당첨 개수 출력
+- [ ] 5등부터 1등까지 순서대로 출력
 - [ ] 형식: "n개 일치 (금액원) - m개"
 - [ ] 2등: "5개 일치, 보너스 볼 일치 (금액원) - m개"
+- [ ] 금액은 천 단위 쉼표 포함
 
 **커밋:** `feat(view): 당첨 통계 출력 기능 구현`
 
-#### 4.6 수익률 출력
+#### 5.6 수익률 출력
 - [ ] "총 수익률은 n%입니다." 형식으로 출력
 - [ ] 소수점 둘째 자리에서 반올림
+- [ ] 천 단위 쉼표 포함
 
 **커밋:** `feat(view): 수익률 출력 기능 구현`
 
-#### 4.7 에러 메시지 출력
+#### 5.7 에러 메시지 출력
 - [ ] "[ERROR]"로 시작하는 에러 메시지 출력
-- [ ] 에러 발생 후 해당 입력부터 재시도
+- [ ] `System.out.println()` 사용
 
 **커밋:** `feat(view): 에러 메시지 출력 기능 구현`
 
 ---
 
-### 5. 게임 진행 서비스
+### 6. 게임 진행 서비스
 
-#### 5.1 LottoGameService 구현
-- [ ] 구매 금액 입력 및 검증
+#### 6.1 LottoGameService 구현
+- [ ] 구매 금액 입력 및 검증 (재시도 로직)
 - [ ] 로또 자동 발행
 - [ ] 구매한 로또 출력
-- [ ] 당첨 번호 입력 및 검증
-- [ ] 보너스 번호 입력 및 검증
+- [ ] 당첨 번호 입력 및 검증 (재시도 로직)
+- [ ] 보너스 번호 입력 및 검증 (재시도 로직)
 - [ ] 당첨 결과 계산
 - [ ] 당첨 통계 및 수익률 출력
-- [ ] 예외 발생 시 해당 단계부터 재시도
+- [ ] 각 입력 단계에서 예외 발생 시 해당 단계부터 재시도
+
+**재시도 흐름:**
+- [ ] 구매 금액 예외 → 구매 금액 입력부터 재시도
+- [ ] 당첨 번호 예외 → 당첨 번호 입력부터 재시도
+- [ ] 보너스 번호 예외 → 보너스 번호 입력부터 재시도
 
 **커밋:** `feat(service): LottoGameService 게임 진행 로직 구현`
 
 ---
 
-### 6. 메인 실행
+### 7. 메인 실행
 
-#### 6.1 Application 진입점
+#### 7.1 Application 진입점
 - [ ] LottoGameService 실행
-- [ ] 예외 발생 시 적절한 처리
+- [ ] 예외는 Service 레이어에서 처리
 
 **커밋:** `feat(app): Application 메인 실행 구현`
 
 ---
 
+## 🎯 예외 처리 전략
+
+### Exception 타입별 사용 기준
+
+#### 1. `IllegalArgumentException`
+**사용 시점:** 메서드에 전달된 인자가 유효하지 않을 때
+- 숫자 범위 오류 (1~45 범위 벗어남)
+- 개수 오류 (6개가 아님)
+- 중복 오류
+- 단위 오류 (1,000원 단위 아님)
+- null 또는 빈 값
+
+**예시:**
+```java
+if (numbers.size() != 6) {
+    throw new IllegalArgumentException("[ERROR] 로또 번호는 6개여야 합니다.");
+}
+```
+
+#### 2. `NumberFormatException`
+**사용 시점:** 문자열을 숫자로 변환할 수 없을 때
+- 파싱 과정에서 발생
+- `Integer.parseInt()` 실패 시
+
+**예시:**
+```java
+try {
+    return Integer.parseInt(input);
+} catch (NumberFormatException e) {
+    throw new NumberFormatException("[ERROR] 구입 금액은 숫자여야 합니다.");
+}
+```
+
+#### 3. `IllegalStateException` (선택적 사용)
+**사용 시점:** 객체의 상태가 메서드 호출에 적합하지 않을 때
+- 게임이 이미 종료된 상태에서 추가 작업 시도
+- 초기화되지 않은 객체 사용
+
+**예시:**
+```java
+if (lottoTickets == null) {
+    throw new IllegalStateException("[ERROR] 로또가 발행되지 않았습니다.");
+}
+```
+---
+
 ## 🏗️ 아키텍처
 
 - **레이어드 아키텍처** (Layered Architecture) 기반
 - **Package by Layer** 방식
-- **Inside-Out 개발** (Domain → Validator → Util → View → Service → Application)
+- **Inside-Out 개발** (Domain → Parser → Validator → Util → View → Service → Application)
 
 ```
 ┌─────────────────┐
@@ -317,11 +469,11 @@ src/main/java/lotto/
 │    Service      │ (조율 + 재시도 로직)
 └────┬────────────┘
      │
-     ├──────────┬──────────┐
-     ▼          ▼          ▼
-┌─────────┐  ┌──────────┐ ┌──────────┐
-│ Domain  │  │   View   │ │   Util   │
-└─────────┘  └──────────┘ └──────────┘
+     ├──────────┬──────────┬──────────┐
+     ▼          ▼          ▼          ▼
+┌─────────┐  ┌──────────┐ ┌──────────┐ ┌──────────┐
+│ Domain  │  │  Parser  │ │   View   │ │   Util   │
+└─────────┘  └──────────┘ └──────────┘ └──────────┘
      ▲          ▲
      │          │
 ┌────┴──────────┴────┐
@@ -339,22 +491,18 @@ src/main/java/lotto/
 - [ ] else 예약어 미사용
 - [ ] 함수 길이 15라인 이하
 - [ ] 함수가 한 가지 일만 수행
-- [ ] Java Enum 활용
+- [ ] Java Enum 활용 (Rank)
 - [ ] JUnit 5, AssertJ 테스트 작성
 - [ ] `Randoms.pickUniqueNumbersInRange()` 사용
 - [ ] `Console.readLine()` 사용
-- [ ] 제공된 Lotto 클래스 활용
+- [ ] 제공된 Lotto 클래스 활용 (필드 추가 불가)
 - [ ] UI 로직 제외 단위 테스트 작성
+- [ ] `IllegalArgumentException`, `IllegalStateException` 등 명확한 예외 타입 사용
 
 ---
 
 ## 🧪 테스트
 
-### 테스트 실행
-```bash
-./gradlew test
-```
-
 ### 테스트 구조
 ```
 src/test/java/lotto/
@@ -364,6 +512,10 @@ src/test/java/lotto/
 │   ├── WinningLottoTest.java
 │   ├── LottoTicketsTest.java
 │   └── LottoResultTest.java
+├── parser/
+│   ├── PurchaseAmountParserTest.java
+│   ├── WinningNumbersParserTest.java
+│   └── BonusNumberParserTest.java
 ├── validator/
 │   └── InputValidatorTest.java
 ├── util/
@@ -372,14 +524,23 @@ src/test/java/lotto/
     └── LottoGameServiceTest.java
 ```
 
+### 테스트 작성 원칙
+- [ ] 정상 케이스와 예외 케이스 모두 테스트
+- [ ] 경계값 테스트 (0, 1, 45, 46 등)
+- [ ] `@ParameterizedTest` 활용하여 여러 케이스 검증
+- [ ] `assertThatThrownBy()` 로 예외 메시지까지 검증
+- [ ] UI 로직(InputView, OutputView)은 테스트 제외
+
 ---
 
 ## 💭 회고
 
 ### 이번 주차 학습 목표
 - [ ] Java Enum을 활용한 등수 관리
-- [ ] 일급 컬렉션 패턴 적용
+- [ ] 일급 컬렉션 패턴 적용 (LottoTickets, LottoResult)
 - [ ] 예외 발생 시 재입력 로직 구현
+- [ ] Parser 레이어 분리로 책임 명확화
+- [ ] 다양한 예외 타입 활용 (IllegalArgumentException, NumberFormatException)
 - [ ] 2주차 공통 피드백 반영
 
 ### 2주차 피드백 반영 사항
@@ -387,14 +548,18 @@ src/test/java/lotto/
 - [ ] Early return 패턴으로 else 제거
 - [ ] 매직 넘버 상수화
 - [ ] 도메인 로직과 UI 로직 분리
+- [ ] 함수 길이 15라인 이하 유지
+
+### 예상 고민 포인트
+- Parser와 Validator의 경계 설정
+- 재시도 로직의 중복 제거
+- Enum을 활용한 등수 및 상금 관리
+- 일급 컬렉션 적용 범위
 
 ---
 
 ## 📚 학습 내용
 
-- Java Enum 활용
+- Java Enum 활용 (상태와 행위를 함께 관리)
 - 일급 컬렉션 (First-Class Collection)
-- 예외 처리 및 재입력 로직
-- 객체 간 협력 설계
-- 단위 테스트 작성
-- 수익률 계산 및 포맷팅
\ No newline at end of file
+- 예외 처리
\ No newline at end of file

From 9d5d7abd68e9f0c5bc0f7ebd36649cf519d61011 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 10:02:33 +0900
Subject: [PATCH 03/21] =?UTF-8?q?feat(domain):=20Rank=20=EC=97=B4=EA=B1=B0?=
 =?UTF-8?q?=ED=98=95=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/domain/Rank.java     | 47 +++++++++++++++
 src/test/java/lotto/domain/RankTest.java | 77 ++++++++++++++++++++++++
 2 files changed, 124 insertions(+)
 create mode 100644 src/main/java/lotto/domain/Rank.java
 create mode 100644 src/test/java/lotto/domain/RankTest.java

diff --git a/src/main/java/lotto/domain/Rank.java b/src/main/java/lotto/domain/Rank.java
new file mode 100644
index 0000000000..4bddef80ae
--- /dev/null
+++ b/src/main/java/lotto/domain/Rank.java
@@ -0,0 +1,47 @@
+package lotto.domain;
+
+import java.util.Arrays;
+
+public enum Rank {
+	FIRST(6, false, 2_000_000_000, "6개 일치"),
+	SECOND(5, true, 30_000_000, "5개 일치, 보너스 볼 일치"),
+	THIRD(5, false, 1_500_000, "5개 일치"),
+	FOURTH(4, false, 50_000, "4개 일치"),
+	FIFTH(3, false, 5_000, "3개 일치"),
+	NONE(0, false, 0, "");
+
+	private final int matchCount;
+	private final boolean matchBonus;
+	private final int prize;
+	private final String description;
+
+	Rank(int matchCount, boolean matchBonus, int prize, String description) {
+		this.matchCount = matchCount;
+		this.matchBonus = matchBonus;
+		this.prize = prize;
+		this.description = description;
+	}
+
+	public static Rank valueOf(int matchCount, boolean matchBonus) {
+		if (matchCount == 5 && matchBonus) {
+			return SECOND;
+		}
+		return Arrays.stream(values())
+			.filter(rank -> rank.matchCount == matchCount)
+			.filter(rank -> !rank.matchBonus)
+			.findFirst()
+			.orElse(NONE);
+	}
+
+	public int getPrize() {
+		return prize;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public boolean isWinning() {
+		return this != NONE;
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/domain/RankTest.java b/src/test/java/lotto/domain/RankTest.java
new file mode 100644
index 0000000000..29e91688fe
--- /dev/null
+++ b/src/test/java/lotto/domain/RankTest.java
@@ -0,0 +1,77 @@
+package lotto.domain;
+
+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;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class RankTest {
+
+	@DisplayName("1: 6개 일치하면 1등")
+	@Test
+	void test1MatchSixNumbers() {
+		Rank rank = Rank.valueOf(6, false);
+
+		assertThat(rank).isEqualTo(Rank.FIRST);
+		assertThat(rank.getPrize()).isEqualTo(2_000_000_000);
+	}
+
+	@DisplayName("2: 5개 일치하고 보너스볼 일치하면 2등")
+	@Test
+	void test2MatchFiveNumbersWithBonus() {
+		Rank rank = Rank.valueOf(5, true);
+
+		assertThat(rank).isEqualTo(Rank.SECOND);
+		assertThat(rank.getPrize()).isEqualTo(30_000_000);
+	}
+
+	@DisplayName("3: 5개 일치하고 보너스볼 불일치하면 3등")
+	@Test
+	void test3MatchFiveNumbersWithoutBonus() {
+		Rank rank = Rank.valueOf(5, false);
+
+		assertThat(rank).isEqualTo(Rank.THIRD);
+		assertThat(rank.getPrize()).isEqualTo(1_500_000);
+	}
+
+	@DisplayName("4: 4개 일치하면 4등")
+	@Test
+	void test4MatchFourNumbers() {
+		Rank rank = Rank.valueOf(4, false);
+
+		assertThat(rank).isEqualTo(Rank.FOURTH);
+		assertThat(rank.getPrize()).isEqualTo(50_000);
+	}
+
+	@DisplayName("5: 3개 일치하면 5등")
+	@Test
+	void test5MatchThreeNumbers() {
+		Rank rank = Rank.valueOf(3, false);
+
+		assertThat(rank).isEqualTo(Rank.FIFTH);
+		assertThat(rank.getPrize()).isEqualTo(5_000);
+	}
+
+	@DisplayName("6: 2개 이하 일치하면 NONE")
+	@ParameterizedTest
+	@CsvSource({"0, false", "1, false", "2, false"})
+	void test6MatchLessThanThree(int matchCount, boolean matchBonus) {
+		Rank rank = Rank.valueOf(matchCount, matchBonus);
+
+		assertThat(rank).isEqualTo(Rank.NONE);
+		assertThat(rank.getPrize()).isEqualTo(0);
+	}
+
+	@DisplayName("7: 당첨 여부 확인")
+	@Test
+	void test7IsWinning() {
+		assertThat(Rank.FIRST.isWinning()).isTrue();
+		assertThat(Rank.SECOND.isWinning()).isTrue();
+		assertThat(Rank.THIRD.isWinning()).isTrue();
+		assertThat(Rank.FOURTH.isWinning()).isTrue();
+		assertThat(Rank.FIFTH.isWinning()).isTrue();
+		assertThat(Rank.NONE.isWinning()).isFalse();
+	}
+}
\ No newline at end of file

From 8a330269c78f49e127b369cd89a7c770855ed058 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 21:25:34 +0900
Subject: [PATCH 04/21] =?UTF-8?q?feat(domain):=20Lotto=20=EA=B0=9D?=
 =?UTF-8?q?=EC=B2=B4=20=EA=B8=B0=EB=B3=B8=20=EA=B8=B0=EB=8A=A5=20=EA=B5=AC?=
 =?UTF-8?q?=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                                     |  30 ++--
 src/main/java/lotto/domain/Lotto.java         |  68 ++++++++
 src/main/java/lotto/domain/WinningLotto.java  |  56 +++++++
 src/test/java/lotto/LottoTest.java            |  25 ---
 src/test/java/lotto/domain/LottoTest.java     | 147 ++++++++++++++++++
 src/test/java/lotto/domain/RankTest.java      |  14 +-
 .../java/lotto/domain/WinningLottoTest.java   | 134 ++++++++++++++++
 7 files changed, 427 insertions(+), 47 deletions(-)
 create mode 100644 src/main/java/lotto/domain/Lotto.java
 create mode 100644 src/main/java/lotto/domain/WinningLotto.java
 delete mode 100644 src/test/java/lotto/LottoTest.java
 create mode 100644 src/test/java/lotto/domain/LottoTest.java
 create mode 100644 src/test/java/lotto/domain/WinningLottoTest.java

diff --git a/README.md b/README.md
index 91ffab6bb2..bc6eeef8c3 100644
--- a/README.md
+++ b/README.md
@@ -102,7 +102,21 @@ src/main/java/lotto/
 
 ### 1. 도메인 객체 구현
 
-#### 1.1 Lotto 객체 구현
+#### 1.2 Rank 열거형 구현
+
+**정상 케이스:**
+- [ ] 일치 개수와 보너스 일치 여부로 등수를 판별한다
+- [ ] 각 등수별 상금을 반환한다
+- [ ] 5등: 3개 일치 / 5,000원
+- [ ] 4등: 4개 일치 / 50,000원
+- [ ] 3등: 5개 일치 / 1,500,000원
+- [ ] 2등: 5개 + 보너스 일치 / 30,000,000원
+- [ ] 1등: 6개 일치 / 2,000,000,000원
+- [ ] 당첨되지 않으면 NONE 반환
+
+**커밋:** `feat(domain): Rank 열거형 구현`
+
+#### 1.2 Lotto 객체 구현
 
 **정상 케이스:**
 - [ ] 6개의 로또 번호를 저장한다
@@ -123,20 +137,6 @@ src/main/java/lotto/
 
 **커밋:** `feat(domain): Lotto 객체 기본 기능 구현`
 
-#### 1.2 Rank 열거형 구현
-
-**정상 케이스:**
-- [ ] 일치 개수와 보너스 일치 여부로 등수를 판별한다
-- [ ] 각 등수별 상금을 반환한다
-- [ ] 5등: 3개 일치 / 5,000원
-- [ ] 4등: 4개 일치 / 50,000원
-- [ ] 3등: 5개 일치 / 1,500,000원
-- [ ] 2등: 5개 + 보너스 일치 / 30,000,000원
-- [ ] 1등: 6개 일치 / 2,000,000,000원
-- [ ] 당첨되지 않으면 NONE 반환
-
-**커밋:** `feat(domain): Rank 열거형 구현`
-
 #### 1.3 WinningLotto 객체 구현
 
 **정상 케이스:**
diff --git a/src/main/java/lotto/domain/Lotto.java b/src/main/java/lotto/domain/Lotto.java
new file mode 100644
index 0000000000..2d5dc54560
--- /dev/null
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -0,0 +1,68 @@
+package lotto.domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Lotto {
+	private static final int LOTTO_NUMBER_COUNT = 6;
+	private static final int MIN_LOTTO_NUMBER = 1;
+	private static final int MAX_LOTTO_NUMBER = 45;
+
+	private final List<Integer> numbers;
+
+	public Lotto(List<Integer> numbers) {
+		validate(numbers);
+		this.numbers = numbers.stream()
+			.sorted()
+			.collect(Collectors.toList());
+	}
+
+	private void validate(List<Integer> numbers) {
+		validateNotNull(numbers);
+		validateSize(numbers);
+		validateDuplicate(numbers);
+		validateRange(numbers);
+	}
+
+	private void validateNotNull(List<Integer> numbers) {
+		if (numbers == null) {
+			throw new IllegalArgumentException("[ERROR] 로또 번호를 입력해주세요.");
+		}
+	}
+
+	private void validateSize(List<Integer> numbers) {
+		if (numbers.size() != LOTTO_NUMBER_COUNT) {
+			throw new IllegalArgumentException("[ERROR] 로또 번호는 6개여야 합니다.");
+		}
+	}
+
+	private void validateDuplicate(List<Integer> numbers) {
+		if (numbers.size() != new HashSet<>(numbers).size()) {
+			throw new IllegalArgumentException("[ERROR] 로또 번호는 중복될 수 없습니다.");
+		}
+	}
+
+	private void validateRange(List<Integer> numbers) {
+		boolean isOutOfRange = numbers.stream()
+			.anyMatch(number -> number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER);
+
+		if (isOutOfRange) {
+			throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+		}
+	}
+
+	public List<Integer> getNumbers() {
+		return numbers;
+	}
+
+	public int countMatches(List<Integer> winningNumbers) {
+		return (int) numbers.stream()
+			.filter(winningNumbers::contains)
+			.count();
+	}
+
+	public boolean contains(int number) {
+		return numbers.contains(number);
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/domain/WinningLotto.java b/src/main/java/lotto/domain/WinningLotto.java
new file mode 100644
index 0000000000..c38ccaf75b
--- /dev/null
+++ b/src/main/java/lotto/domain/WinningLotto.java
@@ -0,0 +1,56 @@
+package lotto.domain;
+
+import java.util.List;
+import java.util.Objects;
+
+public class WinningLotto {
+	private static final int MIN_LOTTO_NUMBER = 1;
+	private static final int MAX_LOTTO_NUMBER = 45;
+	private final Lotto winningNumbers;
+	private final int bonusNumber;
+
+	public WinningLotto(Lotto winningNumbers, int bonusNumber) {
+		validate(winningNumbers, bonusNumber);
+		this.winningNumbers = winningNumbers;
+		this.bonusNumber = bonusNumber;
+	}
+
+	private void validate(Lotto winningNumbers, int bonusNumber) {
+		validateNotNull(winningNumbers);
+		validateBonusNumberRange(bonusNumber);
+		validateDuplicateWithWinningNumbers(winningNumbers, bonusNumber);
+	}
+
+	private void validateNotNull(Lotto winningNumbers) {
+		if (Objects.isNull(winningNumbers)) {
+			throw new IllegalArgumentException("[ERROR] 당첨 번호를 입력해주세요.");
+		}
+	}
+
+	private void validateBonusNumberRange(int bonusNumber) {
+		if (bonusNumber < MIN_LOTTO_NUMBER || bonusNumber > MAX_LOTTO_NUMBER) {
+			throw new IllegalArgumentException("[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.");
+		}
+	}
+
+	private void validateDuplicateWithWinningNumbers(Lotto winningNumbers, int bonusNumber) {
+		if (winningNumbers.contains(bonusNumber)) {
+			throw new IllegalArgumentException("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+		}
+	}
+
+	/**
+	 * 구매한 로또와 당첨 번호를 비교하여 등수를 반환합니다.
+	 */
+	public Rank match(Lotto userLotto) {
+		// 1. 일치하는 번호 개수 계산
+		List<Integer> numbers = winningNumbers.getNumbers();
+		int matchCount = userLotto.countMatches(numbers);
+
+		// 2. 보너스 번호 일치 여부 확인
+		boolean matchBonus = userLotto.contains(bonusNumber);
+
+		// 3. Rank Enum을 통해 등수 판별
+		return Rank.valueOf(matchCount, matchBonus);
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/LottoTest.java b/src/test/java/lotto/LottoTest.java
deleted file mode 100644
index 309f4e50ae..0000000000
--- a/src/test/java/lotto/LottoTest.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package lotto;
-
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-class LottoTest {
-    @Test
-    void 로또_번호의_개수가_6개가_넘어가면_예외가_발생한다() {
-        assertThatThrownBy(() -> new Lotto(List.of(1, 2, 3, 4, 5, 6, 7)))
-                .isInstanceOf(IllegalArgumentException.class);
-    }
-
-    @DisplayName("로또 번호에 중복된 숫자가 있으면 예외가 발생한다.")
-    @Test
-    void 로또_번호에_중복된_숫자가_있으면_예외가_발생한다() {
-        assertThatThrownBy(() -> new Lotto(List.of(1, 2, 3, 4, 5, 5)))
-                .isInstanceOf(IllegalArgumentException.class);
-    }
-
-    // TODO: 추가 기능 구현에 따른 테스트 코드 작성
-}
diff --git a/src/test/java/lotto/domain/LottoTest.java b/src/test/java/lotto/domain/LottoTest.java
new file mode 100644
index 0000000000..b13319038a
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoTest.java
@@ -0,0 +1,147 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LottoTest {
+
+	@DisplayName("정상1: 로또 번호 6개를 저장한다")
+	@Test
+	void test1() {
+		List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
+
+		Lotto lotto = new Lotto(numbers);  // 전체 경로 제거
+		assertThat(lotto.getNumbers()).hasSize(6);
+		assertThat(lotto.getNumbers()).containsExactly(1, 2, 3, 4, 5, 6);
+	}
+
+	@DisplayName("정상2: 로또 번호는 1~45 범위의 중복되지 않는 숫자이다")
+	@Test
+	void test2() {
+		List<Integer> numbers = List.of(1, 15, 23, 32, 41, 45);
+
+		Lotto lotto = new Lotto(numbers);
+		assertThat(lotto.getNumbers()).allMatch(num -> num >= 1 && num <= 45);
+	}
+
+	@DisplayName("정상3: 로또 번호를 오름차순으로 정렬하여 반환한다")
+	@Test
+	void test3() {
+		List<Integer> numbers = List.of(45, 1, 32, 15, 23, 8);
+
+		Lotto lotto = new Lotto(numbers);
+		assertThat(lotto.getNumbers()).containsExactly(1, 8, 15, 23, 32, 45);
+	}
+
+	@DisplayName("정상4: 주어진 번호 리스트와 일치하는 개수를 반환한다")
+	@Test
+	void test4() {
+		Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+		List<Integer> winningNumbers = List.of(1, 2, 3, 7, 8, 9);
+
+		int matchCount = lotto.countMatches(winningNumbers);
+		assertThat(matchCount).isEqualTo(3);
+	}
+
+	@DisplayName("정상5: 일치하는 번호가 없을 때 0을 반환한다")
+	@Test
+	void test5() {
+		Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+		List<Integer> winningNumbers = List.of(7, 8, 9, 10, 11, 12);
+
+		int matchCount = lotto.countMatches(winningNumbers);
+		assertThat(matchCount).isEqualTo(0);
+	}
+
+	@DisplayName("정상6: 모든 번호가 일치할 때 6을 반환한다")
+	@Test
+	void test6() {
+		Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+		List<Integer> winningNumbers = List.of(1, 2, 3, 4, 5, 6);
+
+		int matchCount = lotto.countMatches(winningNumbers);
+		assertThat(matchCount).isEqualTo(6);
+	}
+
+	@DisplayName("정상7: 특정 번호 포함 여부를 확인한다 - 포함하는 경우")
+	@Test
+	void test7() {
+		Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+		assertThat(lotto.contains(1)).isTrue();
+		assertThat(lotto.contains(3)).isTrue();
+		assertThat(lotto.contains(6)).isTrue();
+	}
+
+	@DisplayName("정상8: 특정 번호 포함 여부를 확인한다 - 포함하지 않는 경우")
+	@Test
+	void test8() {
+		Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+		assertThat(lotto.contains(7)).isFalse();
+		assertThat(lotto.contains(45)).isFalse();
+	}
+
+	@DisplayName("예외1: 로또 번호가 null이면 예외가 발생한다")
+	@Test
+	void test9() {
+		assertThatThrownBy(() -> new Lotto(null))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("[ERROR]");
+	}
+
+	@DisplayName("예외2: 로또 번호의 개수가 6개가 넘어가면 예외가 발생한다")
+	@Test
+	void test10() {
+		assertThatThrownBy(() -> new Lotto(List.of(1,2,3,4,5,6,7)))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 6개여야 합니다.");
+	}
+
+	@DisplayName("예외3: 로또 번호의 개수가 6개 미만이면 예외가 발생한다")
+	@Test
+	void test11() {
+		assertThatThrownBy(() -> new Lotto(List.of(1,2,3,4,5)))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 6개여야 합니다.");
+	}
+
+	@Tag("error")
+	@DisplayName("예외4: 로또 번호에 중복된 숫자가 있으면 예외가 발생한다")
+	@Test
+	void test12() {
+		assertThatThrownBy(() -> new Lotto(List.of(1,2,3,4,5,5)))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 중복될 수 없습니다.");
+	}
+
+	@DisplayName("예외5: 로또 번호가 1보다 작으면 예외가 발생한다")
+	@Test
+	void test13() {
+		assertThatThrownBy(() -> new Lotto(List.of(0,1,2,3,4,5)))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+	}
+
+	@DisplayName("예외6: 로또 번호가 45보다 크면 예외가 발생한다")
+	@Test
+	void test14() {
+		assertThatThrownBy(() -> new Lotto(List.of(1,2,3,4,5,46)))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+	}
+
+	@DisplayName("예외7: 로또 번호가 음수이면 예외가 발생한다")
+	@Test
+	void test15() {
+		assertThatThrownBy(() -> new Lotto(List.of(-1,1,2,3,4,5)))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+	}
+}
diff --git a/src/test/java/lotto/domain/RankTest.java b/src/test/java/lotto/domain/RankTest.java
index 29e91688fe..3979fb8e3f 100644
--- a/src/test/java/lotto/domain/RankTest.java
+++ b/src/test/java/lotto/domain/RankTest.java
@@ -11,7 +11,7 @@ class RankTest {
 
 	@DisplayName("1: 6개 일치하면 1등")
 	@Test
-	void test1MatchSixNumbers() {
+	void test1() {
 		Rank rank = Rank.valueOf(6, false);
 
 		assertThat(rank).isEqualTo(Rank.FIRST);
@@ -20,7 +20,7 @@ void test1MatchSixNumbers() {
 
 	@DisplayName("2: 5개 일치하고 보너스볼 일치하면 2등")
 	@Test
-	void test2MatchFiveNumbersWithBonus() {
+	void test2() {
 		Rank rank = Rank.valueOf(5, true);
 
 		assertThat(rank).isEqualTo(Rank.SECOND);
@@ -29,7 +29,7 @@ void test2MatchFiveNumbersWithBonus() {
 
 	@DisplayName("3: 5개 일치하고 보너스볼 불일치하면 3등")
 	@Test
-	void test3MatchFiveNumbersWithoutBonus() {
+	void test3() {
 		Rank rank = Rank.valueOf(5, false);
 
 		assertThat(rank).isEqualTo(Rank.THIRD);
@@ -38,7 +38,7 @@ void test3MatchFiveNumbersWithoutBonus() {
 
 	@DisplayName("4: 4개 일치하면 4등")
 	@Test
-	void test4MatchFourNumbers() {
+	void test4() {
 		Rank rank = Rank.valueOf(4, false);
 
 		assertThat(rank).isEqualTo(Rank.FOURTH);
@@ -47,7 +47,7 @@ void test4MatchFourNumbers() {
 
 	@DisplayName("5: 3개 일치하면 5등")
 	@Test
-	void test5MatchThreeNumbers() {
+	void test5() {
 		Rank rank = Rank.valueOf(3, false);
 
 		assertThat(rank).isEqualTo(Rank.FIFTH);
@@ -57,7 +57,7 @@ void test5MatchThreeNumbers() {
 	@DisplayName("6: 2개 이하 일치하면 NONE")
 	@ParameterizedTest
 	@CsvSource({"0, false", "1, false", "2, false"})
-	void test6MatchLessThanThree(int matchCount, boolean matchBonus) {
+	void test6(int matchCount, boolean matchBonus) {
 		Rank rank = Rank.valueOf(matchCount, matchBonus);
 
 		assertThat(rank).isEqualTo(Rank.NONE);
@@ -66,7 +66,7 @@ void test6MatchLessThanThree(int matchCount, boolean matchBonus) {
 
 	@DisplayName("7: 당첨 여부 확인")
 	@Test
-	void test7IsWinning() {
+	void test7() {
 		assertThat(Rank.FIRST.isWinning()).isTrue();
 		assertThat(Rank.SECOND.isWinning()).isTrue();
 		assertThat(Rank.THIRD.isWinning()).isTrue();
diff --git a/src/test/java/lotto/domain/WinningLottoTest.java b/src/test/java/lotto/domain/WinningLottoTest.java
new file mode 100644
index 0000000000..ae043781ae
--- /dev/null
+++ b/src/test/java/lotto/domain/WinningLottoTest.java
@@ -0,0 +1,134 @@
+package lotto.domain;
+
+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;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class WinningLottoTest {
+
+	private final Lotto validWinningLottoNumbers = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+	@DisplayName("정상1: 당첨 번호 6개와 보너스 번호 1개를 저장한다")
+	@Test
+	void test1() {
+		// Given
+		int bonusNumber = 7;
+
+		// When
+		WinningLotto winningLotto = new WinningLotto(validWinningLottoNumbers, bonusNumber);
+
+		// Then (내부 필드에 대한 직접적인 getter는 없지만, 검증 로직 통과 여부로 확인)
+		assertThat(winningLotto).isNotNull();
+	}
+
+	@DisplayName("정상2: 로또와 비교하여 등수를 판별한다 - 1등")
+	@Test
+	void test2() {
+		// Given: 1, 2, 3, 4, 5, 6 (당첨 번호), 7 (보너스)
+		WinningLotto winningLotto = new WinningLotto(validWinningLottoNumbers, 7);
+		// When: 1, 2, 3, 4, 5, 6 (6개 일치)
+		Lotto userLotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+		// Then
+		assertThat(winningLotto.match(userLotto)).isEqualTo(Rank.FIRST);
+	}
+
+	@DisplayName("정상3: 로또와 비교하여 등수를 판별한다 - 2등")
+	@Test
+	void test3() {
+		// Given: 1, 2, 3, 4, 5, 6 (당첨 번호), 7 (보너스)
+		WinningLotto winningLotto = new WinningLotto(validWinningLottoNumbers, 7);
+		// When: 1, 2, 3, 4, 5, 7 (5개 일치, 보너스 일치)
+		Lotto userLotto = new Lotto(List.of(1, 2, 3, 4, 5, 7));
+
+		// Then
+		assertThat(winningLotto.match(userLotto)).isEqualTo(Rank.SECOND);
+	}
+
+	@DisplayName("정상4: 로또와 비교하여 등수를 판별한다 - 3등")
+	@Test
+	void test4() {
+		// Given: 1, 2, 3, 4, 5, 6 (당첨 번호), 7 (보너스)
+		WinningLotto winningLotto = new WinningLotto(validWinningLottoNumbers, 7);
+		// When: 1, 2, 3, 4, 5, 8 (5개 일치, 보너스 불일치)
+		Lotto userLotto = new Lotto(List.of(1, 2, 3, 4, 5, 8));
+
+		// Then
+		assertThat(winningLotto.match(userLotto)).isEqualTo(Rank.THIRD);
+	}
+
+	@DisplayName("정상5: 로또와 비교하여 등수를 판별한다 - 5등")
+	@Test
+	void test5() {
+		// Given: 1, 2, 3, 4, 5, 6 (당첨 번호), 7 (보너스)
+		WinningLotto winningLotto = new WinningLotto(validWinningLottoNumbers, 7);
+		// When: 1, 2, 3, 8, 9, 10 (3개 일치)
+		Lotto userLotto = new Lotto(List.of(1, 2, 3, 8, 9, 10));
+
+		// Then
+		assertThat(winningLotto.match(userLotto)).isEqualTo(Rank.FIFTH);
+	}
+
+	@DisplayName("정상6: 로또와 비교하여 등수를 판별한다 - 꽝 (NONE)")
+	@ParameterizedTest(name = "{0}개 일치 시 NONE")
+	@CsvSource({"0", "1", "2"})
+	void test6(int matchCount) {
+		// Given: 1, 2, 3, 4, 5, 6 (당첨 번호), 7 (보너스)
+		WinningLotto winningLotto = new WinningLotto(validWinningLottoNumbers, 7);
+
+		// When: matchCount에 맞게 로또 생성 (보너스 번호와도 불일치하게)
+		List<Integer> lottoNumbers = List.of(1, 2, 3, 4, 5, 6).subList(0, matchCount);
+		lottoNumbers = new java.util.ArrayList<>(lottoNumbers);
+		// 나머지 번호를 7, 8, ...로 채워서 보너스 번호(7)와도 겹치지 않게 함
+		for (int i = 0; lottoNumbers.size() < 6; i++) {
+			lottoNumbers.add(8 + i);
+		}
+		Lotto userLotto = new Lotto(lottoNumbers);
+
+		// Then
+		assertThat(winningLotto.match(userLotto)).isEqualTo(Rank.NONE);
+	}
+
+	// 예외 테스트
+	@DisplayName("예외1: 당첨 번호가 null이면 IllegalArgumentException 발생")
+	@Test
+	void test7() {
+		assertThatThrownBy(() -> new WinningLotto(null, 7))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("[ERROR] 당첨 번호를 입력해주세요.");
+	}
+
+	@DisplayName("예외2: 보너스 번호가 당첨 번호와 중복되면 IllegalArgumentException 발생")
+	@Test
+	void test8() {
+		// 당첨 번호: 1, 2, 3, 4, 5, 6
+		int bonusNumber = 6; // 중복
+		assertThatThrownBy(() -> new WinningLotto(validWinningLottoNumbers, bonusNumber))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+	}
+
+	@DisplayName("예외3: 보너스 번호가 1보다 작으면 IllegalArgumentException 발생")
+	@Test
+	void test9() {
+		int bonusNumber = 0;
+		assertThatThrownBy(() -> new WinningLotto(validWinningLottoNumbers, bonusNumber))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.");
+	}
+
+	@DisplayName("예외4: 보너스 번호가 45보다 크면 IllegalArgumentException 발생")
+	@Test
+	void test10() {
+		int bonusNumber = 46;
+		assertThatThrownBy(() -> new WinningLotto(validWinningLottoNumbers, bonusNumber))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.");
+	}
+}
\ No newline at end of file

From 84c4e5ac87b74870b7613adc7124ebb96cf3d676 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 21:46:35 +0900
Subject: [PATCH 05/21] =?UTF-8?q?feat(domain):=20LottoTickets=20=EA=B0=9D?=
 =?UTF-8?q?=EC=B2=B4=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/domain/LottoTickets.java  | 48 +++++++++++
 .../java/lotto/domain/LottoTicketsTest.java   | 79 +++++++++++++++++++
 .../java/lotto/domain/WinningLottoTest.java   |  4 +-
 3 files changed, 129 insertions(+), 2 deletions(-)
 create mode 100644 src/main/java/lotto/domain/LottoTickets.java
 create mode 100644 src/test/java/lotto/domain/LottoTicketsTest.java

diff --git a/src/main/java/lotto/domain/LottoTickets.java b/src/main/java/lotto/domain/LottoTickets.java
new file mode 100644
index 0000000000..3540e446c0
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoTickets.java
@@ -0,0 +1,48 @@
+package lotto.domain;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class LottoTickets {
+	private static final int MIN_LOTTO_COUNT = 1;
+
+	private final List<Lotto> lottos;
+
+	public LottoTickets(List<Lotto> lottos) {
+		if (Objects.isNull(lottos)) {
+			throw new IllegalArgumentException("[ERROR] 로또 목록이 없습니다.");
+		}
+
+		if (lottos.size() < MIN_LOTTO_COUNT) {
+			throw new IllegalArgumentException("[ERROR] 최소 1개 이상의 로또를 구매해야 합니다.");
+		}
+
+		this.lottos = lottos;
+	}
+
+	/**
+	 * 구매한 로또의 개수를 반환합니다.
+	 */
+	public int getLottoCount() {
+		return lottos.size();
+	}
+
+	/**
+	 * 모든 로또를 반환합니다.
+	 */
+	public List<Lotto> getLottos() {
+		return Collections.unmodifiableList(lottos);
+	}
+
+	// public LottoResult compareWithWinningLotto(WinningLotto winningLotto, int purchaseAmount) {
+	// 	// 모든 로또의 당첨 등수를 계산합니다.
+	// 	List<Rank> ranks = lottos.stream()
+	// 		.map(winningLotto::match)
+	// 		.collect(Collectors.toList());
+	//
+	// 	// LottoResult 객체를 생성하여 등수별 개수 및 수익률을 관리합니다.
+	// 	return new LottoResult(ranks, purchaseAmount);
+	// }
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/domain/LottoTicketsTest.java b/src/test/java/lotto/domain/LottoTicketsTest.java
new file mode 100644
index 0000000000..119034c94a
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoTicketsTest.java
@@ -0,0 +1,79 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LottoTicketsTest {
+
+	private final Lotto lotto1 = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+	private final Lotto lotto2 = new Lotto(List.of(7, 8, 9, 10, 11, 12));
+	private final List<Lotto> validLottoList = List.of(lotto1, lotto2);
+
+	@DisplayName("정상1: 여러 개의 로또를 관리하는 객체를 생성한다")
+	@Test
+	void test1() {
+		// When
+		LottoTickets lottoTickets = new LottoTickets(validLottoList);
+
+		// Then
+		assertThat(lottoTickets).isNotNull();
+		assertThat(lottoTickets.getLottoCount()).isEqualTo(2);
+		assertThat(lottoTickets.getLottos()).containsExactly(lotto1, lotto2);
+	}
+
+	@DisplayName("정상2: 구매한 로또 개수를 정확히 반환한다")
+	@Test
+	void test2() {
+		// When
+		LottoTickets lottoTickets = new LottoTickets(validLottoList);
+
+		// Then
+		assertThat(lottoTickets.getLottoCount()).isEqualTo(2);
+	}
+
+	// @DisplayName("정상3: 당첨 번호와 비교하여 각 로또의 등수를 판별하고 LottoResult를 반환한다")
+	// @Test
+	// void test3() {
+	// 	// Given
+	// 	// lotto1: 1, 2, 3, 4, 5, 6 (당첨 번호와 6개 일치 -> 1등)
+	// 	// lotto2: 7, 8, 9, 10, 11, 12 (당첨 번호와 0개 일치 -> 꽝)
+	// 	LottoTickets lottoTickets = new LottoTickets(validLottoList);
+	// 	WinningLotto winningLotto = new WinningLotto(lotto1, 7); // 1~6 당첨, 보너스 7
+	// 	int purchaseAmount = 2000;
+	//
+	// 	// When
+	// 	LottoResult result = lottoTickets.compareWithWinningLotto(winningLotto, purchaseAmount);
+	//
+	// 	// Then (LottoResult의 내부 구현에 따라 검증)
+	// 	// 1등 1개, 꽝 1개 예상
+	// 	assertThat(result.getPrizeCount(Rank.FIRST)).isEqualTo(1);
+	// 	assertThat(result.getPrizeCount(Rank.NONE)).isEqualTo(1);
+	//
+	// 	// 주의: LottoResult 클래스가 아직 구현되지 않았으므로,
+	// 	// 이 테스트는 LottoResult 구현 후 성공적으로 빌드될 수 있습니다.
+	// 	// 현재는 LottoResult 객체가 성공적으로 생성되는지만 확인합니다.
+	// 	assertThat(result).isInstanceOf(LottoResult.class);
+	// }
+
+	@DisplayName("예외1: 로또 리스트가 null이면 예외가 발생한다")
+	@Test
+	void test4() {
+		assertThatThrownBy(() -> new LottoTickets(null))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 목록이 없습니다.");
+	}
+
+	@DisplayName("예외2: 로또 리스트가 비어있으면 예외가 발생한다")
+	@Test
+	void test5() {
+		assertThatThrownBy(() -> new LottoTickets(Collections.emptyList()))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 최소 1개 이상의 로또를 구매해야 합니다.");
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/domain/WinningLottoTest.java b/src/test/java/lotto/domain/WinningLottoTest.java
index ae043781ae..b62c32889f 100644
--- a/src/test/java/lotto/domain/WinningLottoTest.java
+++ b/src/test/java/lotto/domain/WinningLottoTest.java
@@ -23,7 +23,7 @@ void test1() {
 		// When
 		WinningLotto winningLotto = new WinningLotto(validWinningLottoNumbers, bonusNumber);
 
-		// Then (내부 필드에 대한 직접적인 getter는 없지만, 검증 로직 통과 여부로 확인)
+		// Then
 		assertThat(winningLotto).isNotNull();
 	}
 
@@ -108,7 +108,7 @@ void test7() {
 	@Test
 	void test8() {
 		// 당첨 번호: 1, 2, 3, 4, 5, 6
-		int bonusNumber = 6; // 중복
+		int bonusNumber = 6;
 		assertThatThrownBy(() -> new WinningLotto(validWinningLottoNumbers, bonusNumber))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessageContaining("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");

From 6f1840518e79c0ffb89524b95f845de360d361ee Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 22:05:12 +0900
Subject: [PATCH 06/21] =?UTF-8?q?feat(domain):=20LottoResult=20=EA=B0=9D?=
 =?UTF-8?q?=EC=B2=B4=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/domain/LottoResult.java   | 60 ++++++++++++++++
 .../java/lotto/domain/LottoResultTest.java    | 70 +++++++++++++++++++
 2 files changed, 130 insertions(+)
 create mode 100644 src/main/java/lotto/domain/LottoResult.java
 create mode 100644 src/test/java/lotto/domain/LottoResultTest.java

diff --git a/src/main/java/lotto/domain/LottoResult.java b/src/main/java/lotto/domain/LottoResult.java
new file mode 100644
index 0000000000..2eca5aa286
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoResult.java
@@ -0,0 +1,60 @@
+package lotto.domain;
+
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class LottoResult {
+	private static final int MIN_PURCHASE_AMOUNT = 1;
+	private static final String PROFIT_RATE_FORMAT = "%.1f";
+
+	private final Map<Rank, Integer> result;
+	private final int purchaseAmount;
+
+	public LottoResult(List<Rank> ranks, int purchaseAmount) {
+		if (purchaseAmount < MIN_PURCHASE_AMOUNT) {
+			throw new IllegalArgumentException("[ERROR] 구매 금액은 0보다 커야 합니다.");
+		}
+		this.purchaseAmount = purchaseAmount;
+		this.result = countRanks(ranks);
+	}
+
+	private Map<Rank, Integer> countRanks(List<Rank> ranks) {
+		Map<Rank, Integer> counts = new EnumMap<>(Rank.class);
+
+		// NONE 등수를 제외한 모든 당첨 등수를 미리 0으로 초기화
+		for (Rank rank : Rank.values()) {
+			if (rank.isWinning()) {
+				counts.put(rank, 0);
+			}
+		}
+
+		// 실제 당첨 등수의 개수를 카운트
+		ranks.stream()
+			.filter(Rank::isWinning)
+			.forEach(rank -> counts.merge(rank, 1, Integer::sum));
+
+		return counts;
+	}
+
+	public int getPrizeCount(Rank rank) {
+		return result.getOrDefault(rank, 0);
+	}
+
+	public long calculateTotalProfit() {
+		return result.entrySet().stream()
+			.mapToLong(entry -> (long) entry.getKey().getPrize() * entry.getValue())
+			.sum();
+	}
+
+	/**
+	 * 총 수익률을 계산합니다. (소수점 둘째 자리에서 반올림하여 첫째 자리까지 표시)
+	 * 예: 62.5%, 100.0%
+	 */
+	public String calculateProfitRate() {
+		long totalProfit = calculateTotalProfit();
+		double profitRate = (double) totalProfit * 100 / purchaseAmount;
+
+		return String.format(PROFIT_RATE_FORMAT, profitRate);
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/domain/LottoResultTest.java b/src/test/java/lotto/domain/LottoResultTest.java
new file mode 100644
index 0000000000..dd07841aff
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoResultTest.java
@@ -0,0 +1,70 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LottoResultTest {
+
+	@DisplayName("정상1: 등수별 당첨 개수를 정확히 저장한다")
+	@Test
+	void test1() {
+		// Given
+		List<Rank> ranks = List.of(Rank.THIRD, Rank.THIRD, Rank.FIFTH, Rank.NONE);
+
+		// When
+		LottoResult result = new LottoResult(ranks, 4000);
+
+		// Then
+		assertThat(result.getPrizeCount(Rank.THIRD)).isEqualTo(2);
+		assertThat(result.getPrizeCount(Rank.FIFTH)).isEqualTo(1);
+		assertThat(result.getPrizeCount(Rank.FOURTH)).isEqualTo(0);
+		assertThat(result.getPrizeCount(Rank.NONE)).isEqualTo(0);
+	}
+
+	@DisplayName("정상2: 총 수익금을 정확하게 계산한다")
+	@Test
+	void test2() {
+		// 1등 1개 (20억) + 3등 1개 (150만) = 2,001,500,000
+		LottoResult result = new LottoResult(List.of(Rank.FIRST, Rank.THIRD), 8000);
+
+		long expectedProfit = 2_000_000_000L + 1_500_000L;
+
+		assertThat(result.calculateTotalProfit()).isEqualTo(expectedProfit);
+	}
+
+	@DisplayName("정상3: 수익률 계산 (반올림 테스트 1) - 66.666..% -> 66.7%")
+	@Test
+	void test3() {
+		// Given: 3000원 구매, 2000원 당첨
+		int amount = 3000;
+		int profit = 2000;
+
+		// When
+		double profitRate = (double) profit * 100 / amount;
+		String formattedRate = String.format("%.1f", profitRate);
+
+		// Then
+		assertThat(formattedRate).isEqualTo("66.7");
+	}
+
+	@DisplayName("예외1: 구매 금액이 0이면 예외가 발생한다")
+	@Test
+	void test6() {
+		assertThatThrownBy(() -> new LottoResult(List.of(Rank.FIFTH), 0))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구매 금액은 0보다 커야 합니다.");
+	}
+
+	@DisplayName("예외2: 구매 금액이 음수이면 예외가 발생한다")
+	@Test
+	void test7() {
+		assertThatThrownBy(() -> new LottoResult(List.of(Rank.FIFTH), -1000))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구매 금액은 0보다 커야 합니다.");
+	}
+}
\ No newline at end of file

From cc1c7f4f5a68b42cd3af03dbfd8154caa7e88b15 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 22:21:58 +0900
Subject: [PATCH 07/21] =?UTF-8?q?feat(parser):=20=EA=B5=AC=EB=A7=A4=20?=
 =?UTF-8?q?=EA=B8=88=EC=95=A1=20=ED=8C=8C=EC=8B=B1=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../lotto/parser/PurchaseAmountParser.java    | 21 +++++++
 .../parser/PurchaseAmountParserTest.java      | 56 +++++++++++++++++++
 2 files changed, 77 insertions(+)
 create mode 100644 src/main/java/lotto/parser/PurchaseAmountParser.java
 create mode 100644 src/test/java/lotto/parser/PurchaseAmountParserTest.java

diff --git a/src/main/java/lotto/parser/PurchaseAmountParser.java b/src/main/java/lotto/parser/PurchaseAmountParser.java
new file mode 100644
index 0000000000..d47dd6fba7
--- /dev/null
+++ b/src/main/java/lotto/parser/PurchaseAmountParser.java
@@ -0,0 +1,21 @@
+package lotto.parser;
+
+import java.util.Objects;
+
+public class PurchaseAmountParser {
+
+	public static int parse(String input) {
+		if (input == null || input.trim().isEmpty()) {
+			throw new IllegalArgumentException("[ERROR] 구입 금액을 입력해주세요.");
+		}
+		return parseToInteger(input);
+	}
+
+	private static int parseToInteger(String input) {
+		try {
+			return Integer.parseInt(input);
+		} catch (NumberFormatException e) {
+			throw new NumberFormatException("[ERROR] 구입 금액은 숫자여야 합니다.");
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/parser/PurchaseAmountParserTest.java b/src/test/java/lotto/parser/PurchaseAmountParserTest.java
new file mode 100644
index 0000000000..9200c6652e
--- /dev/null
+++ b/src/test/java/lotto/parser/PurchaseAmountParserTest.java
@@ -0,0 +1,56 @@
+package lotto.parser;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class PurchaseAmountParserTest {
+
+	@DisplayName("정상1: 유효한 문자열 금액을 정수로 파싱한다")
+	@Test
+	void test1() {
+		// Given
+		String input = "8000";
+
+		// When
+		int result = PurchaseAmountParser.parse(input);
+
+		// Then
+		assertThat(result).isEqualTo(8000);
+	}
+
+	@DisplayName("예외1: 입력이 null이면 IllegalArgumentException 발생")
+	@Test
+	void test2() {
+		String input = null;
+
+		assertThatThrownBy(() -> PurchaseAmountParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액을 입력해주세요.");
+	}
+
+	@Tag("error")
+	@DisplayName("예외2: 입력이 빈 문자열 또는 공백이면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"", " "})
+	void test3(String input) {
+		assertThatThrownBy(() -> PurchaseAmountParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액을 입력해주세요.");
+	}
+
+	@Tag("error")
+	@DisplayName("예외3: 숫자가 아닌 문자가 포함되면 NumberFormatException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"1000원", "a1000", "1,000"})
+	void test4(String input) {
+		assertThatThrownBy(() -> PurchaseAmountParser.parse(input))
+			.isInstanceOf(NumberFormatException.class)
+			.hasMessage("[ERROR] 구입 금액은 숫자여야 합니다.");
+	}
+}
\ No newline at end of file

From 9194306ff545f22a50599f76f4ea32bbb8aadd8f Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 22:23:22 +0900
Subject: [PATCH 08/21] =?UTF-8?q?feat(parser):=20=EA=B5=AC=EB=A7=A4=20?=
 =?UTF-8?q?=EA=B8=88=EC=95=A1=20=ED=8C=8C=EC=8B=B1=20=EA=B5=AC=ED=98=84=20?=
 =?UTF-8?q?trim()=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/lotto/parser/PurchaseAmountParser.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/lotto/parser/PurchaseAmountParser.java b/src/main/java/lotto/parser/PurchaseAmountParser.java
index d47dd6fba7..720075c090 100644
--- a/src/main/java/lotto/parser/PurchaseAmountParser.java
+++ b/src/main/java/lotto/parser/PurchaseAmountParser.java
@@ -8,7 +8,7 @@ public static int parse(String input) {
 		if (input == null || input.trim().isEmpty()) {
 			throw new IllegalArgumentException("[ERROR] 구입 금액을 입력해주세요.");
 		}
-		return parseToInteger(input);
+		return parseToInteger(input.trim());
 	}
 
 	private static int parseToInteger(String input) {

From e655f23647d835154ad5b06972037f8648cf2df6 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 22:23:45 +0900
Subject: [PATCH 09/21] =?UTF-8?q?feat(parser):=20=EA=B5=AC=EB=A7=A4=20?=
 =?UTF-8?q?=EA=B8=88=EC=95=A1=20=ED=8C=8C=EC=8B=B1=20=EA=B5=AC=ED=98=84=20?=
 =?UTF-8?q?=ED=95=84=EC=9A=94=EC=97=86=EB=8A=94=20import=20=EC=A0=9C?=
 =?UTF-8?q?=EA=B1=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/parser/PurchaseAmountParser.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/main/java/lotto/parser/PurchaseAmountParser.java b/src/main/java/lotto/parser/PurchaseAmountParser.java
index 720075c090..0ffeb12f29 100644
--- a/src/main/java/lotto/parser/PurchaseAmountParser.java
+++ b/src/main/java/lotto/parser/PurchaseAmountParser.java
@@ -1,7 +1,5 @@
 package lotto.parser;
 
-import java.util.Objects;
-
 public class PurchaseAmountParser {
 
 	public static int parse(String input) {

From 6db568b2244a755bb2ec9e9e1cd4e9ed7ce766df Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 22:35:18 +0900
Subject: [PATCH 10/21] =?UTF-8?q?feat(parser):=20=EB=8B=B9=EC=B2=A8=20?=
 =?UTF-8?q?=EB=B2=88=ED=98=B8=20=ED=8C=8C=EC=8B=B1=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../lotto/parser/WinningNumbersParser.java    | 53 +++++++++++++
 .../parser/WinningNumbersParserTest.java      | 76 +++++++++++++++++++
 2 files changed, 129 insertions(+)
 create mode 100644 src/main/java/lotto/parser/WinningNumbersParser.java
 create mode 100644 src/test/java/lotto/parser/WinningNumbersParserTest.java

diff --git a/src/main/java/lotto/parser/WinningNumbersParser.java b/src/main/java/lotto/parser/WinningNumbersParser.java
new file mode 100644
index 0000000000..c578b87198
--- /dev/null
+++ b/src/main/java/lotto/parser/WinningNumbersParser.java
@@ -0,0 +1,53 @@
+package lotto.parser;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class WinningNumbersParser {
+	private static final String SEPARATOR = ",";
+
+	/**
+	 * 사용자 입력 문자열(당첨 번호)을 정수 리스트로 파싱하여 반환합니다.
+	 *
+	 * @param input 사용자가 입력한 당첨 번호 문자열 (쉼표로 구분됨)
+	 * @return 파싱된 당첨 번호 리스트 (정수)
+	 * @throws IllegalArgumentException 입력이 null, 빈 문자열, 또는 쉼표 구분 형식이 아닌 경우
+	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
+	 */
+	public static List<Integer> parse(String input) {
+		validateNotNullOrEmpty(input);
+
+		List<String> numberStrings = splitBySeparator(input);
+		return parseToIntegers(numberStrings);
+	}
+
+	private static void validateNotNullOrEmpty(String input) {
+		if (Objects.isNull(input) || input.trim().isEmpty()) {
+			throw new IllegalArgumentException("[ERROR] 당첨 번호를 입력해주세요.");
+		}
+	}
+
+	private static List<String> splitBySeparator(String input) {
+		List<String> parts = Arrays.stream(input.split(SEPARATOR, -1))
+			.map(String::trim)
+			.collect(Collectors.toList());
+
+		if (parts.stream().anyMatch(String::isEmpty)) {
+			throw new IllegalArgumentException("[ERROR] 당첨 번호는 빈 값일 수 없습니다.");
+		}
+
+		return parts;
+	}
+
+	private static List<Integer> parseToIntegers(List<String> numberStrings) {
+		try {
+			return numberStrings.stream()
+				.map(Integer::parseInt)
+				.collect(Collectors.toList());
+		} catch (NumberFormatException e) {
+			throw new NumberFormatException("[ERROR] 당첨 번호는 숫자여야 합니다.");
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/parser/WinningNumbersParserTest.java b/src/test/java/lotto/parser/WinningNumbersParserTest.java
new file mode 100644
index 0000000000..84cdcab7df
--- /dev/null
+++ b/src/test/java/lotto/parser/WinningNumbersParserTest.java
@@ -0,0 +1,76 @@
+package lotto.parser;
+
+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;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class WinningNumbersParserTest {
+
+
+	@DisplayName("정상1: 쉼표로 구분된 문자열을 정수 리스트로 파싱한다")
+	@Test
+	void test1() {
+		// Given
+		String input = "1,2,3,4,5,6";
+
+		// When
+		List<Integer> result = WinningNumbersParser.parse(input);
+
+		// Then
+		assertThat(result).containsExactly(1, 2, 3, 4, 5, 6);
+	}
+
+	@DisplayName("예외1: 입력이 null이면 IllegalArgumentException 발생")
+	@Test
+	void test2() {
+		String input = null;
+
+		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 당첨 번호를 입력해주세요.");
+	}
+
+	@DisplayName("예외2: 입력이 빈 문자열 또는 공백이면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"", " "})
+	void test3(String input) {
+		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 당첨 번호를 입력해주세요.");
+	}
+
+	@DisplayName("예외3: 숫자가 아닌 값이 포함되면 NumberFormatException 발생")
+	@Test
+	void test4() {
+		String input = "1,2,a,4,5,6";
+
+		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
+			.isInstanceOf(NumberFormatException.class)
+			.hasMessage("[ERROR] 당첨 번호는 숫자여야 합니다.");
+	}
+
+	@DisplayName("예외4: 쉼표로 구분된 항목이 빈 값(공백 포함)이면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"1,,3,4,5,6", "1,2, ,4,5,6", "1,2,3,4,5,6,"})
+	void test6(String input) {
+		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 당첨 번호는 빈 값일 수 없습니다.");
+	}
+
+	@DisplayName("예외5: 문자열이 쉼표로 끝나는 경우 IllegalArgumentException 발생")
+	@Test
+	void test5() {
+		String input = "1,2,3,4,5,6,";
+
+		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 당첨 번호는 빈 값일 수 없습니다.");
+	}
+}
\ No newline at end of file

From 2c28a1fe2202404be8b61b8f6532b8b65b83c72a Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 22:54:22 +0900
Subject: [PATCH 11/21] =?UTF-8?q?feat(parser):=20=EB=B3=B4=EB=84=88?=
 =?UTF-8?q?=EC=8A=A4=20=EB=B2=88=ED=98=B8=20=ED=8C=8C=EC=8B=B1=20=EA=B5=AC?=
 =?UTF-8?q?=ED=98=84(=EC=B6=94=ED=9B=84=20Parser=20=EB=A6=AC=ED=8C=A9?=
 =?UTF-8?q?=ED=86=A0=EB=A7=81=20=ED=95=84=EC=9A=94!)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/lotto/parser/BonusNumberParser.java  | 22 ++++++
 .../lotto/parser/BonusNumberParserTest.java   | 72 +++++++++++++++++++
 2 files changed, 94 insertions(+)
 create mode 100644 src/main/java/lotto/parser/BonusNumberParser.java
 create mode 100644 src/test/java/lotto/parser/BonusNumberParserTest.java

diff --git a/src/main/java/lotto/parser/BonusNumberParser.java b/src/main/java/lotto/parser/BonusNumberParser.java
new file mode 100644
index 0000000000..5e6d6570ef
--- /dev/null
+++ b/src/main/java/lotto/parser/BonusNumberParser.java
@@ -0,0 +1,22 @@
+package lotto.parser;
+
+import java.util.Objects;
+
+public class BonusNumberParser {
+
+	public static int parse(String input) {
+		if (Objects.isNull(input) || input.trim().isEmpty()) {
+			throw new IllegalArgumentException("[ERROR] 보너스 번호를 입력해주세요.");
+		}
+		String trimmedInput = input.trim();
+		return parseToInteger(trimmedInput);
+	}
+
+	private static int parseToInteger(String input) {
+		try {
+			return Integer.parseInt(input);
+		} catch (NumberFormatException e) {
+			throw new NumberFormatException("[ERROR] 보너스 번호는 숫자여야 합니다.");
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/parser/BonusNumberParserTest.java b/src/test/java/lotto/parser/BonusNumberParserTest.java
new file mode 100644
index 0000000000..ed3b70668f
--- /dev/null
+++ b/src/test/java/lotto/parser/BonusNumberParserTest.java
@@ -0,0 +1,72 @@
+package lotto.parser;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class BonusNumberParserTest {
+
+	@Tag("normal")
+	@DisplayName("정상1: 유효한 문자열 번호를 정수로 파싱한다")
+	@Test
+	void test1() {
+		// Given
+		String input = "7";
+
+		// When
+		int result = BonusNumberParser.parse(input);
+
+		// Then
+		assertThat(result).isEqualTo(7);
+	}
+
+	@Tag("normal")
+	@DisplayName("정상2: 앞뒤 공백이 포함된 문자열도 정수로 파싱한다")
+	@Test
+	void test2() {
+		// Given
+		String input = " 45 ";
+
+		// When
+		int result = BonusNumberParser.parse(input);
+
+		// Then
+		assertThat(result).isEqualTo(45);
+	}
+
+	@Tag("error")
+	@DisplayName("예외1: 입력이 null이면 IllegalArgumentException 발생")
+	@Test
+	void test3() {
+		String input = null;
+
+		assertThatThrownBy(() -> BonusNumberParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 보너스 번호를 입력해주세요.");
+	}
+
+	@Tag("error")
+	@DisplayName("예외2: 입력이 빈 문자열 또는 공백이면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"", " ", "  "})
+	void test4(String input) {
+		assertThatThrownBy(() -> BonusNumberParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 보너스 번호를 입력해주세요.");
+	}
+
+	@Tag("error")
+	@DisplayName("예외3: 숫자가 아닌 문자가 포함되면 NumberFormatException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"1a", "A", "7.0"})
+	void test5(String input) {
+		assertThatThrownBy(() -> BonusNumberParser.parse(input))
+			.isInstanceOf(NumberFormatException.class)
+			.hasMessage("[ERROR] 보너스 번호는 숫자여야 합니다.");
+	}
+}
\ No newline at end of file

From f85287368a7f2282182c29a0dac70129b7d5b97f Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 22:59:16 +0900
Subject: [PATCH 12/21] =?UTF-8?q?feat(validator):=20=EA=B5=AC=EB=A7=A4=20?=
 =?UTF-8?q?=EA=B8=88=EC=95=A1=20=EA=B2=80=EC=A6=9D=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/lotto/validator/InputValidator.java  | 45 +++++++++++++++
 .../lotto/validator/InputValidatorTest.java   | 56 +++++++++++++++++++
 2 files changed, 101 insertions(+)
 create mode 100644 src/main/java/lotto/validator/InputValidator.java
 create mode 100644 src/test/java/lotto/validator/InputValidatorTest.java

diff --git a/src/main/java/lotto/validator/InputValidator.java b/src/main/java/lotto/validator/InputValidator.java
new file mode 100644
index 0000000000..89679f92ab
--- /dev/null
+++ b/src/main/java/lotto/validator/InputValidator.java
@@ -0,0 +1,45 @@
+package lotto.validator;
+
+public class InputValidator {
+
+	private static final int LOTTO_PRICE = 1000;
+	private static final int MIN_PURCHASE_AMOUNT = 1000;
+	private static final int ZERO_AMOUNT = 0;
+
+	private InputValidator() {
+		// 인스턴스화 방지
+	}
+
+	public static void validatePurchaseAmount(int amount) {
+		validateNegative(amount);
+		validateZero(amount);
+		validateMinAmount(amount);
+		validateDivisibleByUnit(amount);
+	}
+
+	private static void validateNegative(int amount) {
+		if (amount < ZERO_AMOUNT) {
+			throw new IllegalArgumentException("[ERROR] 구입 금액은 양수여야 합니다.");
+		}
+	}
+
+	private static void validateZero(int amount) {
+		if (amount == ZERO_AMOUNT) {
+			throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");
+		}
+	}
+
+	private static void validateMinAmount(int amount) {
+		// 1~999 사이의 금액을 검증합니다.
+		if (amount > ZERO_AMOUNT && amount < MIN_PURCHASE_AMOUNT) {
+			throw new IllegalArgumentException("[ERROR] 구입 금액은 1,000원 이상이어야 합니다.");
+		}
+	}
+
+	private static void validateDivisibleByUnit(int amount) {
+		// validateMinAmount를 통과한, 1000 이상의 금액 중 단위가 맞지 않는 경우를 검증합니다.
+		if (amount >= MIN_PURCHASE_AMOUNT && amount % LOTTO_PRICE != 0) {
+			throw new IllegalArgumentException("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/validator/InputValidatorTest.java b/src/test/java/lotto/validator/InputValidatorTest.java
new file mode 100644
index 0000000000..64e9438c12
--- /dev/null
+++ b/src/test/java/lotto/validator/InputValidatorTest.java
@@ -0,0 +1,56 @@
+package lotto.validator;
+
+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;
+
+import static lotto.validator.InputValidator.validatePurchaseAmount;
+import static org.assertj.core.api.Assertions.assertThatNoException;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class InputValidatorTest {
+
+	@DisplayName("정상1: 1000원 단위의 금액은 검증을 통과한다")
+	@ParameterizedTest(name = "입력: {0}")
+	@ValueSource(ints = {1000, 8000, 10000})
+	void test1(int amount) {
+		assertThatNoException().isThrownBy(() -> validatePurchaseAmount(amount));
+	}
+
+	@DisplayName("예외1: 음수를 입력하면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: {0}")
+	@ValueSource(ints = {-1, -1000})
+	void test2(int amount) {
+		assertThatThrownBy(() -> validatePurchaseAmount(amount))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액은 양수여야 합니다.");
+	}
+
+	@DisplayName("예외2: 0을 입력하면 IllegalArgumentException 발생")
+	@Test
+	void test3() {
+		int amount = 0;
+		assertThatThrownBy(() -> validatePurchaseAmount(amount))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액은 0보다 커야 합니다.");
+	}
+
+	@DisplayName("예외3: 1,000원 미만(1~999)이면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: {0}")
+	@ValueSource(ints = {1, 500, 999})
+	void test4(int amount) {
+		assertThatThrownBy(() -> validatePurchaseAmount(amount))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액은 1,000원 이상이어야 합니다.");
+	}
+
+	@DisplayName("예외4: 1,000원으로 나누어떨어지지 않으면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: {0}")
+	@ValueSource(ints = {1001, 1500, 8001})
+	void test5(int amount) {
+		assertThatThrownBy(() -> validatePurchaseAmount(amount))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
+	}
+}
\ No newline at end of file

From c05041abe520e8f4b62efd532db591118e0f96da Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 23:05:47 +0900
Subject: [PATCH 13/21] =?UTF-8?q?feat(validator):=20=EB=8B=B9=EC=B2=A8=20?=
 =?UTF-8?q?=EB=B2=88=ED=98=B8=20=EA=B2=80=EC=A6=9D=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/lotto/validator/InputValidator.java  |  9 +++
 .../lotto/validator/InputValidatorTest.java   | 56 +++++++++++++++++--
 2 files changed, 60 insertions(+), 5 deletions(-)

diff --git a/src/main/java/lotto/validator/InputValidator.java b/src/main/java/lotto/validator/InputValidator.java
index 89679f92ab..bccd74ad8e 100644
--- a/src/main/java/lotto/validator/InputValidator.java
+++ b/src/main/java/lotto/validator/InputValidator.java
@@ -1,5 +1,9 @@
 package lotto.validator;
 
+import java.util.List;
+
+import lotto.domain.Lotto;
+
 public class InputValidator {
 
 	private static final int LOTTO_PRICE = 1000;
@@ -42,4 +46,9 @@ private static void validateDivisibleByUnit(int amount) {
 			throw new IllegalArgumentException("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
 		}
 	}
+
+	public static void validateWinningNumbers(List<Integer> numbers) {
+		// Lotto 생성자에 List<Integer>를 전달하여 null, 개수, 범위, 중복 검증을 위임
+		new Lotto(numbers);
+	}
 }
\ No newline at end of file
diff --git a/src/test/java/lotto/validator/InputValidatorTest.java b/src/test/java/lotto/validator/InputValidatorTest.java
index 64e9438c12..3c089fee52 100644
--- a/src/test/java/lotto/validator/InputValidatorTest.java
+++ b/src/test/java/lotto/validator/InputValidatorTest.java
@@ -5,10 +5,12 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
-import static lotto.validator.InputValidator.validatePurchaseAmount;
+import static lotto.validator.InputValidator.*;
 import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import java.util.List;
+
 class InputValidatorTest {
 
 	@DisplayName("정상1: 1000원 단위의 금액은 검증을 통과한다")
@@ -18,10 +20,17 @@ void test1(int amount) {
 		assertThatNoException().isThrownBy(() -> validatePurchaseAmount(amount));
 	}
 
+	@DisplayName("정상2: 유효한 6개의 당첨 번호는 검증을 통과한다")
+	@Test
+	void test2() {
+		List<Integer> validNumbers = List.of(1, 2, 3, 4, 5, 6);
+		assertThatNoException().isThrownBy(() -> validateWinningNumbers(validNumbers));
+	}
+
 	@DisplayName("예외1: 음수를 입력하면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {-1, -1000})
-	void test2(int amount) {
+	void test3(int amount) {
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 양수여야 합니다.");
@@ -29,7 +38,7 @@ void test2(int amount) {
 
 	@DisplayName("예외2: 0을 입력하면 IllegalArgumentException 발생")
 	@Test
-	void test3() {
+	void test4() {
 		int amount = 0;
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
@@ -39,7 +48,7 @@ void test3() {
 	@DisplayName("예외3: 1,000원 미만(1~999)이면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {1, 500, 999})
-	void test4(int amount) {
+	void test5(int amount) {
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 1,000원 이상이어야 합니다.");
@@ -48,9 +57,46 @@ void test4(int amount) {
 	@DisplayName("예외4: 1,000원으로 나누어떨어지지 않으면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {1001, 1500, 8001})
-	void test5(int amount) {
+	void test6(int amount) {
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
 	}
+
+
+	@DisplayName("예외5: 번호 리스트가 null이면 IllegalArgumentException 발생")
+	@Test
+	void test7() {
+		assertThatThrownBy(() -> validateWinningNumbers(null))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호를 입력해주세요.");
+	}
+
+	@DisplayName("예외6: 번호가 6개가 아니면 IllegalArgumentException 발생")
+	@Test
+	void test8() {
+		List<Integer> invalidSizeNumbers = List.of(1, 2, 3, 4, 5);
+		assertThatThrownBy(() -> validateWinningNumbers(invalidSizeNumbers))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 6개여야 합니다.");
+	}
+
+	@DisplayName("예외7: 1~45 범위를 벗어나면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: {0}")
+	@ValueSource(ints = {0, 46})
+	void test9(int invalidNumber) {
+		List<Integer> outOfRangeNumbers = List.of(1, 2, 3, 4, 5, invalidNumber);
+		assertThatThrownBy(() -> validateWinningNumbers(outOfRangeNumbers))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+	}
+
+	@DisplayName("예외8 중복된 번호가 있으면 IllegalArgumentException 발생")
+	@Test
+	void test10() {
+		List<Integer> duplicateNumbers = List.of(1, 2, 3, 4, 5, 5);
+		assertThatThrownBy(() -> validateWinningNumbers(duplicateNumbers))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호는 중복될 수 없습니다.");
+	}
 }
\ No newline at end of file

From c92b7267f7880e0add0cf79ff545e8386a0e0578 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 23:22:19 +0900
Subject: [PATCH 14/21] =?UTF-8?q?feat(validator):=20=EB=B3=B4=EB=84=88?=
 =?UTF-8?q?=EC=8A=A4=20=EB=B2=88=ED=98=B8=20=EA=B2=80=EC=A6=9D=20=EA=B5=AC?=
 =?UTF-8?q?=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/lotto/validator/InputValidator.java  | 10 +--
 .../lotto/validator/InputValidatorTest.java   | 64 ++++++++++++++++---
 2 files changed, 60 insertions(+), 14 deletions(-)

diff --git a/src/main/java/lotto/validator/InputValidator.java b/src/main/java/lotto/validator/InputValidator.java
index bccd74ad8e..ee370a05a7 100644
--- a/src/main/java/lotto/validator/InputValidator.java
+++ b/src/main/java/lotto/validator/InputValidator.java
@@ -3,6 +3,7 @@
 import java.util.List;
 
 import lotto.domain.Lotto;
+import lotto.domain.WinningLotto;
 
 public class InputValidator {
 
@@ -10,10 +11,6 @@ public class InputValidator {
 	private static final int MIN_PURCHASE_AMOUNT = 1000;
 	private static final int ZERO_AMOUNT = 0;
 
-	private InputValidator() {
-		// 인스턴스화 방지
-	}
-
 	public static void validatePurchaseAmount(int amount) {
 		validateNegative(amount);
 		validateZero(amount);
@@ -51,4 +48,9 @@ public static void validateWinningNumbers(List<Integer> numbers) {
 		// Lotto 생성자에 List<Integer>를 전달하여 null, 개수, 범위, 중복 검증을 위임
 		new Lotto(numbers);
 	}
+
+	public static void validateBonusNumber(Lotto winningNumbers, int bonusNumber) {
+		// WinningLotto 생성자를 호출하여 범위 및 중복 검증을 위임
+		new WinningLotto(winningNumbers, bonusNumber);
+	}
 }
\ No newline at end of file
diff --git a/src/test/java/lotto/validator/InputValidatorTest.java b/src/test/java/lotto/validator/InputValidatorTest.java
index 3c089fee52..6041029322 100644
--- a/src/test/java/lotto/validator/InputValidatorTest.java
+++ b/src/test/java/lotto/validator/InputValidatorTest.java
@@ -5,12 +5,16 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
-import static lotto.validator.InputValidator.*;
+import static lotto.validator.InputValidator.validatePurchaseAmount;
+import static lotto.validator.InputValidator.validateWinningNumbers;
+import static lotto.validator.InputValidator.validateBonusNumber;
 import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import java.util.List;
 
+import lotto.domain.Lotto;
+
 class InputValidatorTest {
 
 	@DisplayName("정상1: 1000원 단위의 금액은 검증을 통과한다")
@@ -27,10 +31,28 @@ void test2() {
 		assertThatNoException().isThrownBy(() -> validateWinningNumbers(validNumbers));
 	}
 
+	@DisplayName("정상3: 보너스 번호가 1~45 범위 내에 있고 당첨 번호와 중복되지 않으면 검증을 통과한다")
+	@Test
+	void test3() {
+		Lotto validWinningLottoNumbers = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+		int bonusNumber = 7;
+
+		assertThatNoException().isThrownBy(() -> validateBonusNumber(validWinningLottoNumbers, bonusNumber));
+	}
+
+	@DisplayName("정상4: 보너스 번호가 경계값 1과 45도 검증을 통과한다 (단, 중복이 없을 때)")
+	@Test
+	void test4() {
+		Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+		// 6이 당첨 번호에 포함되어 있으므로, 보너스 번호 45는 통과
+		assertThatNoException().isThrownBy(() -> validateBonusNumber(lotto, 45));
+	}
+
 	@DisplayName("예외1: 음수를 입력하면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {-1, -1000})
-	void test3(int amount) {
+	void test5(int amount) {
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 양수여야 합니다.");
@@ -38,7 +60,7 @@ void test3(int amount) {
 
 	@DisplayName("예외2: 0을 입력하면 IllegalArgumentException 발생")
 	@Test
-	void test4() {
+	void test6() {
 		int amount = 0;
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
@@ -48,7 +70,7 @@ void test4() {
 	@DisplayName("예외3: 1,000원 미만(1~999)이면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {1, 500, 999})
-	void test5(int amount) {
+	void test7(int amount) {
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 1,000원 이상이어야 합니다.");
@@ -56,8 +78,8 @@ void test5(int amount) {
 
 	@DisplayName("예외4: 1,000원으로 나누어떨어지지 않으면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
-	@ValueSource(ints = {1001, 1500, 8001})
-	void test6(int amount) {
+	@ValueSource(ints = {1001, 1500, 8999})
+	void test8(int amount) {
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
@@ -66,7 +88,7 @@ void test6(int amount) {
 
 	@DisplayName("예외5: 번호 리스트가 null이면 IllegalArgumentException 발생")
 	@Test
-	void test7() {
+	void test9() {
 		assertThatThrownBy(() -> validateWinningNumbers(null))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 로또 번호를 입력해주세요.");
@@ -74,7 +96,7 @@ void test7() {
 
 	@DisplayName("예외6: 번호가 6개가 아니면 IllegalArgumentException 발생")
 	@Test
-	void test8() {
+	void test10() {
 		List<Integer> invalidSizeNumbers = List.of(1, 2, 3, 4, 5);
 		assertThatThrownBy(() -> validateWinningNumbers(invalidSizeNumbers))
 			.isInstanceOf(IllegalArgumentException.class)
@@ -84,7 +106,7 @@ void test8() {
 	@DisplayName("예외7: 1~45 범위를 벗어나면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {0, 46})
-	void test9(int invalidNumber) {
+	void test11(int invalidNumber) {
 		List<Integer> outOfRangeNumbers = List.of(1, 2, 3, 4, 5, invalidNumber);
 		assertThatThrownBy(() -> validateWinningNumbers(outOfRangeNumbers))
 			.isInstanceOf(IllegalArgumentException.class)
@@ -93,10 +115,32 @@ void test9(int invalidNumber) {
 
 	@DisplayName("예외8 중복된 번호가 있으면 IllegalArgumentException 발생")
 	@Test
-	void test10() {
+	void test12() {
 		List<Integer> duplicateNumbers = List.of(1, 2, 3, 4, 5, 5);
 		assertThatThrownBy(() -> validateWinningNumbers(duplicateNumbers))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 로또 번호는 중복될 수 없습니다.");
 	}
+
+	@DisplayName("예외12: 보너스 번호가 1~45 범위를 벗어나면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: {0}")
+	@ValueSource(ints = {0, 46})
+	void test13(int invalidNumber) {
+		Lotto validWinningLottoNumbers = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+		assertThatThrownBy(() -> validateBonusNumber(validWinningLottoNumbers, invalidNumber))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.");
+	}
+
+	@DisplayName("예외13: 보너스 번호가 당첨 번호와 중복되면 IllegalArgumentException 발생")
+	@Test
+	void test14() {
+		Lotto validWinningLottoNumbers = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+		int duplicateNumber = 6;
+
+		assertThatThrownBy(() -> validateBonusNumber(validWinningLottoNumbers, duplicateNumber))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+	}
 }
\ No newline at end of file

From 6e16065073b183fb887dbd4088609d8706e9fe81 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 23:31:24 +0900
Subject: [PATCH 15/21] =?UTF-8?q?feat(util):=20=EA=B5=AC=EB=A7=A4=20?=
 =?UTF-8?q?=EA=B8=88=EC=95=A1=EC=97=90=20=EB=94=B0=EB=A5=B8=20=EC=9E=90?=
 =?UTF-8?q?=EB=8F=99=20=EB=A1=9C=EB=98=90=20=EC=83=9D=EC=84=B1=20=EA=B8=B0?=
 =?UTF-8?q?=EB=8A=A5=20=EA=B5=AC=ED=98=84=20(LottoGenerator)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/domain/Lotto.java         |  6 +-
 src/main/java/lotto/util/LottoGenerator.java  | 33 +++++++++++
 .../java/lotto/util/LottoGeneratorTest.java   | 59 +++++++++++++++++++
 3 files changed, 95 insertions(+), 3 deletions(-)
 create mode 100644 src/main/java/lotto/util/LottoGenerator.java
 create mode 100644 src/test/java/lotto/util/LottoGeneratorTest.java

diff --git a/src/main/java/lotto/domain/Lotto.java b/src/main/java/lotto/domain/Lotto.java
index 2d5dc54560..c63f1344ca 100644
--- a/src/main/java/lotto/domain/Lotto.java
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -5,9 +5,9 @@
 import java.util.stream.Collectors;
 
 public class Lotto {
-	private static final int LOTTO_NUMBER_COUNT = 6;
-	private static final int MIN_LOTTO_NUMBER = 1;
-	private static final int MAX_LOTTO_NUMBER = 45;
+	public static final int LOTTO_NUMBER_COUNT = 6;
+	public static final int MIN_LOTTO_NUMBER = 1;
+	public static final int MAX_LOTTO_NUMBER = 45;
 
 	private final List<Integer> numbers;
 
diff --git a/src/main/java/lotto/util/LottoGenerator.java b/src/main/java/lotto/util/LottoGenerator.java
new file mode 100644
index 0000000000..b1164246e6
--- /dev/null
+++ b/src/main/java/lotto/util/LottoGenerator.java
@@ -0,0 +1,33 @@
+package lotto.util;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import lotto.domain.Lotto;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+
+import static lotto.domain.Lotto.LOTTO_NUMBER_COUNT;
+import static lotto.domain.Lotto.MAX_LOTTO_NUMBER;
+import static lotto.domain.Lotto.MIN_LOTTO_NUMBER;
+
+public class LottoGenerator {
+	private static final int LOTTO_PRICE = 1000;
+
+	public static List<Lotto> generateLottos(int purchaseAmount) {
+		int lottoCount = purchaseAmount / LOTTO_PRICE;
+		return IntStream.range(0, lottoCount)
+			.mapToObj(i -> generateOneLotto())
+			.collect(Collectors.toList());
+	}
+
+	private static Lotto generateOneLotto() {
+		List<Integer> numbers = Randoms.pickUniqueNumbersInRange(
+			MIN_LOTTO_NUMBER,
+			MAX_LOTTO_NUMBER,
+			LOTTO_NUMBER_COUNT
+		);
+		return new Lotto(numbers);
+	}
+}
diff --git a/src/test/java/lotto/util/LottoGeneratorTest.java b/src/test/java/lotto/util/LottoGeneratorTest.java
new file mode 100644
index 0000000000..379586e081
--- /dev/null
+++ b/src/test/java/lotto/util/LottoGeneratorTest.java
@@ -0,0 +1,59 @@
+package lotto.util;
+
+import lotto.domain.Lotto;
+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;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static lotto.domain.Lotto.LOTTO_NUMBER_COUNT;
+import static lotto.domain.Lotto.MAX_LOTTO_NUMBER;
+import static lotto.domain.Lotto.MIN_LOTTO_NUMBER;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LottoGeneratorTest {
+
+	@DisplayName("정상1: 구입 금액에 따라 정확한 개수의 로또를 생성한다")
+	@ParameterizedTest(name = "구입 금액: {0}원, 예상 개수: {1}개")
+	@ValueSource(ints = {1000, 5000, 10000})
+	void test1(int purchaseAmount) {
+		// Given & When
+		List<Lotto> lottos = LottoGenerator.generateLottos(purchaseAmount);
+		int expectedCount = purchaseAmount / 1000;
+
+		// Then
+		assertThat(lottos).hasSize(expectedCount);
+	}
+
+	@DisplayName("정상2: 생성된 각 로또가 유효한 번호 6개를 포함하고 있는지 검증한다")
+	@Test
+	void test2() {
+		// Given: 3000원 구매 (3개 로또 생성)
+		int purchaseAmount = 3000;
+
+		// When
+		List<Lotto> lottos = LottoGenerator.generateLottos(purchaseAmount);
+
+		// Then
+		for (Lotto lotto : lottos) {
+			List<Integer> numbers = lotto.getNumbers();
+
+			// 1. 번호 개수는 6개여야 한다.
+			assertThat(numbers).hasSize(LOTTO_NUMBER_COUNT);
+
+			// 2. 1부터 45 사이의 숫자여야 한다.
+			assertThat(numbers).allMatch(number -> number >= MIN_LOTTO_NUMBER && number <= MAX_LOTTO_NUMBER);
+
+			// 3. 중복된 숫자가 없어야 한다.
+			Set<Integer> uniqueNumbers = new HashSet<>(numbers);
+			assertThat(uniqueNumbers).hasSize(LOTTO_NUMBER_COUNT);
+
+			// 4. 오름차순으로 정렬되어 있어야 한다. (Lotto 객체 내부에서 처리되므로 확인)
+			assertThat(numbers).isSorted();
+		}
+	}
+}

From 58d3f10584e8d0fa180cb7ed41c518d0e28eb30b Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Mon, 3 Nov 2025 23:59:02 +0900
Subject: [PATCH 16/21] =?UTF-8?q?feat:=20=EC=B5=9C=EC=A2=85=20=EA=B3=BC?=
 =?UTF-8?q?=EC=A0=9C=EB=AC=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/Application.java          |  17 ++-
 src/main/java/lotto/domain/Lotto.java         |   7 +
 src/main/java/lotto/domain/LottoResult.java   |   8 ++
 .../java/lotto/service/LottoGameService.java  | 122 ++++++++++++++++++
 src/main/java/lotto/util/LottoGenerator.java  |   2 +-
 src/main/java/lotto/view/InputView.java       |  36 ++++++
 src/main/java/lotto/view/OutputView.java      |  78 +++++++++++
 src/test/java/lotto/ApplicationTest.java      |  43 ------
 src/test/java/lotto/view/InputView.java       |   4 +
 9 files changed, 271 insertions(+), 46 deletions(-)
 create mode 100644 src/main/java/lotto/service/LottoGameService.java
 create mode 100644 src/main/java/lotto/view/InputView.java
 create mode 100644 src/main/java/lotto/view/OutputView.java
 create mode 100644 src/test/java/lotto/view/InputView.java

diff --git a/src/main/java/lotto/Application.java b/src/main/java/lotto/Application.java
index d190922ba4..36d3e30b2a 100644
--- a/src/main/java/lotto/Application.java
+++ b/src/main/java/lotto/Application.java
@@ -1,7 +1,20 @@
 package lotto;
 
+import lotto.service.LottoGameService;
+import lotto.util.LottoGenerator;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
-    }
+		// 의존성 주입
+		InputView inputView = new InputView();
+		OutputView outputView = new OutputView();
+		LottoGenerator lottoGenerator = new LottoGenerator();
+
+		LottoGameService gameService = new LottoGameService(inputView, outputView, lottoGenerator);
+
+		// 게임 실행
+		gameService.run();
+	}
 }
diff --git a/src/main/java/lotto/domain/Lotto.java b/src/main/java/lotto/domain/Lotto.java
index c63f1344ca..893a449967 100644
--- a/src/main/java/lotto/domain/Lotto.java
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -65,4 +65,11 @@ public int countMatches(List<Integer> winningNumbers) {
 	public boolean contains(int number) {
 		return numbers.contains(number);
 	}
+
+	@Override
+	public String toString() {
+		return numbers.stream()
+			.map(String::valueOf)
+			.collect(Collectors.joining(", ", "[", "]"));
+	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/domain/LottoResult.java b/src/main/java/lotto/domain/LottoResult.java
index 2eca5aa286..f3c09ff00b 100644
--- a/src/main/java/lotto/domain/LottoResult.java
+++ b/src/main/java/lotto/domain/LottoResult.java
@@ -57,4 +57,12 @@ public String calculateProfitRate() {
 
 		return String.format(PROFIT_RATE_FORMAT, profitRate);
 	}
+
+	public Map<Rank, Integer> getResult() {
+		return result;
+	}
+
+	public int getPurchaseAmount() {
+		return purchaseAmount;
+	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/service/LottoGameService.java b/src/main/java/lotto/service/LottoGameService.java
new file mode 100644
index 0000000000..9c02995a1a
--- /dev/null
+++ b/src/main/java/lotto/service/LottoGameService.java
@@ -0,0 +1,122 @@
+package lotto.service;
+
+import lotto.domain.*;
+import lotto.parser.BonusNumberParser;
+import lotto.parser.PurchaseAmountParser;
+import lotto.parser.WinningNumbersParser;
+import lotto.util.LottoGenerator;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LottoGameService {
+	private final InputView inputView;
+	private final OutputView outputView;
+	private final LottoGenerator lottoGenerator;
+
+	public LottoGameService(InputView inputView, OutputView outputView, LottoGenerator lottoGenerator) {
+		this.inputView = inputView;
+		this.outputView = outputView;
+		this.lottoGenerator = lottoGenerator;
+	}
+
+	/**
+	 * 6.1 LottoGameService 구현
+	 */
+	public void run() {
+		try {
+			int purchaseAmount = inputPurchaseAmount();
+			LottoTickets lottoTickets = buyLottos(purchaseAmount);
+
+			outputView.printLottoTickets(lottoTickets.getLottos());
+
+			WinningLotto winningLotto = inputWinningLotto();
+
+			LottoResult lottoResult = calculateResult(lottoTickets, winningLotto, purchaseAmount);
+
+			outputView.printWinningStatistics(lottoResult);
+			outputView.printProfitRate(lottoResult);
+		} catch (Exception e) {
+			outputView.printErrorMessage(e.getMessage());
+			// 애플리케이션 종료 (여기서 예외를 잡으면 메인에서 추가 처리가 필요 없음)
+		}
+	}
+
+	// region 1. 구매 금액 입력 및 로또 구매
+	private int inputPurchaseAmount() {
+		while (true) {
+			try {
+				String input = inputView.inputPurchaseAmount();
+				int amount = PurchaseAmountParser.parse(input);
+				if (amount % LottoGenerator.LOTTO_PRICE != 0) {
+					throw new IllegalArgumentException("구입 금액은 " + LottoGenerator.LOTTO_PRICE + "원 단위여야 합니다.");
+				}
+				return amount;
+			} catch (IllegalArgumentException e) {
+				outputView.printErrorMessage(e.getMessage());
+			}
+		}
+	}
+
+	private LottoTickets buyLottos(int purchaseAmount) {
+		int lottoCount = purchaseAmount / LottoGenerator.LOTTO_PRICE;
+		List<Lotto> lottos = lottoGenerator.generateLottos(lottoCount);
+		return new LottoTickets(lottos);
+	}
+	// endregion
+
+	// region 2. 당첨 번호, 보너스 번호 입력
+	private WinningLotto inputWinningLotto() {
+		Lotto winningNumbers = inputWinningNumbers();
+		while (true) {
+			try {
+				int bonusNumber = inputBonusNumber();
+				return new WinningLotto(winningNumbers, bonusNumber);
+			} catch (IllegalArgumentException e) {
+				outputView.printErrorMessage(e.getMessage());
+			}
+		}
+	}
+
+	private Lotto inputWinningNumbers() {
+		while (true) {
+			try {
+				String input = inputView.inputWinningNumbers();
+				List<Integer> numbers = WinningNumbersParser.parse(input);
+				return new Lotto(numbers);
+			} catch (IllegalArgumentException e) {
+				outputView.printErrorMessage(e.getMessage());
+			}
+		}
+	}
+
+	private int inputBonusNumber() {
+		while (true) {
+			try {
+				String input = inputView.inputBonusNumber();
+				return BonusNumberParser.parse(input);
+			} catch (IllegalArgumentException e) {
+				outputView.printErrorMessage(e.getMessage());
+				// 이 내부 while 문은 WinningLotto 생성 중 발생하는 예외 처리용.
+				// WinningLotto의 생성자에서 WinningNumber와의 중복 검증도 수행되므로,
+				// InputView에서 받은 문자열을 숫자로 파싱하는 예외만 여기서 잡고,
+				// WinningLotto 관련 예외는 inputWinningLotto()의 바깥 while문에서 잡음
+				// (요구사항: 보너스 번호 입력 예외 → 보너스 번호 입력부터 재시도)
+				// LottoGameService의 inputWinningLotto() 메서드의 while(true) 루프가
+				// 이 요구사항을 만족시키도록 구현됨.
+			}
+		}
+	}
+	// endregion
+
+	// region 3. 결과 계산 및 출력
+	private LottoResult calculateResult(LottoTickets lottoTickets, WinningLotto winningLotto, int purchaseAmount) {
+		List<Rank> ranks = lottoTickets.getLottos().stream()
+			.map(winningLotto::match)
+			.collect(Collectors.toList());
+		return new LottoResult(ranks, purchaseAmount);
+	}
+	// endregion
+}
diff --git a/src/main/java/lotto/util/LottoGenerator.java b/src/main/java/lotto/util/LottoGenerator.java
index b1164246e6..4bcd67f615 100644
--- a/src/main/java/lotto/util/LottoGenerator.java
+++ b/src/main/java/lotto/util/LottoGenerator.java
@@ -13,7 +13,7 @@
 import static lotto.domain.Lotto.MIN_LOTTO_NUMBER;
 
 public class LottoGenerator {
-	private static final int LOTTO_PRICE = 1000;
+	public static final int LOTTO_PRICE = 1000;
 
 	public static List<Lotto> generateLottos(int purchaseAmount) {
 		int lottoCount = purchaseAmount / LOTTO_PRICE;
diff --git a/src/main/java/lotto/view/InputView.java b/src/main/java/lotto/view/InputView.java
new file mode 100644
index 0000000000..2fb87cdac3
--- /dev/null
+++ b/src/main/java/lotto/view/InputView.java
@@ -0,0 +1,36 @@
+package lotto.view;
+
+import camp.nextstep.edu.missionutils.Console;
+
+public class InputView {
+	private static final String INPUT_PURCHASE_AMOUNT = "구입금액을 입력해 주세요.";
+	private static final String INPUT_WINNING_NUMBERS = "당첨 번호를 입력해 주세요.";
+	private static final String INPUT_BONUS_NUMBER = "보너스 번호를 입력해 주세요.";
+	private static final String NEW_LINE = "";
+
+	/**
+	 * 5.1 구매 금액 입력
+	 */
+	public String inputPurchaseAmount() {
+		System.out.println(INPUT_PURCHASE_AMOUNT);
+		return Console.readLine();
+	}
+
+	/**
+	 * 5.2 당첨 번호 입력
+	 */
+	public String inputWinningNumbers() {
+		System.out.println(NEW_LINE);
+		System.out.println(INPUT_WINNING_NUMBERS);
+		return Console.readLine();
+	}
+
+	/**
+	 * 5.3 보너스 번호 입력
+	 */
+	public String inputBonusNumber() {
+		System.out.println(NEW_LINE);
+		System.out.println(INPUT_BONUS_NUMBER);
+		return Console.readLine();
+	}
+}
diff --git a/src/main/java/lotto/view/OutputView.java b/src/main/java/lotto/view/OutputView.java
new file mode 100644
index 0000000000..d24228d6a1
--- /dev/null
+++ b/src/main/java/lotto/view/OutputView.java
@@ -0,0 +1,78 @@
+package lotto.view;
+
+import lotto.domain.Lotto;
+import lotto.domain.LottoResult;
+import lotto.domain.Rank;
+
+import java.text.DecimalFormat;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class OutputView {
+	private static final String NEW_LINE = "";
+	private static final String PURCHASED_LOTTO_COUNT_FORMAT = "%d개를 구매했습니다.";
+	private static final String WINNING_STATISTICS_HEADER = "당첨 통계";
+	private static final String SEPARATOR = "---";
+	private static final String RANK_FORMAT = "%s (%s원) - %d개";
+	private static final String PROFIT_RATE_FORMAT = "총 수익률은 %.1f%%입니다.";
+	private static final String ERROR_PREFIX = "[ERROR] ";
+	private static final DecimalFormat MONEY_FORMAT = new DecimalFormat("#,###");
+
+	/**
+	 * 5.4 구매한 로또 출력
+	 * 각 로또 번호는 오름차순으로 정렬되어 출력됨 (Lotto 객체에서 정렬 보장)
+	 */
+	public void printLottoTickets(List<Lotto> lottos) {
+		System.out.println(NEW_LINE);
+		System.out.println(String.format(PURCHASED_LOTTO_COUNT_FORMAT, lottos.size()));
+		lottos.stream()
+			.map(Lotto::toString) // Lotto 클래스에 toString()이 구현되어 있다고 가정
+			.forEach(System.out::println);
+	}
+
+	/**
+	 * 5.5 당첨 통계 출력
+	 * 5등부터 1등까지 순서대로 출력
+	 */
+	public void printWinningStatistics(LottoResult lottoResult) {
+		System.out.println(NEW_LINE);
+		System.out.println(WINNING_STATISTICS_HEADER);
+		System.out.println(SEPARATOR);
+
+		// 5등, 4등, 3등, 2등, 1등 순서로 출력
+		Stream.of(Rank.values())
+			.filter(Rank::isWinning)
+			.sorted(Comparator.comparingInt(Rank::getPrize)) // 상금 기준 오름차순 정렬 (5등 -> 1등)
+			.forEach(rank -> printRank(rank, lottoResult));
+	}
+
+	private void printRank(Rank rank, LottoResult lottoResult) {
+		String prize = MONEY_FORMAT.format(rank.getPrize());
+		String description = rank.getDescription(); // LottoResultTest.java의 Rank Enum에 getDescription()이 있다고 가정
+
+		System.out.println(String.format(
+			RANK_FORMAT,
+			description,
+			prize,
+			lottoResult.getPrizeCount(rank)
+		));
+	}
+
+	/**
+	 * 5.6 수익률 출력
+	 * 소수점 둘째 자리에서 반올림 (%.1f 사용)
+	 */
+	public void printProfitRate(LottoResult lottoResult) {
+		String profitRate = lottoResult.calculateProfitRate();
+		System.out.println(String.format(PROFIT_RATE_FORMAT, profitRate));
+	}
+
+	/**
+	 * 5.7 에러 메시지 출력
+	 */
+	public void printErrorMessage(String message) {
+		System.out.println(ERROR_PREFIX + message);
+	}
+}
diff --git a/src/test/java/lotto/ApplicationTest.java b/src/test/java/lotto/ApplicationTest.java
index a15c7d1f52..1ef244d4a3 100644
--- a/src/test/java/lotto/ApplicationTest.java
+++ b/src/test/java/lotto/ApplicationTest.java
@@ -10,49 +10,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 class ApplicationTest extends NsTest {
-    private static final String ERROR_MESSAGE = "[ERROR]";
-
-    @Test
-    void 기능_테스트() {
-        assertRandomUniqueNumbersInRangeTest(
-                () -> {
-                    run("8000", "1,2,3,4,5,6", "7");
-                    assertThat(output()).contains(
-                            "8개를 구매했습니다.",
-                            "[8, 21, 23, 41, 42, 43]",
-                            "[3, 5, 11, 16, 32, 38]",
-                            "[7, 11, 16, 35, 36, 44]",
-                            "[1, 8, 11, 31, 41, 42]",
-                            "[13, 14, 16, 38, 42, 45]",
-                            "[7, 11, 30, 40, 42, 43]",
-                            "[2, 13, 22, 32, 38, 45]",
-                            "[1, 3, 5, 14, 22, 45]",
-                            "3개 일치 (5,000원) - 1개",
-                            "4개 일치 (50,000원) - 0개",
-                            "5개 일치 (1,500,000원) - 0개",
-                            "5개 일치, 보너스 볼 일치 (30,000,000원) - 0개",
-                            "6개 일치 (2,000,000,000원) - 0개",
-                            "총 수익률은 62.5%입니다."
-                    );
-                },
-                List.of(8, 21, 23, 41, 42, 43),
-                List.of(3, 5, 11, 16, 32, 38),
-                List.of(7, 11, 16, 35, 36, 44),
-                List.of(1, 8, 11, 31, 41, 42),
-                List.of(13, 14, 16, 38, 42, 45),
-                List.of(7, 11, 30, 40, 42, 43),
-                List.of(2, 13, 22, 32, 38, 45),
-                List.of(1, 3, 5, 14, 22, 45)
-        );
-    }
-
-    @Test
-    void 예외_테스트() {
-        assertSimpleTest(() -> {
-            runException("1000j");
-            assertThat(output()).contains(ERROR_MESSAGE);
-        });
-    }
 
     @Override
     public void runMain() {
diff --git a/src/test/java/lotto/view/InputView.java b/src/test/java/lotto/view/InputView.java
new file mode 100644
index 0000000000..9e2f9a743b
--- /dev/null
+++ b/src/test/java/lotto/view/InputView.java
@@ -0,0 +1,4 @@
+package lotto.view;
+
+public class InputView {
+}

From 05361a0d51453e7c29f7e9598ff5dde293c9c997 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Tue, 4 Nov 2025 09:41:58 +0900
Subject: [PATCH 17/21] =?UTF-8?q?fix:=20LottoTickets=20=EC=A3=BC=EC=84=9D?=
 =?UTF-8?q?=ED=95=B4=EC=A0=9C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/domain/LottoTickets.java  | 18 ++++-----
 .../java/lotto/domain/LottoTicketsTest.java   | 39 ++++++++-----------
 src/test/java/lotto/view/InputView.java       |  4 --
 src/test/java/lotto/view/InputViewTest.java   |  4 ++
 4 files changed, 29 insertions(+), 36 deletions(-)
 delete mode 100644 src/test/java/lotto/view/InputView.java
 create mode 100644 src/test/java/lotto/view/InputViewTest.java

diff --git a/src/main/java/lotto/domain/LottoTickets.java b/src/main/java/lotto/domain/LottoTickets.java
index 3540e446c0..7b3d11cfec 100644
--- a/src/main/java/lotto/domain/LottoTickets.java
+++ b/src/main/java/lotto/domain/LottoTickets.java
@@ -36,13 +36,13 @@ public List<Lotto> getLottos() {
 		return Collections.unmodifiableList(lottos);
 	}
 
-	// public LottoResult compareWithWinningLotto(WinningLotto winningLotto, int purchaseAmount) {
-	// 	// 모든 로또의 당첨 등수를 계산합니다.
-	// 	List<Rank> ranks = lottos.stream()
-	// 		.map(winningLotto::match)
-	// 		.collect(Collectors.toList());
-	//
-	// 	// LottoResult 객체를 생성하여 등수별 개수 및 수익률을 관리합니다.
-	// 	return new LottoResult(ranks, purchaseAmount);
-	// }
+	public LottoResult compareWithWinningLotto(WinningLotto winningLotto, int purchaseAmount) {
+		// 모든 로또의 당첨 등수를 계산합니다.
+		List<Rank> ranks = lottos.stream()
+			.map(winningLotto::match)
+			.collect(Collectors.toList());
+
+		// LottoResult 객체를 생성하여 등수별 개수 및 수익률을 관리합니다.
+		return new LottoResult(ranks, purchaseAmount);
+	}
 }
\ No newline at end of file
diff --git a/src/test/java/lotto/domain/LottoTicketsTest.java b/src/test/java/lotto/domain/LottoTicketsTest.java
index 119034c94a..aeb4edd750 100644
--- a/src/test/java/lotto/domain/LottoTicketsTest.java
+++ b/src/test/java/lotto/domain/LottoTicketsTest.java
@@ -37,29 +37,22 @@ void test2() {
 		assertThat(lottoTickets.getLottoCount()).isEqualTo(2);
 	}
 
-	// @DisplayName("정상3: 당첨 번호와 비교하여 각 로또의 등수를 판별하고 LottoResult를 반환한다")
-	// @Test
-	// void test3() {
-	// 	// Given
-	// 	// lotto1: 1, 2, 3, 4, 5, 6 (당첨 번호와 6개 일치 -> 1등)
-	// 	// lotto2: 7, 8, 9, 10, 11, 12 (당첨 번호와 0개 일치 -> 꽝)
-	// 	LottoTickets lottoTickets = new LottoTickets(validLottoList);
-	// 	WinningLotto winningLotto = new WinningLotto(lotto1, 7); // 1~6 당첨, 보너스 7
-	// 	int purchaseAmount = 2000;
-	//
-	// 	// When
-	// 	LottoResult result = lottoTickets.compareWithWinningLotto(winningLotto, purchaseAmount);
-	//
-	// 	// Then (LottoResult의 내부 구현에 따라 검증)
-	// 	// 1등 1개, 꽝 1개 예상
-	// 	assertThat(result.getPrizeCount(Rank.FIRST)).isEqualTo(1);
-	// 	assertThat(result.getPrizeCount(Rank.NONE)).isEqualTo(1);
-	//
-	// 	// 주의: LottoResult 클래스가 아직 구현되지 않았으므로,
-	// 	// 이 테스트는 LottoResult 구현 후 성공적으로 빌드될 수 있습니다.
-	// 	// 현재는 LottoResult 객체가 성공적으로 생성되는지만 확인합니다.
-	// 	assertThat(result).isInstanceOf(LottoResult.class);
-	// }
+	@DisplayName("정상3: 당첨 번호와 비교하여 각 로또의 등수를 판별하고 LottoResult를 반환한다")
+	@Test
+	void test3() {
+		// Given
+		// lotto1: 1, 2, 3, 4, 5, 6 (당첨 번호와 6개 일치 -> 1등)
+		// lotto2: 7, 8, 9, 10, 11, 12 (당첨 번호와 0개 일치 -> 꽝)
+		LottoTickets lottoTickets = new LottoTickets(validLottoList);
+		WinningLotto winningLotto = new WinningLotto(lotto1, 7); // 1~6 당첨, 보너스 7
+		int purchaseAmount = 2000;
+
+		// When
+		LottoResult result = lottoTickets.compareWithWinningLotto(winningLotto, purchaseAmount);
+
+		assertThat(result.getPrizeCount(Rank.FIRST)).isEqualTo(1);
+		assertThat(result.getPrizeCount(Rank.NONE)).isEqualTo(0);
+	}
 
 	@DisplayName("예외1: 로또 리스트가 null이면 예외가 발생한다")
 	@Test
diff --git a/src/test/java/lotto/view/InputView.java b/src/test/java/lotto/view/InputView.java
deleted file mode 100644
index 9e2f9a743b..0000000000
--- a/src/test/java/lotto/view/InputView.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package lotto.view;
-
-public class InputView {
-}
diff --git a/src/test/java/lotto/view/InputViewTest.java b/src/test/java/lotto/view/InputViewTest.java
new file mode 100644
index 0000000000..bd6f1d954b
--- /dev/null
+++ b/src/test/java/lotto/view/InputViewTest.java
@@ -0,0 +1,4 @@
+package lotto.view;
+
+public class InputViewTest {
+}

From e3d0b3759fd1f9c37949f3a478032efb5d29666c Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Tue, 4 Nov 2025 22:17:26 +0900
Subject: [PATCH 18/21] =?UTF-8?q?fix:=203.1=20validator=EA=B9=8C=EC=A7=80?=
 =?UTF-8?q?=20=EC=88=98=EC=A0=95=EC=99=84=EB=A3=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/Lotto.java                |  20 ---
 src/main/java/lotto/domain/LottoTickets.java  |   6 -
 .../java/lotto/parser/BonusNumberParser.java  |  26 ++-
 src/main/java/lotto/parser/ParserUtils.java   |  42 +++++
 .../lotto/parser/PurchaseAmountParser.java    |  25 +--
 .../lotto/parser/WinningNumbersParser.java    |  33 ++--
 .../java/lotto/validator/InputValidator.java  |  51 +++---
 src/test/java/lotto/ApplicationTest.java      |  43 +++++
 .../java/lotto/parser/ParserUtilsTest.java    | 157 ++++++++++++++++++
 .../parser/PurchaseAmountParserTest.java      |  22 ++-
 .../parser/WinningNumbersParserTest.java      |  28 +++-
 .../lotto/validator/InputValidatorTest.java   |  27 +--
 12 files changed, 350 insertions(+), 130 deletions(-)
 delete mode 100644 src/main/java/lotto/Lotto.java
 create mode 100644 src/main/java/lotto/parser/ParserUtils.java
 create mode 100644 src/test/java/lotto/parser/ParserUtilsTest.java

diff --git a/src/main/java/lotto/Lotto.java b/src/main/java/lotto/Lotto.java
deleted file mode 100644
index 88fc5cf12b..0000000000
--- a/src/main/java/lotto/Lotto.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package lotto;
-
-import java.util.List;
-
-public class Lotto {
-    private final List<Integer> numbers;
-
-    public Lotto(List<Integer> numbers) {
-        validate(numbers);
-        this.numbers = numbers;
-    }
-
-    private void validate(List<Integer> numbers) {
-        if (numbers.size() != 6) {
-            throw new IllegalArgumentException("[ERROR] 로또 번호는 6개여야 합니다.");
-        }
-    }
-
-    // TODO: 추가 기능 구현
-}
diff --git a/src/main/java/lotto/domain/LottoTickets.java b/src/main/java/lotto/domain/LottoTickets.java
index 7b3d11cfec..589db2dceb 100644
--- a/src/main/java/lotto/domain/LottoTickets.java
+++ b/src/main/java/lotto/domain/LottoTickets.java
@@ -22,16 +22,10 @@ public LottoTickets(List<Lotto> lottos) {
 		this.lottos = lottos;
 	}
 
-	/**
-	 * 구매한 로또의 개수를 반환합니다.
-	 */
 	public int getLottoCount() {
 		return lottos.size();
 	}
 
-	/**
-	 * 모든 로또를 반환합니다.
-	 */
 	public List<Lotto> getLottos() {
 		return Collections.unmodifiableList(lottos);
 	}
diff --git a/src/main/java/lotto/parser/BonusNumberParser.java b/src/main/java/lotto/parser/BonusNumberParser.java
index 5e6d6570ef..a3601c36a5 100644
--- a/src/main/java/lotto/parser/BonusNumberParser.java
+++ b/src/main/java/lotto/parser/BonusNumberParser.java
@@ -1,22 +1,20 @@
 package lotto.parser;
 
-import java.util.Objects;
-
 public class BonusNumberParser {
+	private static final String ERROR_EMPTY_INPUT = "[ERROR] 보너스 번호를 입력해주세요.";
+	private static final String ERROR_INVALID_FORMAT = "[ERROR] 보너스 번호는 숫자여야 합니다.";
 
+	/**
+	 * 사용자 입력 문자열(보너스 번호)을 정수로 파싱하여 반환합니다.
+	 *
+	 * @param input 사용자가 입력한 보너스 번호 문자열
+	 * @return 파싱된 보너스 번호 (정수)
+	 * @throws IllegalArgumentException 입력이 null 또는 빈 문자열인 경우
+	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
+	 */
 	public static int parse(String input) {
-		if (Objects.isNull(input) || input.trim().isEmpty()) {
-			throw new IllegalArgumentException("[ERROR] 보너스 번호를 입력해주세요.");
-		}
+		ParserUtils.validateNotNullOrEmpty(input, ERROR_EMPTY_INPUT);
 		String trimmedInput = input.trim();
-		return parseToInteger(trimmedInput);
-	}
-
-	private static int parseToInteger(String input) {
-		try {
-			return Integer.parseInt(input);
-		} catch (NumberFormatException e) {
-			throw new NumberFormatException("[ERROR] 보너스 번호는 숫자여야 합니다.");
-		}
+		return ParserUtils.parseToInteger(trimmedInput, ERROR_INVALID_FORMAT);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/parser/ParserUtils.java b/src/main/java/lotto/parser/ParserUtils.java
new file mode 100644
index 0000000000..430a63b3ca
--- /dev/null
+++ b/src/main/java/lotto/parser/ParserUtils.java
@@ -0,0 +1,42 @@
+package lotto.parser;
+
+import java.util.Objects;
+
+/**
+ * Parser들이 공통으로 사용하는 유틸리티 메서드를 제공합니다.
+ */
+public class ParserUtils {
+
+	private ParserUtils() {
+		// 유틸리티 클래스는 인스턴스화 방지
+	}
+
+	/**
+	 * 입력이 null이거나 빈 문자열(공백 포함)인지 검증합니다.
+	 *
+	 * @param input 검증할 입력 문자열
+	 * @param errorMessage 예외 발생 시 표시할 에러 메시지
+	 * @throws IllegalArgumentException 입력이 null이거나 빈 문자열인 경우
+	 */
+	public static void validateNotNullOrEmpty(String input, String errorMessage) {
+		if (Objects.isNull(input) || input.trim().isEmpty()) {
+			throw new IllegalArgumentException(errorMessage);
+		}
+	}
+
+	/**
+	 * 문자열을 정수로 파싱합니다.
+	 *
+	 * @param input 파싱할 문자열
+	 * @param errorMessage 파싱 실패 시 표시할 에러 메시지
+	 * @return 파싱된 정수
+	 * @throws NumberFormatException 숫자로 변환할 수 없는 경우
+	 */
+	public static int parseToInteger(String input, String errorMessage) {
+		try {
+			return Integer.parseInt(input);
+		} catch (NumberFormatException e) {
+			throw new NumberFormatException(errorMessage);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/parser/PurchaseAmountParser.java b/src/main/java/lotto/parser/PurchaseAmountParser.java
index 0ffeb12f29..af544f8b80 100644
--- a/src/main/java/lotto/parser/PurchaseAmountParser.java
+++ b/src/main/java/lotto/parser/PurchaseAmountParser.java
@@ -1,19 +1,20 @@
 package lotto.parser;
 
 public class PurchaseAmountParser {
+	private static final String ERROR_EMPTY_INPUT = "[ERROR] 구입 금액을 입력해주세요.";
+	private static final String ERROR_INVALID_FORMAT = "[ERROR] 구입 금액은 숫자여야 합니다.";
 
+	/**
+	 * 사용자 입력 문자열(구입 금액)을 정수로 파싱하여 반환합니다.
+	 *
+	 * @param input 사용자가 입력한 구입 금액 문자열
+	 * @return 파싱된 구입 금액 (정수)
+	 * @throws IllegalArgumentException 입력이 null 또는 빈 문자열인 경우
+	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
+	 */
 	public static int parse(String input) {
-		if (input == null || input.trim().isEmpty()) {
-			throw new IllegalArgumentException("[ERROR] 구입 금액을 입력해주세요.");
-		}
-		return parseToInteger(input.trim());
-	}
-
-	private static int parseToInteger(String input) {
-		try {
-			return Integer.parseInt(input);
-		} catch (NumberFormatException e) {
-			throw new NumberFormatException("[ERROR] 구입 금액은 숫자여야 합니다.");
-		}
+		ParserUtils.validateNotNullOrEmpty(input, ERROR_EMPTY_INPUT);
+		String trimmedInput = input.trim();
+		return ParserUtils.parseToInteger(trimmedInput, ERROR_INVALID_FORMAT);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/parser/WinningNumbersParser.java b/src/main/java/lotto/parser/WinningNumbersParser.java
index c578b87198..259fc0e0b1 100644
--- a/src/main/java/lotto/parser/WinningNumbersParser.java
+++ b/src/main/java/lotto/parser/WinningNumbersParser.java
@@ -2,52 +2,47 @@
 
 import java.util.Arrays;
 import java.util.List;
-import java.util.Objects;
 import java.util.stream.Collectors;
 
 public class WinningNumbersParser {
 	private static final String SEPARATOR = ",";
+	private static final String ERROR_EMPTY_INPUT = "[ERROR] 당첨 번호를 입력해주세요.";
+	private static final String ERROR_EMPTY_VALUE = "[ERROR] 당첨 번호는 빈 값일 수 없습니다.";
+	private static final String ERROR_INVALID_FORMAT = "[ERROR] 당첨 번호는 숫자여야 합니다.";
 
 	/**
 	 * 사용자 입력 문자열(당첨 번호)을 정수 리스트로 파싱하여 반환합니다.
 	 *
 	 * @param input 사용자가 입력한 당첨 번호 문자열 (쉼표로 구분됨)
 	 * @return 파싱된 당첨 번호 리스트 (정수)
-	 * @throws IllegalArgumentException 입력이 null, 빈 문자열, 또는 쉼표 구분 형식이 아닌 경우
+	 * @throws IllegalArgumentException 입력이 null, 빈 문자열, 또는 빈 값이 포함된 경우
 	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
 	 */
 	public static List<Integer> parse(String input) {
-		validateNotNullOrEmpty(input);
+		ParserUtils.validateNotNullOrEmpty(input, ERROR_EMPTY_INPUT);
 
 		List<String> numberStrings = splitBySeparator(input);
 		return parseToIntegers(numberStrings);
 	}
 
-	private static void validateNotNullOrEmpty(String input) {
-		if (Objects.isNull(input) || input.trim().isEmpty()) {
-			throw new IllegalArgumentException("[ERROR] 당첨 번호를 입력해주세요.");
-		}
-	}
-
 	private static List<String> splitBySeparator(String input) {
 		List<String> parts = Arrays.stream(input.split(SEPARATOR, -1))
 			.map(String::trim)
 			.collect(Collectors.toList());
 
+		validateNoEmptyValues(parts);
+		return parts;
+	}
+
+	private static void validateNoEmptyValues(List<String> parts) {
 		if (parts.stream().anyMatch(String::isEmpty)) {
-			throw new IllegalArgumentException("[ERROR] 당첨 번호는 빈 값일 수 없습니다.");
+			throw new IllegalArgumentException(ERROR_EMPTY_VALUE);
 		}
-
-		return parts;
 	}
 
 	private static List<Integer> parseToIntegers(List<String> numberStrings) {
-		try {
-			return numberStrings.stream()
-				.map(Integer::parseInt)
-				.collect(Collectors.toList());
-		} catch (NumberFormatException e) {
-			throw new NumberFormatException("[ERROR] 당첨 번호는 숫자여야 합니다.");
-		}
+		return numberStrings.stream()
+			.map(str -> ParserUtils.parseToInteger(str, ERROR_INVALID_FORMAT))
+			.collect(Collectors.toList());
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/validator/InputValidator.java b/src/main/java/lotto/validator/InputValidator.java
index ee370a05a7..9dd427c303 100644
--- a/src/main/java/lotto/validator/InputValidator.java
+++ b/src/main/java/lotto/validator/InputValidator.java
@@ -9,48 +9,45 @@ public class InputValidator {
 
 	private static final int LOTTO_PRICE = 1000;
 	private static final int MIN_PURCHASE_AMOUNT = 1000;
-	private static final int ZERO_AMOUNT = 0;
 
+	/**
+	 * 구매 금액이 유효한지 검증합니다.
+	 *
+	 * @param amount 구매 금액
+	 * @throws IllegalArgumentException 금액이 0 이하, 1000원 미만, 1000원 단위가 아닌 경우
+	 */
 	public static void validatePurchaseAmount(int amount) {
-		validateNegative(amount);
-		validateZero(amount);
-		validateMinAmount(amount);
-		validateDivisibleByUnit(amount);
-	}
-
-	private static void validateNegative(int amount) {
-		if (amount < ZERO_AMOUNT) {
-			throw new IllegalArgumentException("[ERROR] 구입 금액은 양수여야 합니다.");
-		}
-	}
-
-	private static void validateZero(int amount) {
-		if (amount == ZERO_AMOUNT) {
+		if (amount <= 0) {
 			throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");
 		}
-	}
-
-	private static void validateMinAmount(int amount) {
-		// 1~999 사이의 금액을 검증합니다.
-		if (amount > ZERO_AMOUNT && amount < MIN_PURCHASE_AMOUNT) {
+		if (amount < MIN_PURCHASE_AMOUNT) {
 			throw new IllegalArgumentException("[ERROR] 구입 금액은 1,000원 이상이어야 합니다.");
 		}
-	}
-
-	private static void validateDivisibleByUnit(int amount) {
-		// validateMinAmount를 통과한, 1000 이상의 금액 중 단위가 맞지 않는 경우를 검증합니다.
-		if (amount >= MIN_PURCHASE_AMOUNT && amount % LOTTO_PRICE != 0) {
+		if (amount % LOTTO_PRICE != 0) {
 			throw new IllegalArgumentException("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
 		}
 	}
 
+	/**
+	 * 당첨 번호가 유효한지 검증합니다.
+	 * Lotto 객체 생성을 통해 null, 개수, 범위, 중복 검증을 수행합니다.
+	 *
+	 * @param numbers 당첨 번호 리스트
+	 * @throws IllegalArgumentException Lotto 생성 조건을 만족하지 않는 경우
+	 */
 	public static void validateWinningNumbers(List<Integer> numbers) {
-		// Lotto 생성자에 List<Integer>를 전달하여 null, 개수, 범위, 중복 검증을 위임
 		new Lotto(numbers);
 	}
 
+	/**
+	 * 보너스 번호가 유효한지 검증합니다.
+	 * WinningLotto 객체 생성을 통해 범위 및 중복 검증을 수행합니다.
+	 *
+	 * @param winningNumbers 당첨 번호 Lotto 객체
+	 * @param bonusNumber 보너스 번호
+	 * @throws IllegalArgumentException WinningLotto 생성 조건을 만족하지 않는 경우
+	 */
 	public static void validateBonusNumber(Lotto winningNumbers, int bonusNumber) {
-		// WinningLotto 생성자를 호출하여 범위 및 중복 검증을 위임
 		new WinningLotto(winningNumbers, bonusNumber);
 	}
 }
\ No newline at end of file
diff --git a/src/test/java/lotto/ApplicationTest.java b/src/test/java/lotto/ApplicationTest.java
index 1ef244d4a3..a15c7d1f52 100644
--- a/src/test/java/lotto/ApplicationTest.java
+++ b/src/test/java/lotto/ApplicationTest.java
@@ -10,6 +10,49 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 class ApplicationTest extends NsTest {
+    private static final String ERROR_MESSAGE = "[ERROR]";
+
+    @Test
+    void 기능_테스트() {
+        assertRandomUniqueNumbersInRangeTest(
+                () -> {
+                    run("8000", "1,2,3,4,5,6", "7");
+                    assertThat(output()).contains(
+                            "8개를 구매했습니다.",
+                            "[8, 21, 23, 41, 42, 43]",
+                            "[3, 5, 11, 16, 32, 38]",
+                            "[7, 11, 16, 35, 36, 44]",
+                            "[1, 8, 11, 31, 41, 42]",
+                            "[13, 14, 16, 38, 42, 45]",
+                            "[7, 11, 30, 40, 42, 43]",
+                            "[2, 13, 22, 32, 38, 45]",
+                            "[1, 3, 5, 14, 22, 45]",
+                            "3개 일치 (5,000원) - 1개",
+                            "4개 일치 (50,000원) - 0개",
+                            "5개 일치 (1,500,000원) - 0개",
+                            "5개 일치, 보너스 볼 일치 (30,000,000원) - 0개",
+                            "6개 일치 (2,000,000,000원) - 0개",
+                            "총 수익률은 62.5%입니다."
+                    );
+                },
+                List.of(8, 21, 23, 41, 42, 43),
+                List.of(3, 5, 11, 16, 32, 38),
+                List.of(7, 11, 16, 35, 36, 44),
+                List.of(1, 8, 11, 31, 41, 42),
+                List.of(13, 14, 16, 38, 42, 45),
+                List.of(7, 11, 30, 40, 42, 43),
+                List.of(2, 13, 22, 32, 38, 45),
+                List.of(1, 3, 5, 14, 22, 45)
+        );
+    }
+
+    @Test
+    void 예외_테스트() {
+        assertSimpleTest(() -> {
+            runException("1000j");
+            assertThat(output()).contains(ERROR_MESSAGE);
+        });
+    }
 
     @Override
     public void runMain() {
diff --git a/src/test/java/lotto/parser/ParserUtilsTest.java b/src/test/java/lotto/parser/ParserUtilsTest.java
new file mode 100644
index 0000000000..9f5edebc33
--- /dev/null
+++ b/src/test/java/lotto/parser/ParserUtilsTest.java
@@ -0,0 +1,157 @@
+package lotto.parser;
+
+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;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class ParserUtilsTest {
+
+	@DisplayName("정상1: 유효한 문자열은 검증을 통과한다")
+	@Test
+	void test1() {
+		// Given
+		String input = "8000";
+		String errorMessage = "[ERROR] 테스트 에러";
+
+		// When & Then
+		ParserUtils.validateNotNullOrEmpty(input, errorMessage);
+		// 예외가 발생하지 않으면 테스트 통과
+	}
+
+	@DisplayName("정상2: 공백이 포함된 문자열은 검증을 통과한다")
+	@Test
+	void test2() {
+		// Given
+		String input = " 8000 ";
+		String errorMessage = "[ERROR] 테스트 에러";
+
+		// When & Then
+		ParserUtils.validateNotNullOrEmpty(input, errorMessage);
+		// 예외가 발생하지 않으면 테스트 통과
+	}
+
+	@DisplayName("예외1: 입력이 null이면 IllegalArgumentException 발생")
+	@Test
+	void test3() {
+		// Given
+		String input = null;
+		String errorMessage = "[ERROR] null 입력 에러";
+
+		// When & Then
+		assertThatThrownBy(() -> ParserUtils.validateNotNullOrEmpty(input, errorMessage))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage(errorMessage);
+	}
+
+	@DisplayName("예외2: 입력이 빈 문자열이면 IllegalArgumentException 발생")
+	@Test
+	void test4() {
+		// Given
+		String input = "";
+		String errorMessage = "[ERROR] 빈 문자열 에러";
+
+		// When & Then
+		assertThatThrownBy(() -> ParserUtils.validateNotNullOrEmpty(input, errorMessage))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage(errorMessage);
+	}
+
+	@DisplayName("예외3: 입력이 공백만 있으면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {" ", "  "})
+	void test5(String input) {
+		// Given
+		String errorMessage = "[ERROR] 공백 에러";
+
+		// When & Then
+		assertThatThrownBy(() -> ParserUtils.validateNotNullOrEmpty(input, errorMessage))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage(errorMessage);
+	}
+
+
+	@DisplayName("정상3: 유효한 문자열을 정수로 파싱한다")
+	@Test
+	void test6() {
+		// Given
+		String input = "8000";
+		String errorMessage = "[ERROR] 파싱 에러";
+
+		// When
+		int result = ParserUtils.parseToInteger(input, errorMessage);
+
+		// Then
+		assertThat(result).isEqualTo(8000);
+	}
+
+	@DisplayName("정상4: 음수 문자열을 음수 정수로 파싱한다")
+	@Test
+	void test7() {
+		// Given
+		String input = "-1000";
+		String errorMessage = "[ERROR] 파싱 에러";
+
+		// When
+		int result = ParserUtils.parseToInteger(input, errorMessage);
+
+		// Then
+		assertThat(result).isEqualTo(-1000);
+	}
+
+	@DisplayName("정상5: 0을 정수로 파싱한다")
+	@Test
+	void test8() {
+		// Given
+		String input = "0";
+		String errorMessage = "[ERROR] 파싱 에러";
+
+		// When
+		int result = ParserUtils.parseToInteger(input, errorMessage);
+
+		// Then
+		assertThat(result).isEqualTo(0);
+	}
+
+	@DisplayName("예외4: 숫자가 아닌 문자가 포함되면 NumberFormatException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"abc", "1000원", "1,000", "1.5"})
+	void test9(String input) {
+		// Given
+		String errorMessage = "[ERROR] 숫자 형식 에러";
+
+		// When & Then
+		assertThatThrownBy(() -> ParserUtils.parseToInteger(input, errorMessage))
+			.isInstanceOf(NumberFormatException.class)
+			.hasMessage(errorMessage);
+	}
+
+	@DisplayName("예외5: 빈 문자열은 NumberFormatException 발생")
+	@Test
+	void test10() {
+		// Given
+		String input = "";
+		String errorMessage = "[ERROR] 빈 문자열 파싱 에러";
+
+		// When & Then
+		assertThatThrownBy(() -> ParserUtils.parseToInteger(input, errorMessage))
+			.isInstanceOf(NumberFormatException.class)
+			.hasMessage(errorMessage);
+	}
+
+	@DisplayName("예외6: Integer 범위를 벗어나면 NumberFormatException 발생")
+	@Test
+	void test11() {
+		// Given
+		String input = "9999999999999999999"; // Integer.MAX_VALUE를 초과
+		String errorMessage = "[ERROR] 범위 초과 에러";
+
+		// When & Then
+		assertThatThrownBy(() -> ParserUtils.parseToInteger(input, errorMessage))
+			.isInstanceOf(NumberFormatException.class)
+			.hasMessage(errorMessage);
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/parser/PurchaseAmountParserTest.java b/src/test/java/lotto/parser/PurchaseAmountParserTest.java
index 9200c6652e..0400779ec1 100644
--- a/src/test/java/lotto/parser/PurchaseAmountParserTest.java
+++ b/src/test/java/lotto/parser/PurchaseAmountParserTest.java
@@ -1,7 +1,6 @@
 package lotto.parser;
 
 import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
@@ -24,9 +23,22 @@ void test1() {
 		assertThat(result).isEqualTo(8000);
 	}
 
-	@DisplayName("예외1: 입력이 null이면 IllegalArgumentException 발생")
+	@DisplayName("정상2: 앞뒤 공백이 포함된 문자열도 정수로 파싱한다")
 	@Test
 	void test2() {
+		// Given
+		String input = " 8000 ";
+
+		// When
+		int result = PurchaseAmountParser.parse(input);
+
+		// Then
+		assertThat(result).isEqualTo(8000);
+	}
+
+	@DisplayName("예외1: 입력이 null이면 IllegalArgumentException 발생")
+	@Test
+	void test3() {
 		String input = null;
 
 		assertThatThrownBy(() -> PurchaseAmountParser.parse(input))
@@ -34,21 +46,19 @@ void test2() {
 			.hasMessage("[ERROR] 구입 금액을 입력해주세요.");
 	}
 
-	@Tag("error")
 	@DisplayName("예외2: 입력이 빈 문자열 또는 공백이면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: \"{0}\"")
 	@ValueSource(strings = {"", " "})
-	void test3(String input) {
+	void test4(String input) {
 		assertThatThrownBy(() -> PurchaseAmountParser.parse(input))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액을 입력해주세요.");
 	}
 
-	@Tag("error")
 	@DisplayName("예외3: 숫자가 아닌 문자가 포함되면 NumberFormatException 발생")
 	@ParameterizedTest(name = "입력: \"{0}\"")
 	@ValueSource(strings = {"1000원", "a1000", "1,000"})
-	void test4(String input) {
+	void test5(String input) {
 		assertThatThrownBy(() -> PurchaseAmountParser.parse(input))
 			.isInstanceOf(NumberFormatException.class)
 			.hasMessage("[ERROR] 구입 금액은 숫자여야 합니다.");
diff --git a/src/test/java/lotto/parser/WinningNumbersParserTest.java b/src/test/java/lotto/parser/WinningNumbersParserTest.java
index 84cdcab7df..aee508835b 100644
--- a/src/test/java/lotto/parser/WinningNumbersParserTest.java
+++ b/src/test/java/lotto/parser/WinningNumbersParserTest.java
@@ -12,7 +12,6 @@
 
 class WinningNumbersParserTest {
 
-
 	@DisplayName("정상1: 쉼표로 구분된 문자열을 정수 리스트로 파싱한다")
 	@Test
 	void test1() {
@@ -26,9 +25,22 @@ void test1() {
 		assertThat(result).containsExactly(1, 2, 3, 4, 5, 6);
 	}
 
-	@DisplayName("예외1: 입력이 null이면 IllegalArgumentException 발생")
+	@DisplayName("정상2: 공백이 포함된 문자열도 정수 리스트로 파싱한다")
 	@Test
 	void test2() {
+		// Given
+		String input = " 1 , 2 , 3 , 4 , 5 , 6 ";
+
+		// When
+		List<Integer> result = WinningNumbersParser.parse(input);
+
+		// Then
+		assertThat(result).containsExactly(1, 2, 3, 4, 5, 6);
+	}
+
+	@DisplayName("예외1: 입력이 null이면 IllegalArgumentException 발생")
+	@Test
+	void test3() {
 		String input = null;
 
 		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
@@ -38,8 +50,8 @@ void test2() {
 
 	@DisplayName("예외2: 입력이 빈 문자열 또는 공백이면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: \"{0}\"")
-	@ValueSource(strings = {"", " "})
-	void test3(String input) {
+	@ValueSource(strings = {"", " ", "  "})
+	void test4(String input) {
 		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 당첨 번호를 입력해주세요.");
@@ -47,7 +59,7 @@ void test3(String input) {
 
 	@DisplayName("예외3: 숫자가 아닌 값이 포함되면 NumberFormatException 발생")
 	@Test
-	void test4() {
+	void test5() {
 		String input = "1,2,a,4,5,6";
 
 		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
@@ -55,9 +67,9 @@ void test4() {
 			.hasMessage("[ERROR] 당첨 번호는 숫자여야 합니다.");
 	}
 
-	@DisplayName("예외4: 쉼표로 구분된 항목이 빈 값(공백 포함)이면 IllegalArgumentException 발생")
+	@DisplayName("예외4: 쉼표로 구분된 항목이 빈 값이면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: \"{0}\"")
-	@ValueSource(strings = {"1,,3,4,5,6", "1,2, ,4,5,6", "1,2,3,4,5,6,"})
+	@ValueSource(strings = {"1,,3,4,5,6", "1,2, ,4,5,6"})
 	void test6(String input) {
 		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
 			.isInstanceOf(IllegalArgumentException.class)
@@ -66,7 +78,7 @@ void test6(String input) {
 
 	@DisplayName("예외5: 문자열이 쉼표로 끝나는 경우 IllegalArgumentException 발생")
 	@Test
-	void test5() {
+	void test7() {
 		String input = "1,2,3,4,5,6,";
 
 		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
diff --git a/src/test/java/lotto/validator/InputValidatorTest.java b/src/test/java/lotto/validator/InputValidatorTest.java
index 6041029322..c95ee4cfa2 100644
--- a/src/test/java/lotto/validator/InputValidatorTest.java
+++ b/src/test/java/lotto/validator/InputValidatorTest.java
@@ -51,17 +51,8 @@ void test4() {
 
 	@DisplayName("예외1: 음수를 입력하면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
-	@ValueSource(ints = {-1, -1000})
+	@ValueSource(ints = {-1, -1000, 0})
 	void test5(int amount) {
-		assertThatThrownBy(() -> validatePurchaseAmount(amount))
-			.isInstanceOf(IllegalArgumentException.class)
-			.hasMessage("[ERROR] 구입 금액은 양수여야 합니다.");
-	}
-
-	@DisplayName("예외2: 0을 입력하면 IllegalArgumentException 발생")
-	@Test
-	void test6() {
-		int amount = 0;
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 0보다 커야 합니다.");
@@ -70,7 +61,7 @@ void test6() {
 	@DisplayName("예외3: 1,000원 미만(1~999)이면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {1, 500, 999})
-	void test7(int amount) {
+	void test6(int amount) {
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 1,000원 이상이어야 합니다.");
@@ -79,7 +70,7 @@ void test7(int amount) {
 	@DisplayName("예외4: 1,000원으로 나누어떨어지지 않으면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {1001, 1500, 8999})
-	void test8(int amount) {
+	void test7(int amount) {
 		assertThatThrownBy(() -> validatePurchaseAmount(amount))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
@@ -88,7 +79,7 @@ void test8(int amount) {
 
 	@DisplayName("예외5: 번호 리스트가 null이면 IllegalArgumentException 발생")
 	@Test
-	void test9() {
+	void test8() {
 		assertThatThrownBy(() -> validateWinningNumbers(null))
 			.isInstanceOf(IllegalArgumentException.class)
 			.hasMessage("[ERROR] 로또 번호를 입력해주세요.");
@@ -96,7 +87,7 @@ void test9() {
 
 	@DisplayName("예외6: 번호가 6개가 아니면 IllegalArgumentException 발생")
 	@Test
-	void test10() {
+	void test9() {
 		List<Integer> invalidSizeNumbers = List.of(1, 2, 3, 4, 5);
 		assertThatThrownBy(() -> validateWinningNumbers(invalidSizeNumbers))
 			.isInstanceOf(IllegalArgumentException.class)
@@ -106,7 +97,7 @@ void test10() {
 	@DisplayName("예외7: 1~45 범위를 벗어나면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {0, 46})
-	void test11(int invalidNumber) {
+	void test10(int invalidNumber) {
 		List<Integer> outOfRangeNumbers = List.of(1, 2, 3, 4, 5, invalidNumber);
 		assertThatThrownBy(() -> validateWinningNumbers(outOfRangeNumbers))
 			.isInstanceOf(IllegalArgumentException.class)
@@ -115,7 +106,7 @@ void test11(int invalidNumber) {
 
 	@DisplayName("예외8 중복된 번호가 있으면 IllegalArgumentException 발생")
 	@Test
-	void test12() {
+	void test11() {
 		List<Integer> duplicateNumbers = List.of(1, 2, 3, 4, 5, 5);
 		assertThatThrownBy(() -> validateWinningNumbers(duplicateNumbers))
 			.isInstanceOf(IllegalArgumentException.class)
@@ -125,7 +116,7 @@ void test12() {
 	@DisplayName("예외12: 보너스 번호가 1~45 범위를 벗어나면 IllegalArgumentException 발생")
 	@ParameterizedTest(name = "입력: {0}")
 	@ValueSource(ints = {0, 46})
-	void test13(int invalidNumber) {
+	void test12(int invalidNumber) {
 		Lotto validWinningLottoNumbers = new Lotto(List.of(1, 2, 3, 4, 5, 6));
 
 		assertThatThrownBy(() -> validateBonusNumber(validWinningLottoNumbers, invalidNumber))
@@ -135,7 +126,7 @@ void test13(int invalidNumber) {
 
 	@DisplayName("예외13: 보너스 번호가 당첨 번호와 중복되면 IllegalArgumentException 발생")
 	@Test
-	void test14() {
+	void test13() {
 		Lotto validWinningLottoNumbers = new Lotto(List.of(1, 2, 3, 4, 5, 6));
 		int duplicateNumber = 6;
 

From 09082b2be47a3e1605b074b375bff2e4b9919d55 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Wed, 5 Nov 2025 08:57:59 +0900
Subject: [PATCH 19/21] =?UTF-8?q?feat(common):=20LottoConstants=20?=
 =?UTF-8?q?=EA=B3=B5=ED=86=B5=20=EC=83=81=EC=88=98=20=ED=81=B4=EB=9E=98?=
 =?UTF-8?q?=EC=8A=A4=20=EC=83=9D=EC=84=B1,=20=EC=97=90=EB=9F=AC=EB=A9=94?=
 =?UTF-8?q?=EC=84=B8=EC=A7=80=EB=8F=84=20=EA=B3=B5=ED=86=B5=20=EC=83=81?=
 =?UTF-8?q?=EC=88=98=EB=A5=BC=20=EC=82=AC=EC=9A=A9=ED=95=A0=EA=BB=80?=
 =?UTF-8?q?=EC=A7=80=20=EA=B3=A0=EB=AF=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/lotto/common/LottoConstants.java     | 21 +++++++++++++
 .../java/lotto/service/LottoGameService.java  |  8 +++--
 src/main/java/lotto/util/LottoGenerator.java  |  6 +---
 .../java/lotto/validator/InputValidator.java  |  5 ++-
 .../java/lotto/util/LottoGeneratorTest.java   | 31 ++++++++++++++-----
 5 files changed, 52 insertions(+), 19 deletions(-)
 create mode 100644 src/main/java/lotto/common/LottoConstants.java

diff --git a/src/main/java/lotto/common/LottoConstants.java b/src/main/java/lotto/common/LottoConstants.java
new file mode 100644
index 0000000000..faffb036b0
--- /dev/null
+++ b/src/main/java/lotto/common/LottoConstants.java
@@ -0,0 +1,21 @@
+package lotto.common;
+
+/**
+ * 로또 게임에서 사용하는 공통 상수를 정의합니다.
+ */
+public class LottoConstants {
+
+	private LottoConstants() {
+		// 상수 클래스는 인스턴스화 방지
+	}
+
+	// 로또 번호 범위
+	public static final int MIN_LOTTO_NUMBER = 1;
+	public static final int MAX_LOTTO_NUMBER = 45;
+	public static final int LOTTO_NUMBER_COUNT = 6;
+
+	// 로또 가격
+	public static final int LOTTO_PRICE = 1000;
+
+	public static final int MIN_PURCHASE_AMOUNT = 1000;
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/service/LottoGameService.java b/src/main/java/lotto/service/LottoGameService.java
index 9c02995a1a..71227b0a6a 100644
--- a/src/main/java/lotto/service/LottoGameService.java
+++ b/src/main/java/lotto/service/LottoGameService.java
@@ -1,5 +1,7 @@
 package lotto.service;
 
+import static lotto.common.LottoConstants.*;
+
 import lotto.domain.*;
 import lotto.parser.BonusNumberParser;
 import lotto.parser.PurchaseAmountParser;
@@ -50,8 +52,8 @@ private int inputPurchaseAmount() {
 			try {
 				String input = inputView.inputPurchaseAmount();
 				int amount = PurchaseAmountParser.parse(input);
-				if (amount % LottoGenerator.LOTTO_PRICE != 0) {
-					throw new IllegalArgumentException("구입 금액은 " + LottoGenerator.LOTTO_PRICE + "원 단위여야 합니다.");
+				if (amount % LOTTO_PRICE != 0) {
+					throw new IllegalArgumentException("구입 금액은 " + LOTTO_PRICE + "원 단위여야 합니다.");
 				}
 				return amount;
 			} catch (IllegalArgumentException e) {
@@ -61,7 +63,7 @@ private int inputPurchaseAmount() {
 	}
 
 	private LottoTickets buyLottos(int purchaseAmount) {
-		int lottoCount = purchaseAmount / LottoGenerator.LOTTO_PRICE;
+		int lottoCount = purchaseAmount / LOTTO_PRICE;
 		List<Lotto> lottos = lottoGenerator.generateLottos(lottoCount);
 		return new LottoTickets(lottos);
 	}
diff --git a/src/main/java/lotto/util/LottoGenerator.java b/src/main/java/lotto/util/LottoGenerator.java
index 4bcd67f615..4b1aa77bbf 100644
--- a/src/main/java/lotto/util/LottoGenerator.java
+++ b/src/main/java/lotto/util/LottoGenerator.java
@@ -7,13 +7,9 @@
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
-
-import static lotto.domain.Lotto.LOTTO_NUMBER_COUNT;
-import static lotto.domain.Lotto.MAX_LOTTO_NUMBER;
-import static lotto.domain.Lotto.MIN_LOTTO_NUMBER;
+import static lotto.common.LottoConstants.*;
 
 public class LottoGenerator {
-	public static final int LOTTO_PRICE = 1000;
 
 	public static List<Lotto> generateLottos(int purchaseAmount) {
 		int lottoCount = purchaseAmount / LOTTO_PRICE;
diff --git a/src/main/java/lotto/validator/InputValidator.java b/src/main/java/lotto/validator/InputValidator.java
index 9dd427c303..d9a410a9ff 100644
--- a/src/main/java/lotto/validator/InputValidator.java
+++ b/src/main/java/lotto/validator/InputValidator.java
@@ -1,5 +1,7 @@
 package lotto.validator;
 
+import static lotto.common.LottoConstants.*;
+
 import java.util.List;
 
 import lotto.domain.Lotto;
@@ -7,9 +9,6 @@
 
 public class InputValidator {
 
-	private static final int LOTTO_PRICE = 1000;
-	private static final int MIN_PURCHASE_AMOUNT = 1000;
-
 	/**
 	 * 구매 금액이 유효한지 검증합니다.
 	 *
diff --git a/src/test/java/lotto/util/LottoGeneratorTest.java b/src/test/java/lotto/util/LottoGeneratorTest.java
index 379586e081..b7ce1dc7fc 100644
--- a/src/test/java/lotto/util/LottoGeneratorTest.java
+++ b/src/test/java/lotto/util/LottoGeneratorTest.java
@@ -10,20 +10,18 @@
 import java.util.List;
 import java.util.Set;
 
-import static lotto.domain.Lotto.LOTTO_NUMBER_COUNT;
-import static lotto.domain.Lotto.MAX_LOTTO_NUMBER;
-import static lotto.domain.Lotto.MIN_LOTTO_NUMBER;
+import static lotto.common.LottoConstants.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 class LottoGeneratorTest {
 
 	@DisplayName("정상1: 구입 금액에 따라 정확한 개수의 로또를 생성한다")
-	@ParameterizedTest(name = "구입 금액: {0}원, 예상 개수: {1}개")
+	@ParameterizedTest(name = "구입 금액: {0}원")
 	@ValueSource(ints = {1000, 5000, 10000})
 	void test1(int purchaseAmount) {
 		// Given & When
 		List<Lotto> lottos = LottoGenerator.generateLottos(purchaseAmount);
-		int expectedCount = purchaseAmount / 1000;
+		int expectedCount = purchaseAmount / LOTTO_PRICE;
 
 		// Then
 		assertThat(lottos).hasSize(expectedCount);
@@ -32,7 +30,7 @@ void test1(int purchaseAmount) {
 	@DisplayName("정상2: 생성된 각 로또가 유효한 번호 6개를 포함하고 있는지 검증한다")
 	@Test
 	void test2() {
-		// Given: 3000원 구매 (3개 로또 생성)
+		// Given
 		int purchaseAmount = 3000;
 
 		// When
@@ -52,8 +50,25 @@ void test2() {
 			Set<Integer> uniqueNumbers = new HashSet<>(numbers);
 			assertThat(uniqueNumbers).hasSize(LOTTO_NUMBER_COUNT);
 
-			// 4. 오름차순으로 정렬되어 있어야 한다. (Lotto 객체 내부에서 처리되므로 확인)
+			// 4. 오름차순으로 정렬되어 있어야 한다.
 			assertThat(numbers).isSorted();
 		}
 	}
-}
+
+	@DisplayName("정상3: 여러 로또 생성 시 각 로또가 서로 다른 번호 조합을 가질 가능성이 있다")
+	@Test
+	void test3() {
+		// Given: 100개 로또 생성
+		int purchaseAmount = 100_000;
+
+		// When
+		List<Lotto> lottos = LottoGenerator.generateLottos(purchaseAmount);
+
+		// Then
+		// 100개 로또가 모두 같을 확률은 거의 0이므로, 최소 2개는 다를 것으로 기대
+		Set<List<Integer>> uniqueLottos = new HashSet<>();
+		lottos.forEach(lotto -> uniqueLottos.add(lotto.getNumbers()));
+
+		assertThat(uniqueLottos.size()).isGreaterThan(1);
+	}
+}
\ No newline at end of file

From 35ca8ebfb9db70d1b0f91e2ed1e9ca22fd268f3c Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Wed, 5 Nov 2025 09:42:11 +0900
Subject: [PATCH 20/21] =?UTF-8?q?fix:=20=EC=97=90=EB=9F=AC=EB=A9=94?=
 =?UTF-8?q?=EC=84=B8=EC=A7=80=20=EC=83=81=EC=88=98=20=EC=82=AC=EC=9A=A9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                                     |  75 +++++++++++++
 src/main/java/lotto/common/ErrorMessages.java |  40 +++++++
 src/main/java/lotto/common/ViewMessages.java  |  23 ++++
 src/main/java/lotto/domain/Lotto.java         |  18 ++--
 src/main/java/lotto/domain/LottoResult.java   |  15 +--
 src/main/java/lotto/domain/LottoTickets.java  |   6 +-
 src/main/java/lotto/domain/WinningLotto.java  |  11 +-
 .../java/lotto/parser/BonusNumberParser.java  |   8 +-
 .../lotto/parser/PurchaseAmountParser.java    |   8 +-
 .../lotto/parser/WinningNumbersParser.java    |  11 +-
 .../java/lotto/validator/InputValidator.java  |  16 +--
 src/main/java/lotto/view/InputView.java       |  27 +++--
 src/main/java/lotto/view/OutputView.java      |  66 ++++++------
 .../java/lotto/domain/WinningLottoTest.java   |   2 +-
 src/test/java/lotto/view/OutputViewTest.java  | 102 ++++++++++++++++++
 15 files changed, 338 insertions(+), 90 deletions(-)
 create mode 100644 src/main/java/lotto/common/ErrorMessages.java
 create mode 100644 src/main/java/lotto/common/ViewMessages.java
 create mode 100644 src/test/java/lotto/view/OutputViewTest.java

diff --git a/README.md b/README.md
index bc6eeef8c3..1f4cdf770b 100644
--- a/README.md
+++ b/README.md
@@ -501,6 +501,81 @@ if (lottoTickets == null) {
 
 ---
 
+## 📊 상수 관리 현황
+
+### ErrorMessages 사용 현황
+
+| 상수 이름 | 사용 위치 | 상태 |
+|-----------|-----------|------|
+| `PURCHASE_AMOUNT_ZERO` | InputValidator | ✅ |
+| `PURCHASE_AMOUNT_MINIMUM` | InputValidator | ✅ |
+| `PURCHASE_AMOUNT_UNIT` | InputValidator | ✅ |
+| `PURCHASE_AMOUNT_EMPTY` | PurchaseAmountParser | ✅ |
+| `PURCHASE_AMOUNT_INVALID_FORMAT` | PurchaseAmountParser | ✅ |
+| `LOTTO_NUMBERS_NULL` | Lotto, WinningLotto | ✅ |
+| `LOTTO_NUMBERS_SIZE` | Lotto | ✅ |
+| `LOTTO_NUMBERS_DUPLICATE` | Lotto | ✅ |
+| `LOTTO_NUMBERS_RANGE` | Lotto | ✅ |
+| `WINNING_NUMBERS_EMPTY` | WinningNumbersParser | ✅ |
+| `WINNING_NUMBERS_INVALID_FORMAT` | WinningNumbersParser | ✅ |
+| `WINNING_NUMBERS_EMPTY_VALUE` | WinningNumbersParser | ✅ |
+| `BONUS_NUMBER_EMPTY` | BonusNumberParser | ✅ |
+| `BONUS_NUMBER_INVALID_FORMAT` | BonusNumberParser | ✅ |
+| `BONUS_NUMBER_RANGE` | WinningLotto | ✅ |
+| `BONUS_NUMBER_DUPLICATE` | WinningLotto | ✅ |
+| `LOTTO_TICKETS_NULL` | LottoTickets | ✅ |
+| `LOTTO_TICKETS_EMPTY` | LottoTickets | ✅ |
+| `LOTTO_RESULT_PURCHASE_AMOUNT` | LottoResult | ✅ |
+
+### ViewMessages 사용 현황
+
+| 상수 이름 | 사용 위치 | 용도 | 상태 |
+|-----------|-----------|------|------|
+| `INPUT_PURCHASE_AMOUNT` | InputView | 구매 금액 입력 안내 | ✅ |
+| `INPUT_WINNING_NUMBERS` | InputView | 당첨 번호 입력 안내 | ✅ |
+| `INPUT_BONUS_NUMBER` | InputView | 보너스 번호 입력 안내 | ✅ |
+| `PURCHASED_LOTTO_COUNT_FORMAT` | OutputView | 구매 개수 출력 | ✅ |
+| `WINNING_STATISTICS_HEADER` | OutputView | 통계 헤더 출력 | ✅ |
+| `SEPARATOR` | OutputView | 구분선 출력 | ✅ |
+| `RANK_FORMAT` | OutputView | 등수별 당첨 결과 출력 | ✅ |
+| `PROFIT_RATE_FORMAT` | OutputView | 수익률 출력 | ✅ |
+
+### LottoConstants 사용 현황
+
+| 상수 이름 | 값 | 사용 위치 | 상태 |
+|-----------|-----|-----------|------|
+| `MIN_LOTTO_NUMBER` | 1 | Lotto, WinningLotto, LottoGenerator | ✅ |
+| `MAX_LOTTO_NUMBER` | 45 | Lotto, WinningLotto, LottoGenerator | ✅ |
+| `LOTTO_NUMBER_COUNT` | 6 | Lotto, LottoGenerator | ✅ |
+| `LOTTO_PRICE` | 1000 | InputValidator, LottoGenerator | ✅ |
+
+---
+
+## 🎨 상수 설계 원칙
+
+### 1. 단일 책임 원칙 (SRP)
+- **ErrorMessages**: 에러 메시지만 관리
+- **ViewMessages**: View 출력 메시지만 관리
+- **LottoConstants**: 비즈니스 상수만 관리
+
+### 2. 중복 제거 (DRY)
+- 모든 문자열 리터럴을 상수로 추출
+- 한 곳에서 수정하면 전체에 반영
+
+### 3. 명확한 네이밍
+- 상수 이름만으로 용도를 파악 가능
+- 접두사를 통한 그룹핑 (PURCHASE_AMOUNT_*, LOTTO_NUMBERS_*)
+
+### 4. 패키지 구조
+```
+lotto/
+└── common/
+    ├── ErrorMessages.java      # 에러 메시지
+    ├── ViewMessages.java       # View 메시지
+    └── LottoConstants.java     # 비즈니스 상수
+```
+---
+
 ## 🧪 테스트
 
 ### 테스트 구조
diff --git a/src/main/java/lotto/common/ErrorMessages.java b/src/main/java/lotto/common/ErrorMessages.java
new file mode 100644
index 0000000000..1bba3f67b4
--- /dev/null
+++ b/src/main/java/lotto/common/ErrorMessages.java
@@ -0,0 +1,40 @@
+package lotto.common;
+
+/**
+ * 로또 게임에서 사용하는 에러 메시지를 정의합니다.
+ */
+public class ErrorMessages {
+
+	private ErrorMessages() {
+		// 상수 클래스는 인스턴스화 방지
+	}
+
+	// 구매 금액 관련
+	public static final String PURCHASE_AMOUNT_ZERO = "[ERROR] 구입 금액은 0보다 커야 합니다.";
+	public static final String PURCHASE_AMOUNT_MINIMUM = "[ERROR] 구입 금액은 1,000원 이상이어야 합니다.";
+	public static final String PURCHASE_AMOUNT_UNIT = "[ERROR] 구입 금액은 1,000원 단위여야 합니다.";
+	public static final String PURCHASE_AMOUNT_EMPTY = "[ERROR] 구입 금액을 입력해주세요.";
+	public static final String PURCHASE_AMOUNT_INVALID_FORMAT = "[ERROR] 구입 금액은 숫자여야 합니다.";
+
+	// 로또 번호 관련
+	public static final String LOTTO_NUMBERS_NULL = "[ERROR] 로또 번호를 입력해주세요.";
+	public static final String LOTTO_NUMBERS_SIZE = "[ERROR] 로또 번호는 6개여야 합니다.";
+	public static final String LOTTO_NUMBERS_DUPLICATE = "[ERROR] 로또 번호는 중복될 수 없습니다.";
+	public static final String LOTTO_NUMBERS_RANGE = "[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.";
+
+	// 당첨 번호 관련
+	public static final String WINNING_NUMBERS_EMPTY = "[ERROR] 당첨 번호를 입력해주세요.";
+	public static final String WINNING_NUMBERS_INVALID_FORMAT = "[ERROR] 당첨 번호는 숫자여야 합니다.";
+	public static final String WINNING_NUMBERS_EMPTY_VALUE = "[ERROR] 당첨 번호는 빈 값일 수 없습니다.";
+
+	// 보너스 번호 관련
+	public static final String BONUS_NUMBER_EMPTY = "[ERROR] 보너스 번호를 입력해주세요.";
+	public static final String BONUS_NUMBER_INVALID_FORMAT = "[ERROR] 보너스 번호는 숫자여야 합니다.";
+	public static final String BONUS_NUMBER_RANGE = "[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.";
+	public static final String BONUS_NUMBER_DUPLICATE = "[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.";
+
+	// 기타
+	public static final String LOTTO_TICKETS_NULL = "[ERROR] 로또 목록이 없습니다.";
+	public static final String LOTTO_TICKETS_EMPTY = "[ERROR] 최소 1개 이상의 로또를 구매해야 합니다.";
+	public static final String LOTTO_RESULT_PURCHASE_AMOUNT = "[ERROR] 구매 금액은 0보다 커야 합니다.";
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/common/ViewMessages.java b/src/main/java/lotto/common/ViewMessages.java
new file mode 100644
index 0000000000..f0b7d64a26
--- /dev/null
+++ b/src/main/java/lotto/common/ViewMessages.java
@@ -0,0 +1,23 @@
+package lotto.common;
+
+/**
+ * 로또 게임에서 사용하는 출력 메시지를 정의합니다.
+ */
+public class ViewMessages {
+
+	private ViewMessages() {
+		// 상수 클래스는 인스턴스화 방지
+	}
+
+	// 입력 안내
+	public static final String INPUT_PURCHASE_AMOUNT = "구입금액을 입력해 주세요.";
+	public static final String INPUT_WINNING_NUMBERS = "당첨 번호를 입력해 주세요.";
+	public static final String INPUT_BONUS_NUMBER = "보너스 번호를 입력해 주세요.";
+
+	// 결과 출력
+	public static final String PURCHASED_LOTTO_COUNT_FORMAT = "%d개를 구매했습니다.";
+	public static final String WINNING_STATISTICS_HEADER = "당첨 통계";
+	public static final String SEPARATOR = "---";
+	public static final String RANK_FORMAT = "%s (%s원) - %d개";
+	public static final String PROFIT_RATE_FORMAT = "총 수익률은 %.1f%%입니다.";
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/domain/Lotto.java b/src/main/java/lotto/domain/Lotto.java
index 893a449967..011cb381a9 100644
--- a/src/main/java/lotto/domain/Lotto.java
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -3,11 +3,10 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.stream.Collectors;
+import static lotto.common.ErrorMessages.*;
+import static lotto.common.LottoConstants.*;
 
 public class Lotto {
-	public static final int LOTTO_NUMBER_COUNT = 6;
-	public static final int MIN_LOTTO_NUMBER = 1;
-	public static final int MAX_LOTTO_NUMBER = 45;
 
 	private final List<Integer> numbers;
 
@@ -27,19 +26,18 @@ private void validate(List<Integer> numbers) {
 
 	private void validateNotNull(List<Integer> numbers) {
 		if (numbers == null) {
-			throw new IllegalArgumentException("[ERROR] 로또 번호를 입력해주세요.");
+			throw new IllegalArgumentException(LOTTO_NUMBERS_NULL);
 		}
 	}
 
 	private void validateSize(List<Integer> numbers) {
 		if (numbers.size() != LOTTO_NUMBER_COUNT) {
-			throw new IllegalArgumentException("[ERROR] 로또 번호는 6개여야 합니다.");
+			throw new IllegalArgumentException(LOTTO_NUMBERS_SIZE);
 		}
 	}
-
 	private void validateDuplicate(List<Integer> numbers) {
 		if (numbers.size() != new HashSet<>(numbers).size()) {
-			throw new IllegalArgumentException("[ERROR] 로또 번호는 중복될 수 없습니다.");
+			throw new IllegalArgumentException(LOTTO_NUMBERS_DUPLICATE);
 		}
 	}
 
@@ -48,7 +46,7 @@ private void validateRange(List<Integer> numbers) {
 			.anyMatch(number -> number < MIN_LOTTO_NUMBER || number > MAX_LOTTO_NUMBER);
 
 		if (isOutOfRange) {
-			throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+			throw new IllegalArgumentException(LOTTO_NUMBERS_RANGE);
 		}
 	}
 
@@ -68,8 +66,6 @@ public boolean contains(int number) {
 
 	@Override
 	public String toString() {
-		return numbers.stream()
-			.map(String::valueOf)
-			.collect(Collectors.joining(", ", "[", "]"));
+		return numbers.toString();
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/domain/LottoResult.java b/src/main/java/lotto/domain/LottoResult.java
index f3c09ff00b..ae1a748cb4 100644
--- a/src/main/java/lotto/domain/LottoResult.java
+++ b/src/main/java/lotto/domain/LottoResult.java
@@ -1,5 +1,7 @@
 package lotto.domain;
 
+import static lotto.common.ErrorMessages.*;
+
 import java.util.EnumMap;
 import java.util.List;
 import java.util.Map;
@@ -13,7 +15,7 @@ public class LottoResult {
 
 	public LottoResult(List<Rank> ranks, int purchaseAmount) {
 		if (purchaseAmount < MIN_PURCHASE_AMOUNT) {
-			throw new IllegalArgumentException("[ERROR] 구매 금액은 0보다 커야 합니다.");
+			throw new IllegalArgumentException(LOTTO_RESULT_PURCHASE_AMOUNT);
 		}
 		this.purchaseAmount = purchaseAmount;
 		this.result = countRanks(ranks);
@@ -48,14 +50,13 @@ public long calculateTotalProfit() {
 	}
 
 	/**
-	 * 총 수익률을 계산합니다. (소수점 둘째 자리에서 반올림하여 첫째 자리까지 표시)
-	 * 예: 62.5%, 100.0%
+	 * 총 수익률을 계산합니다.
+	 *
+	 * @return 수익률 (퍼센트, 소수점 포함)
 	 */
-	public String calculateProfitRate() {
+	public double calculateProfitRate() {
 		long totalProfit = calculateTotalProfit();
-		double profitRate = (double) totalProfit * 100 / purchaseAmount;
-
-		return String.format(PROFIT_RATE_FORMAT, profitRate);
+		return (double) totalProfit * 100 / purchaseAmount;
 	}
 
 	public Map<Rank, Integer> getResult() {
diff --git a/src/main/java/lotto/domain/LottoTickets.java b/src/main/java/lotto/domain/LottoTickets.java
index 589db2dceb..2108a8fc94 100644
--- a/src/main/java/lotto/domain/LottoTickets.java
+++ b/src/main/java/lotto/domain/LottoTickets.java
@@ -1,5 +1,7 @@
 package lotto.domain;
 
+import static lotto.common.ErrorMessages.*;
+
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
@@ -12,11 +14,11 @@ public class LottoTickets {
 
 	public LottoTickets(List<Lotto> lottos) {
 		if (Objects.isNull(lottos)) {
-			throw new IllegalArgumentException("[ERROR] 로또 목록이 없습니다.");
+			throw new IllegalArgumentException(LOTTO_TICKETS_NULL);
 		}
 
 		if (lottos.size() < MIN_LOTTO_COUNT) {
-			throw new IllegalArgumentException("[ERROR] 최소 1개 이상의 로또를 구매해야 합니다.");
+			throw new IllegalArgumentException(LOTTO_TICKETS_EMPTY);
 		}
 
 		this.lottos = lottos;
diff --git a/src/main/java/lotto/domain/WinningLotto.java b/src/main/java/lotto/domain/WinningLotto.java
index c38ccaf75b..ddc15483d8 100644
--- a/src/main/java/lotto/domain/WinningLotto.java
+++ b/src/main/java/lotto/domain/WinningLotto.java
@@ -1,11 +1,12 @@
 package lotto.domain;
 
+import static lotto.common.ErrorMessages.*;
+import static lotto.common.LottoConstants.*;
+
 import java.util.List;
 import java.util.Objects;
 
 public class WinningLotto {
-	private static final int MIN_LOTTO_NUMBER = 1;
-	private static final int MAX_LOTTO_NUMBER = 45;
 	private final Lotto winningNumbers;
 	private final int bonusNumber;
 
@@ -23,19 +24,19 @@ private void validate(Lotto winningNumbers, int bonusNumber) {
 
 	private void validateNotNull(Lotto winningNumbers) {
 		if (Objects.isNull(winningNumbers)) {
-			throw new IllegalArgumentException("[ERROR] 당첨 번호를 입력해주세요.");
+			throw new IllegalArgumentException(LOTTO_NUMBERS_NULL);
 		}
 	}
 
 	private void validateBonusNumberRange(int bonusNumber) {
 		if (bonusNumber < MIN_LOTTO_NUMBER || bonusNumber > MAX_LOTTO_NUMBER) {
-			throw new IllegalArgumentException("[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.");
+			throw new IllegalArgumentException(BONUS_NUMBER_RANGE);
 		}
 	}
 
 	private void validateDuplicateWithWinningNumbers(Lotto winningNumbers, int bonusNumber) {
 		if (winningNumbers.contains(bonusNumber)) {
-			throw new IllegalArgumentException("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+			throw new IllegalArgumentException(BONUS_NUMBER_DUPLICATE);
 		}
 	}
 
diff --git a/src/main/java/lotto/parser/BonusNumberParser.java b/src/main/java/lotto/parser/BonusNumberParser.java
index a3601c36a5..6bb392d378 100644
--- a/src/main/java/lotto/parser/BonusNumberParser.java
+++ b/src/main/java/lotto/parser/BonusNumberParser.java
@@ -1,8 +1,8 @@
 package lotto.parser;
 
+import static lotto.common.ErrorMessages.*;
+
 public class BonusNumberParser {
-	private static final String ERROR_EMPTY_INPUT = "[ERROR] 보너스 번호를 입력해주세요.";
-	private static final String ERROR_INVALID_FORMAT = "[ERROR] 보너스 번호는 숫자여야 합니다.";
 
 	/**
 	 * 사용자 입력 문자열(보너스 번호)을 정수로 파싱하여 반환합니다.
@@ -13,8 +13,8 @@ public class BonusNumberParser {
 	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
 	 */
 	public static int parse(String input) {
-		ParserUtils.validateNotNullOrEmpty(input, ERROR_EMPTY_INPUT);
+		ParserUtils.validateNotNullOrEmpty(input, BONUS_NUMBER_EMPTY);
 		String trimmedInput = input.trim();
-		return ParserUtils.parseToInteger(trimmedInput, ERROR_INVALID_FORMAT);
+		return ParserUtils.parseToInteger(trimmedInput, BONUS_NUMBER_INVALID_FORMAT);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/parser/PurchaseAmountParser.java b/src/main/java/lotto/parser/PurchaseAmountParser.java
index af544f8b80..9d62cc9c69 100644
--- a/src/main/java/lotto/parser/PurchaseAmountParser.java
+++ b/src/main/java/lotto/parser/PurchaseAmountParser.java
@@ -1,8 +1,8 @@
 package lotto.parser;
 
+import static lotto.common.ErrorMessages.*;
+
 public class PurchaseAmountParser {
-	private static final String ERROR_EMPTY_INPUT = "[ERROR] 구입 금액을 입력해주세요.";
-	private static final String ERROR_INVALID_FORMAT = "[ERROR] 구입 금액은 숫자여야 합니다.";
 
 	/**
 	 * 사용자 입력 문자열(구입 금액)을 정수로 파싱하여 반환합니다.
@@ -13,8 +13,8 @@ public class PurchaseAmountParser {
 	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
 	 */
 	public static int parse(String input) {
-		ParserUtils.validateNotNullOrEmpty(input, ERROR_EMPTY_INPUT);
+		ParserUtils.validateNotNullOrEmpty(input, PURCHASE_AMOUNT_EMPTY);
 		String trimmedInput = input.trim();
-		return ParserUtils.parseToInteger(trimmedInput, ERROR_INVALID_FORMAT);
+		return ParserUtils.parseToInteger(trimmedInput, PURCHASE_AMOUNT_INVALID_FORMAT);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/parser/WinningNumbersParser.java b/src/main/java/lotto/parser/WinningNumbersParser.java
index 259fc0e0b1..143d9f99b7 100644
--- a/src/main/java/lotto/parser/WinningNumbersParser.java
+++ b/src/main/java/lotto/parser/WinningNumbersParser.java
@@ -1,14 +1,13 @@
 package lotto.parser;
 
+import static lotto.common.ErrorMessages.*;
+
 import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
 public class WinningNumbersParser {
 	private static final String SEPARATOR = ",";
-	private static final String ERROR_EMPTY_INPUT = "[ERROR] 당첨 번호를 입력해주세요.";
-	private static final String ERROR_EMPTY_VALUE = "[ERROR] 당첨 번호는 빈 값일 수 없습니다.";
-	private static final String ERROR_INVALID_FORMAT = "[ERROR] 당첨 번호는 숫자여야 합니다.";
 
 	/**
 	 * 사용자 입력 문자열(당첨 번호)을 정수 리스트로 파싱하여 반환합니다.
@@ -19,7 +18,7 @@ public class WinningNumbersParser {
 	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
 	 */
 	public static List<Integer> parse(String input) {
-		ParserUtils.validateNotNullOrEmpty(input, ERROR_EMPTY_INPUT);
+		ParserUtils.validateNotNullOrEmpty(input, WINNING_NUMBERS_EMPTY);
 
 		List<String> numberStrings = splitBySeparator(input);
 		return parseToIntegers(numberStrings);
@@ -36,13 +35,13 @@ private static List<String> splitBySeparator(String input) {
 
 	private static void validateNoEmptyValues(List<String> parts) {
 		if (parts.stream().anyMatch(String::isEmpty)) {
-			throw new IllegalArgumentException(ERROR_EMPTY_VALUE);
+			throw new IllegalArgumentException(WINNING_NUMBERS_EMPTY_VALUE);
 		}
 	}
 
 	private static List<Integer> parseToIntegers(List<String> numberStrings) {
 		return numberStrings.stream()
-			.map(str -> ParserUtils.parseToInteger(str, ERROR_INVALID_FORMAT))
+			.map(str -> ParserUtils.parseToInteger(str, WINNING_NUMBERS_INVALID_FORMAT))
 			.collect(Collectors.toList());
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/lotto/validator/InputValidator.java b/src/main/java/lotto/validator/InputValidator.java
index d9a410a9ff..f359d409b6 100644
--- a/src/main/java/lotto/validator/InputValidator.java
+++ b/src/main/java/lotto/validator/InputValidator.java
@@ -1,12 +1,16 @@
 package lotto.validator;
 
-import static lotto.common.LottoConstants.*;
-
 import java.util.List;
 
 import lotto.domain.Lotto;
 import lotto.domain.WinningLotto;
 
+import static lotto.common.LottoConstants.*;
+import static lotto.common.ErrorMessages.*;
+
+/**
+ * 사용자 입력값을 검증하는 유틸리티 클래스입니다.
+ */
 public class InputValidator {
 
 	/**
@@ -17,13 +21,13 @@ public class InputValidator {
 	 */
 	public static void validatePurchaseAmount(int amount) {
 		if (amount <= 0) {
-			throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");
+			throw new IllegalArgumentException(PURCHASE_AMOUNT_ZERO);
 		}
-		if (amount < MIN_PURCHASE_AMOUNT) {
-			throw new IllegalArgumentException("[ERROR] 구입 금액은 1,000원 이상이어야 합니다.");
+		if (amount < LOTTO_PRICE) {
+			throw new IllegalArgumentException(PURCHASE_AMOUNT_MINIMUM);
 		}
 		if (amount % LOTTO_PRICE != 0) {
-			throw new IllegalArgumentException("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
+			throw new IllegalArgumentException(PURCHASE_AMOUNT_UNIT);
 		}
 	}
 
diff --git a/src/main/java/lotto/view/InputView.java b/src/main/java/lotto/view/InputView.java
index 2fb87cdac3..827592492f 100644
--- a/src/main/java/lotto/view/InputView.java
+++ b/src/main/java/lotto/view/InputView.java
@@ -2,14 +2,17 @@
 
 import camp.nextstep.edu.missionutils.Console;
 
+import static lotto.common.ViewMessages.*;
+
+/**
+ * 사용자 입력을 받는 View 클래스입니다.
+ */
 public class InputView {
-	private static final String INPUT_PURCHASE_AMOUNT = "구입금액을 입력해 주세요.";
-	private static final String INPUT_WINNING_NUMBERS = "당첨 번호를 입력해 주세요.";
-	private static final String INPUT_BONUS_NUMBER = "보너스 번호를 입력해 주세요.";
-	private static final String NEW_LINE = "";
 
 	/**
-	 * 5.1 구매 금액 입력
+	 * 구매 금액을 입력받습니다.
+	 *
+	 * @return 사용자가 입력한 구매 금액 문자열
 	 */
 	public String inputPurchaseAmount() {
 		System.out.println(INPUT_PURCHASE_AMOUNT);
@@ -17,20 +20,24 @@ public String inputPurchaseAmount() {
 	}
 
 	/**
-	 * 5.2 당첨 번호 입력
+	 * 당첨 번호를 입력받습니다.
+	 *
+	 * @return 사용자가 입력한 당첨 번호 문자열 (쉼표로 구분)
 	 */
 	public String inputWinningNumbers() {
-		System.out.println(NEW_LINE);
+		System.out.println();
 		System.out.println(INPUT_WINNING_NUMBERS);
 		return Console.readLine();
 	}
 
 	/**
-	 * 5.3 보너스 번호 입력
+	 * 보너스 번호를 입력받습니다.
+	 *
+	 * @return 사용자가 입력한 보너스 번호 문자열
 	 */
 	public String inputBonusNumber() {
-		System.out.println(NEW_LINE);
+		System.out.println();
 		System.out.println(INPUT_BONUS_NUMBER);
 		return Console.readLine();
 	}
-}
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/view/OutputView.java b/src/main/java/lotto/view/OutputView.java
index d24228d6a1..a5a509fd8b 100644
--- a/src/main/java/lotto/view/OutputView.java
+++ b/src/main/java/lotto/view/OutputView.java
@@ -7,72 +7,70 @@
 import java.text.DecimalFormat;
 import java.util.Comparator;
 import java.util.List;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static lotto.common.ViewMessages.*;
+
+/**
+ * 게임 결과를 출력하는 View 클래스입니다.
+ */
 public class OutputView {
-	private static final String NEW_LINE = "";
-	private static final String PURCHASED_LOTTO_COUNT_FORMAT = "%d개를 구매했습니다.";
-	private static final String WINNING_STATISTICS_HEADER = "당첨 통계";
-	private static final String SEPARATOR = "---";
-	private static final String RANK_FORMAT = "%s (%s원) - %d개";
-	private static final String PROFIT_RATE_FORMAT = "총 수익률은 %.1f%%입니다.";
-	private static final String ERROR_PREFIX = "[ERROR] ";
 	private static final DecimalFormat MONEY_FORMAT = new DecimalFormat("#,###");
 
 	/**
-	 * 5.4 구매한 로또 출력
-	 * 각 로또 번호는 오름차순으로 정렬되어 출력됨 (Lotto 객체에서 정렬 보장)
+	 * 구매한 로또 목록을 출력합니다.
+	 * 각 로또 번호는 오름차순으로 정렬되어 출력됩니다.
+	 *
+	 * @param lottos 구매한 로또 리스트
 	 */
 	public void printLottoTickets(List<Lotto> lottos) {
-		System.out.println(NEW_LINE);
-		System.out.println(String.format(PURCHASED_LOTTO_COUNT_FORMAT, lottos.size()));
-		lottos.stream()
-			.map(Lotto::toString) // Lotto 클래스에 toString()이 구현되어 있다고 가정
-			.forEach(System.out::println);
+		System.out.println();
+		System.out.printf(PURCHASED_LOTTO_COUNT_FORMAT + "%n", lottos.size());
+		lottos.forEach(lotto -> System.out.println(lotto.toString()));
 	}
 
 	/**
-	 * 5.5 당첨 통계 출력
-	 * 5등부터 1등까지 순서대로 출력
+	 * 당첨 통계를 출력합니다.
+	 * 5등부터 1등까지 순서대로 출력합니다.
+	 *
+	 * @param lottoResult 당첨 결과
 	 */
 	public void printWinningStatistics(LottoResult lottoResult) {
-		System.out.println(NEW_LINE);
+		System.out.println();
 		System.out.println(WINNING_STATISTICS_HEADER);
 		System.out.println(SEPARATOR);
 
-		// 5등, 4등, 3등, 2등, 1등 순서로 출력
 		Stream.of(Rank.values())
 			.filter(Rank::isWinning)
-			.sorted(Comparator.comparingInt(Rank::getPrize)) // 상금 기준 오름차순 정렬 (5등 -> 1등)
+			.sorted(Comparator.comparingInt(Rank::getPrize))
 			.forEach(rank -> printRank(rank, lottoResult));
 	}
 
 	private void printRank(Rank rank, LottoResult lottoResult) {
 		String prize = MONEY_FORMAT.format(rank.getPrize());
-		String description = rank.getDescription(); // LottoResultTest.java의 Rank Enum에 getDescription()이 있다고 가정
+		String description = rank.getDescription();
+		int count = lottoResult.getPrizeCount(rank);
 
-		System.out.println(String.format(
-			RANK_FORMAT,
-			description,
-			prize,
-			lottoResult.getPrizeCount(rank)
-		));
+		System.out.printf(RANK_FORMAT + "%n", description, prize, count);
 	}
 
 	/**
-	 * 5.6 수익률 출력
-	 * 소수점 둘째 자리에서 반올림 (%.1f 사용)
+	 * 수익률을 출력합니다.
+	 * 소수점 첫째 자리까지 표시하며 반올림됩니다.
+	 *
+	 * @param lottoResult 당첨 결과
 	 */
 	public void printProfitRate(LottoResult lottoResult) {
-		String profitRate = lottoResult.calculateProfitRate();
-		System.out.println(String.format(PROFIT_RATE_FORMAT, profitRate));
+		double profitRate = lottoResult.calculateProfitRate();
+		System.out.printf(PROFIT_RATE_FORMAT + "%n", profitRate);
 	}
 
 	/**
-	 * 5.7 에러 메시지 출력
+	 * 에러 메시지를 출력합니다.
+	 *
+	 * @param message 에러 메시지 (이미 [ERROR] 접두사 포함)
 	 */
 	public void printErrorMessage(String message) {
-		System.out.println(ERROR_PREFIX + message);
+		System.out.println(message);
 	}
-}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/domain/WinningLottoTest.java b/src/test/java/lotto/domain/WinningLottoTest.java
index b62c32889f..0b26ab4534 100644
--- a/src/test/java/lotto/domain/WinningLottoTest.java
+++ b/src/test/java/lotto/domain/WinningLottoTest.java
@@ -101,7 +101,7 @@ void test6(int matchCount) {
 	void test7() {
 		assertThatThrownBy(() -> new WinningLotto(null, 7))
 			.isInstanceOf(IllegalArgumentException.class)
-			.hasMessageContaining("[ERROR] 당첨 번호를 입력해주세요.");
+			.hasMessageContaining("[ERROR] 로또 번호를 입력해주세요.");
 	}
 
 	@DisplayName("예외2: 보너스 번호가 당첨 번호와 중복되면 IllegalArgumentException 발생")
diff --git a/src/test/java/lotto/view/OutputViewTest.java b/src/test/java/lotto/view/OutputViewTest.java
new file mode 100644
index 0000000000..f069c57f58
--- /dev/null
+++ b/src/test/java/lotto/view/OutputViewTest.java
@@ -0,0 +1,102 @@
+package lotto.view;
+
+import lotto.domain.Lotto;
+import lotto.domain.LottoResult;
+import lotto.domain.Rank;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class OutputViewTest {
+
+	private OutputView outputView;
+	private ByteArrayOutputStream outputStream;
+	private PrintStream originalOut;
+
+	@BeforeEach
+	void setUp() {
+		outputView = new OutputView();
+		outputStream = new ByteArrayOutputStream();
+		originalOut = System.out;
+		System.setOut(new PrintStream(outputStream));
+	}
+
+	@AfterEach
+	void tearDown() {
+		System.setOut(originalOut);
+	}
+
+	@DisplayName("정상1: 구매한 로또 목록을 출력한다")
+	@Test
+	void test1() {
+		// Given
+		List<Lotto> lottos = List.of(
+			new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+			new Lotto(List.of(7, 8, 9, 10, 11, 12))
+		);
+
+		// When
+		outputView.printLottoTickets(lottos);
+
+		// Then
+		String output = outputStream.toString();
+		assertThat(output).contains("2개를 구매했습니다.");
+		assertThat(output).contains("[1, 2, 3, 4, 5, 6]");
+		assertThat(output).contains("[7, 8, 9, 10, 11, 12]");
+	}
+
+	@DisplayName("정상2: 당첨 통계를 출력한다")
+	@Test
+	void test2() {
+		// Given
+		List<Rank> ranks = List.of(Rank.FIFTH, Rank.THIRD);
+		LottoResult lottoResult = new LottoResult(ranks, 8000);
+
+		// When
+		outputView.printWinningStatistics(lottoResult);
+
+		// Then
+		String output = outputStream.toString();
+		assertThat(output).contains("당첨 통계");
+		assertThat(output).contains("---");
+		assertThat(output).contains("3개 일치");
+		assertThat(output).contains("5개 일치");
+	}
+
+	@DisplayName("정상3: 수익률을 출력한다")
+	@Test
+	void test3() {
+		// Given
+		List<Rank> ranks = List.of(Rank.FIFTH);
+		LottoResult lottoResult = new LottoResult(ranks, 8000);
+
+		// When
+		outputView.printProfitRate(lottoResult);
+
+		// Then
+		String output = outputStream.toString();
+		assertThat(output).contains("총 수익률은");
+		assertThat(output).contains("%입니다.");
+	}
+
+	@DisplayName("예외1: 에러 메시지를 출력한다")
+	@Test
+	void test4() {
+		// Given
+		String errorMessage = "[ERROR] 테스트 에러";
+
+		// When
+		outputView.printErrorMessage(errorMessage);
+
+		// Then
+		String output = outputStream.toString();
+		assertThat(output).contains("[ERROR] 테스트 에러");
+	}
+}
\ No newline at end of file

From 685070ae1aa0e7868365e509a22af15530a86c76 Mon Sep 17 00:00:00 2001
From: believeme <cain1227@naver.com>
Date: Thu, 6 Nov 2025 10:22:15 +0900
Subject: [PATCH 21/21] =?UTF-8?q?fix:=20=EA=B8=B0=EB=8A=A5=20=EA=B0=9C?=
 =?UTF-8?q?=EB=B0=9C=20=EC=99=84=EB=A3=8C,=20Service=EB=8A=94=20View?=
 =?UTF-8?q?=EB=A7=8C=20=EC=9E=88=EA=B8=B0=EC=97=90=20=ED=85=8C=EC=8A=A4?=
 =?UTF-8?q?=ED=8A=B8=EB=A5=BC=20=EC=95=88=ED=95=B4=EB=8F=84=20=EC=83=81?=
 =?UTF-8?q?=EA=B4=80=20=EC=97=86=EC=9D=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/java/lotto/Application.java          |  18 +-
 .../java/lotto/service/LottoGameService.java  | 110 ++++++-------
 src/test/java/lotto/ApplicationTest.java      | 155 ++++++++++++------
 .../LottoGameServiceWithMockitoTest.java      | 106 ++++++++++++
 4 files changed, 264 insertions(+), 125 deletions(-)
 create mode 100644 src/test/java/lotto/service/LottoGameServiceWithMockitoTest.java

diff --git a/src/main/java/lotto/Application.java b/src/main/java/lotto/Application.java
index 36d3e30b2a..ff20da09af 100644
--- a/src/main/java/lotto/Application.java
+++ b/src/main/java/lotto/Application.java
@@ -1,20 +1,10 @@
 package lotto;
 
 import lotto.service.LottoGameService;
-import lotto.util.LottoGenerator;
-import lotto.view.InputView;
-import lotto.view.OutputView;
 
 public class Application {
-    public static void main(String[] args) {
-		// 의존성 주입
-		InputView inputView = new InputView();
-		OutputView outputView = new OutputView();
-		LottoGenerator lottoGenerator = new LottoGenerator();
-
-		LottoGameService gameService = new LottoGameService(inputView, outputView, lottoGenerator);
-
-		// 게임 실행
-		gameService.run();
+	public static void main(String[] args) {
+		LottoGameService lottoGameService = new LottoGameService();
+		lottoGameService.run();
 	}
-}
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/service/LottoGameService.java b/src/main/java/lotto/service/LottoGameService.java
index 71227b0a6a..7e92cb350e 100644
--- a/src/main/java/lotto/service/LottoGameService.java
+++ b/src/main/java/lotto/service/LottoGameService.java
@@ -1,60 +1,64 @@
 package lotto.service;
 
-import static lotto.common.LottoConstants.*;
-
-import lotto.domain.*;
+import lotto.domain.Lotto;
+import lotto.domain.LottoResult;
+import lotto.domain.LottoTickets;
+import lotto.domain.WinningLotto;
 import lotto.parser.BonusNumberParser;
 import lotto.parser.PurchaseAmountParser;
 import lotto.parser.WinningNumbersParser;
 import lotto.util.LottoGenerator;
+import lotto.validator.InputValidator;
 import lotto.view.InputView;
 import lotto.view.OutputView;
 
 import java.util.List;
-import java.util.stream.Collectors;
 
+/**
+ * 로또 게임의 전체 흐름을 관리하는 서비스 클래스입니다.
+ */
 public class LottoGameService {
 	private final InputView inputView;
 	private final OutputView outputView;
-	private final LottoGenerator lottoGenerator;
 
-	public LottoGameService(InputView inputView, OutputView outputView, LottoGenerator lottoGenerator) {
+	public LottoGameService() {
+		this.inputView = new InputView();
+		this.outputView = new OutputView();
+	}
+
+	public LottoGameService(InputView inputView, OutputView outputView) {
 		this.inputView = inputView;
 		this.outputView = outputView;
-		this.lottoGenerator = lottoGenerator;
 	}
 
 	/**
-	 * 6.1 LottoGameService 구현
+	 * 로또 게임을 실행합니다.
 	 */
 	public void run() {
-		try {
-			int purchaseAmount = inputPurchaseAmount();
-			LottoTickets lottoTickets = buyLottos(purchaseAmount);
-
-			outputView.printLottoTickets(lottoTickets.getLottos());
+		int purchaseAmount = inputPurchaseAmount();
+		LottoTickets lottoTickets = purchaseLottos(purchaseAmount);
+		outputView.printLottoTickets(lottoTickets.getLottos());
 
-			WinningLotto winningLotto = inputWinningLotto();
+		Lotto winningNumbers = inputWinningNumbers();
+		int bonusNumber = inputBonusNumber(winningNumbers);
 
-			LottoResult lottoResult = calculateResult(lottoTickets, winningLotto, purchaseAmount);
+		WinningLotto winningLotto = new WinningLotto(winningNumbers, bonusNumber);
+		LottoResult result = lottoTickets.compareWithWinningLotto(winningLotto, purchaseAmount);
 
-			outputView.printWinningStatistics(lottoResult);
-			outputView.printProfitRate(lottoResult);
-		} catch (Exception e) {
-			outputView.printErrorMessage(e.getMessage());
-			// 애플리케이션 종료 (여기서 예외를 잡으면 메인에서 추가 처리가 필요 없음)
-		}
+		outputView.printWinningStatistics(result);
+		outputView.printProfitRate(result);
 	}
 
-	// region 1. 구매 금액 입력 및 로또 구매
+	/**
+	 * 구매 금액을 입력받고 검증합니다.
+	 * 예외 발생 시 재입력을 요청합니다.
+	 */
 	private int inputPurchaseAmount() {
 		while (true) {
 			try {
 				String input = inputView.inputPurchaseAmount();
 				int amount = PurchaseAmountParser.parse(input);
-				if (amount % LOTTO_PRICE != 0) {
-					throw new IllegalArgumentException("구입 금액은 " + LOTTO_PRICE + "원 단위여야 합니다.");
-				}
+				InputValidator.validatePurchaseAmount(amount);
 				return amount;
 			} catch (IllegalArgumentException e) {
 				outputView.printErrorMessage(e.getMessage());
@@ -62,31 +66,24 @@ private int inputPurchaseAmount() {
 		}
 	}
 
-	private LottoTickets buyLottos(int purchaseAmount) {
-		int lottoCount = purchaseAmount / LOTTO_PRICE;
-		List<Lotto> lottos = lottoGenerator.generateLottos(lottoCount);
+	/**
+	 * 구매 금액만큼 로또를 자동 생성합니다.
+	 */
+	private LottoTickets purchaseLottos(int purchaseAmount) {
+		List<Lotto> lottos = LottoGenerator.generateLottos(purchaseAmount);
 		return new LottoTickets(lottos);
 	}
-	// endregion
-
-	// region 2. 당첨 번호, 보너스 번호 입력
-	private WinningLotto inputWinningLotto() {
-		Lotto winningNumbers = inputWinningNumbers();
-		while (true) {
-			try {
-				int bonusNumber = inputBonusNumber();
-				return new WinningLotto(winningNumbers, bonusNumber);
-			} catch (IllegalArgumentException e) {
-				outputView.printErrorMessage(e.getMessage());
-			}
-		}
-	}
 
+	/**
+	 * 당첨 번호를 입력받고 검증합니다.
+	 * 예외 발생 시 재입력을 요청합니다.
+	 */
 	private Lotto inputWinningNumbers() {
 		while (true) {
 			try {
 				String input = inputView.inputWinningNumbers();
 				List<Integer> numbers = WinningNumbersParser.parse(input);
+				InputValidator.validateWinningNumbers(numbers);
 				return new Lotto(numbers);
 			} catch (IllegalArgumentException e) {
 				outputView.printErrorMessage(e.getMessage());
@@ -94,31 +91,20 @@ private Lotto inputWinningNumbers() {
 		}
 	}
 
-	private int inputBonusNumber() {
+	/**
+	 * 보너스 번호를 입력받고 검증합니다.
+	 * 예외 발생 시 재입력을 요청합니다.
+	 */
+	private int inputBonusNumber(Lotto winningNumbers) {
 		while (true) {
 			try {
 				String input = inputView.inputBonusNumber();
-				return BonusNumberParser.parse(input);
+				int bonusNumber = BonusNumberParser.parse(input);
+				InputValidator.validateBonusNumber(winningNumbers, bonusNumber);
+				return bonusNumber;
 			} catch (IllegalArgumentException e) {
 				outputView.printErrorMessage(e.getMessage());
-				// 이 내부 while 문은 WinningLotto 생성 중 발생하는 예외 처리용.
-				// WinningLotto의 생성자에서 WinningNumber와의 중복 검증도 수행되므로,
-				// InputView에서 받은 문자열을 숫자로 파싱하는 예외만 여기서 잡고,
-				// WinningLotto 관련 예외는 inputWinningLotto()의 바깥 while문에서 잡음
-				// (요구사항: 보너스 번호 입력 예외 → 보너스 번호 입력부터 재시도)
-				// LottoGameService의 inputWinningLotto() 메서드의 while(true) 루프가
-				// 이 요구사항을 만족시키도록 구현됨.
 			}
 		}
 	}
-	// endregion
-
-	// region 3. 결과 계산 및 출력
-	private LottoResult calculateResult(LottoTickets lottoTickets, WinningLotto winningLotto, int purchaseAmount) {
-		List<Rank> ranks = lottoTickets.getLottos().stream()
-			.map(winningLotto::match)
-			.collect(Collectors.toList());
-		return new LottoResult(ranks, purchaseAmount);
-	}
-	// endregion
-}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/ApplicationTest.java b/src/test/java/lotto/ApplicationTest.java
index a15c7d1f52..a322c2dd20 100644
--- a/src/test/java/lotto/ApplicationTest.java
+++ b/src/test/java/lotto/ApplicationTest.java
@@ -1,6 +1,7 @@
 package lotto;
 
 import camp.nextstep.edu.missionutils.test.NsTest;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
@@ -10,52 +11,108 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 class ApplicationTest extends NsTest {
-    private static final String ERROR_MESSAGE = "[ERROR]";
-
-    @Test
-    void 기능_테스트() {
-        assertRandomUniqueNumbersInRangeTest(
-                () -> {
-                    run("8000", "1,2,3,4,5,6", "7");
-                    assertThat(output()).contains(
-                            "8개를 구매했습니다.",
-                            "[8, 21, 23, 41, 42, 43]",
-                            "[3, 5, 11, 16, 32, 38]",
-                            "[7, 11, 16, 35, 36, 44]",
-                            "[1, 8, 11, 31, 41, 42]",
-                            "[13, 14, 16, 38, 42, 45]",
-                            "[7, 11, 30, 40, 42, 43]",
-                            "[2, 13, 22, 32, 38, 45]",
-                            "[1, 3, 5, 14, 22, 45]",
-                            "3개 일치 (5,000원) - 1개",
-                            "4개 일치 (50,000원) - 0개",
-                            "5개 일치 (1,500,000원) - 0개",
-                            "5개 일치, 보너스 볼 일치 (30,000,000원) - 0개",
-                            "6개 일치 (2,000,000,000원) - 0개",
-                            "총 수익률은 62.5%입니다."
-                    );
-                },
-                List.of(8, 21, 23, 41, 42, 43),
-                List.of(3, 5, 11, 16, 32, 38),
-                List.of(7, 11, 16, 35, 36, 44),
-                List.of(1, 8, 11, 31, 41, 42),
-                List.of(13, 14, 16, 38, 42, 45),
-                List.of(7, 11, 30, 40, 42, 43),
-                List.of(2, 13, 22, 32, 38, 45),
-                List.of(1, 3, 5, 14, 22, 45)
-        );
-    }
-
-    @Test
-    void 예외_테스트() {
-        assertSimpleTest(() -> {
-            runException("1000j");
-            assertThat(output()).contains(ERROR_MESSAGE);
-        });
-    }
-
-    @Override
-    public void runMain() {
-        Application.main(new String[]{});
-    }
-}
+	private static final String ERROR_MESSAGE = "[ERROR]";
+
+	@DisplayName("기능 테스트")
+	@Test
+	void 기능_테스트() {
+		assertRandomUniqueNumbersInRangeTest(
+			() -> {
+				run("8000", "1,2,3,4,5,6", "7");
+				assertThat(output()).contains(
+					"8개를 구매했습니다.",
+					"[8, 21, 23, 41, 42, 43]",
+					"[3, 5, 11, 16, 32, 38]",
+					"[7, 11, 16, 35, 36, 44]",
+					"[1, 8, 11, 31, 41, 42]",
+					"[13, 14, 16, 38, 42, 45]",
+					"[7, 11, 30, 40, 42, 43]",
+					"[2, 13, 22, 32, 38, 45]",
+					"[1, 3, 5, 14, 22, 45]",
+					"3개 일치 (5,000원) - 1개",
+					"4개 일치 (50,000원) - 0개",
+					"5개 일치 (1,500,000원) - 0개",
+					"5개 일치, 보너스 볼 일치 (30,000,000원) - 0개",
+					"6개 일치 (2,000,000,000원) - 0개",
+					"총 수익률은 62.5%입니다."
+				);
+			},
+			List.of(8, 21, 23, 41, 42, 43),
+			List.of(3, 5, 11, 16, 32, 38),
+			List.of(7, 11, 16, 35, 36, 44),
+			List.of(1, 8, 11, 31, 41, 42),
+			List.of(13, 14, 16, 38, 42, 45),
+			List.of(7, 11, 30, 40, 42, 43),
+			List.of(2, 13, 22, 32, 38, 45),
+			List.of(1, 3, 5, 14, 22, 45)
+		);
+	}
+
+	@DisplayName("예외 테스트 - 구매 금액이 숫자가 아닌 경우")
+	@Test
+	void 예외_테스트() {
+		assertSimpleTest(() -> {
+			runException("1000j");
+			assertThat(output()).contains(ERROR_MESSAGE);
+		});
+	}
+
+	@DisplayName("예외 테스트 - 구매 금액이 1000원 단위가 아닌 경우")
+	@Test
+	void 예외_테스트_구매금액_단위() {
+		assertSimpleTest(() -> {
+			runException("1500");
+			assertThat(output()).contains(ERROR_MESSAGE);
+		});
+	}
+
+	@DisplayName("예외 테스트 - 당첨 번호가 6개가 아닌 경우")
+	@Test
+	void 예외_테스트_당첨번호_개수() {
+		assertSimpleTest(() -> {
+			runException("1000", "1,2,3,4,5");
+			assertThat(output()).contains(ERROR_MESSAGE);
+		});
+	}
+
+	@DisplayName("예외 테스트 - 당첨 번호에 중복이 있는 경우")
+	@Test
+	void 예외_테스트_당첨번호_중복() {
+		assertSimpleTest(() -> {
+			runException("1000", "1,2,3,4,5,5");
+			assertThat(output()).contains(ERROR_MESSAGE);
+		});
+	}
+
+	@DisplayName("예외 테스트 - 당첨 번호가 범위를 벗어난 경우")
+	@Test
+	void 예외_테스트_당첨번호_범위() {
+		assertSimpleTest(() -> {
+			runException("1000", "1,2,3,4,5,46");
+			assertThat(output()).contains(ERROR_MESSAGE);
+		});
+	}
+
+	@DisplayName("예외 테스트 - 보너스 번호가 당첨 번호와 중복된 경우")
+	@Test
+	void 예외_테스트_보너스번호_중복() {
+		assertSimpleTest(() -> {
+			runException("1000", "1,2,3,4,5,6", "6");
+			assertThat(output()).contains(ERROR_MESSAGE);
+		});
+	}
+
+	@DisplayName("예외 테스트 - 보너스 번호가 범위를 벗어난 경우")
+	@Test
+	void 예외_테스트_보너스번호_범위() {
+		assertSimpleTest(() -> {
+			runException("1000", "1,2,3,4,5,6", "46");
+			assertThat(output()).contains(ERROR_MESSAGE);
+		});
+	}
+
+	@Override
+	public void runMain() {
+		Application.main(new String[]{});
+	}
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/service/LottoGameServiceWithMockitoTest.java b/src/test/java/lotto/service/LottoGameServiceWithMockitoTest.java
new file mode 100644
index 0000000000..f31393f399
--- /dev/null
+++ b/src/test/java/lotto/service/LottoGameServiceWithMockitoTest.java
@@ -0,0 +1,106 @@
+// package lotto.service;
+//
+// import lotto.view.InputView;
+// import lotto.view.OutputView;
+// import org.junit.jupiter.api.DisplayName;
+// import org.junit.jupiter.api.Test;
+//
+// import static org.assertj.core.api.Assertions.assertThat;
+// import static org.mockito.Mockito.*;
+//
+// class LottoGameServiceWithMockitoTest {
+//
+// 	@DisplayName("정상1: 게임이 정상적으로 실행된다")
+// 	@Test
+// 	void test1() {
+// 		// Given
+// 		InputView inputView = mock(InputView.class);
+// 		OutputView outputView = mock(OutputView.class);
+//
+// 		when(inputView.inputPurchaseAmount()).thenReturn("1000");
+// 		when(inputView.inputWinningNumbers()).thenReturn("1,2,3,4,5,6");
+// 		when(inputView.inputBonusNumber()).thenReturn("7");
+//
+// 		LottoGameService service = new LottoGameService(inputView, outputView);
+//
+// 		// When
+// 		service.run();
+//
+// 		// Then
+// 		verify(inputView, times(1)).inputPurchaseAmount();
+// 		verify(inputView, times(1)).inputWinningNumbers();
+// 		verify(inputView, times(1)).inputBonusNumber();
+// 		verify(outputView, times(1)).printLottoTickets(any());
+// 		verify(outputView, times(1)).printWinningStatistics(any());
+// 		verify(outputView, times(1)).printProfitRate(any());
+// 	}
+//
+// 	@DisplayName("예외1: 잘못된 구매 금액 입력 시 재입력을 요청한다")
+// 	@Test
+// 	void test2() {
+// 		// Given
+// 		InputView inputView = mock(InputView.class);
+// 		OutputView outputView = mock(OutputView.class);
+//
+// 		when(inputView.inputPurchaseAmount())
+// 			.thenReturn("1500")  // 첫 번째: 잘못된 입력
+// 			.thenReturn("1000"); // 두 번째: 올바른 입력
+// 		when(inputView.inputWinningNumbers()).thenReturn("1,2,3,4,5,6");
+// 		when(inputView.inputBonusNumber()).thenReturn("7");
+//
+// 		LottoGameService service = new LottoGameService(inputView, outputView);
+//
+// 		// When
+// 		service.run();
+//
+// 		// Then
+// 		verify(inputView, times(2)).inputPurchaseAmount(); // 2번 호출
+// 		verify(outputView, times(1)).printErrorMessage(any()); // 에러 메시지 1번 출력
+// 	}
+//
+// 	@DisplayName("예외2: 잘못된 당첨 번호 입력 시 재입력을 요청한다")
+// 	@Test
+// 	void test3() {
+// 		// Given
+// 		InputView inputView = mock(InputView.class);
+// 		OutputView outputView = mock(OutputView.class);
+//
+// 		when(inputView.inputPurchaseAmount()).thenReturn("1000");
+// 		when(inputView.inputWinningNumbers())
+// 			.thenReturn("1,2,3,4,5")    // 첫 번째: 5개 입력 (오류)
+// 			.thenReturn("1,2,3,4,5,6"); // 두 번째: 올바른 입력
+// 		when(inputView.inputBonusNumber()).thenReturn("7");
+//
+// 		LottoGameService service = new LottoGameService(inputView, outputView);
+//
+// 		// When
+// 		service.run();
+//
+// 		// Then
+// 		verify(inputView, times(2)).inputWinningNumbers(); // 2번 호출
+// 		verify(outputView, times(1)).printErrorMessage(any()); // 에러 메시지 1번 출력
+// 	}
+//
+// 	@DisplayName("예외3: 잘못된 보너스 번호 입력 시 재입력을 요청한다")
+// 	@Test
+// 	void test4() {
+// 		// Given
+// 		InputView inputView = mock(InputView.class);
+// 		OutputView outputView = mock(OutputView.class);
+//
+// 		when(inputView.inputPurchaseAmount()).thenReturn("1000");
+// 		when(inputView.inputWinningNumbers()).thenReturn("1,2,3,4,5,6");
+// 		when(inputView.inputBonusNumber())
+// 			.thenReturn("6")  // 첫 번째: 중복 (오류)
+// 			.thenReturn("7"); // 두 번째: 올바른 입력
+//
+// 		LottoGameService service = new LottoGameService(inputView, outputView);
+//
+// 		// When
+// 		service.run();
+//
+// 		// Then
+// 		verify(inputView, times(2)).inputBonusNumber(); // 2번 호출
+// 		verify(outputView, times(1)).printErrorMessage(any()); // 에러 메시지 1번 출력
+// 	}
+// }
\ No newline at end of file