diff --git a/README.md b/README.md
index 5fa2560b46..1f4cdf770b 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,640 @@
-# java-lotto-precourse
+# 🎰 로또 게임 (java-lotto-precourse)
+
+## 📖 프로젝트 소개
+
+> 우아한테크코스 프리코스 3주차 미션입니다.
+>
+> 로또 구매부터 당첨 확인까지 전체 프로세스를 구현한 콘솔 기반 로또 게임입니다.
+
+### 주요 기능
+- 💰 구매 금액 입력 및 로또 자동 발행
+- 🎲 1~45 범위의 중복되지 않는 번호 6개 생성
+- 🎯 당첨 번호 및 보너스 번호 입력
+- 🏆 당첨 통계 및 수익률 계산
+- ✅ 입력값 검증 및 예외 처리 (재시도 로직)
+
+---
+
+## 🛠️ 기술 스택
+
+- **Language:** Java 21
+- **Build Tool:** Gradle
+- **Testing:** JUnit 5, AssertJ
+- **Library:** camp.nextstep.edu.missionutils
+
+---
+
+## 🚀  입출력 예시
+
+**입력:**
+```
+구입금액을 입력해 주세요.
+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%입니다.
+```
+
+---
+
+## 📦 패키지 구조
+**레이어별 책임:**
+- **Application**: 프로그램 시작점
+- **Domain**: 핵심 비즈니스 로직
+- **Service**: 전체 게임 흐름 조율 및 예외 재시도 처리
+- **View**: 입출력 담당 (`Console.readLine()`, `System.out.println()`)
+- **Parser**: 문자열 → 객체 변환
+- **Validator**: 비즈니스 규칙 검증
+- **Util**: 로또 번호 생성 등 유틸리티
+
+```
+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           # 사용자 입력 (Console.readLine())
+│   └── OutputView.java          # 결과 출력
+├── parser/                       # 문자열 파싱
+│   ├── PurchaseAmountParser.java
+│   ├── WinningNumbersParser.java
+│   └── BonusNumberParser.java
+├── validator/                    # 입력 검증
+│   └── InputValidator.java
+└── util/                         # 유틸리티
+    └── LottoGenerator.java       # 로또 번호 생성
+```
+
+---
+
+## ⚙️ 기능 구현 목록
+
+### 1. 도메인 객체 구현
+
+#### 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개의 로또 번호를 저장한다
+- [ ] 로또 번호는 1~45 범위의 중복되지 않는 숫자이다
+- [ ] 로또 번호를 오름차순으로 정렬하여 반환한다
+- [ ] 주어진 번호 리스트와 일치하는 개수를 반환한다
+- [ ] 특정 번호 포함 여부를 확인한다
+
+**예외 케이스:**
+- [ ] 로또 번호가 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호를 입력해주세요.`
+- [ ] 로또 번호가 6개가 아니면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호는 6개여야 합니다.`
+- [ ] 중복된 번호가 있으면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호는 중복될 수 없습니다.`
+- [ ] 1~45 범위를 벗어나면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.`
+
+**커밋:** `feat(domain): Lotto 객체 기본 기능 구현`
+
+#### 1.3 WinningLotto 객체 구현
+
+**정상 케이스:**
+- [ ] 당첨 번호 6개와 보너스 번호 1개를 저장한다
+- [ ] 로또와 비교하여 등수를 판별한다
+- [ ] 일치 개수를 계산한다
+- [ ] 보너스 번호 일치 여부를 확인한다
+
+**예외 케이스:**
+- [ ] 당첨 번호가 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호를 입력해주세요.`
+- [ ] 보너스 번호가 당첨 번호와 중복되면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`
+- [ ] 보너스 번호가 1~45 범위를 벗어나면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.`
+
+**커밋:** `feat(domain): WinningLotto 객체 구현`
+
+#### 1.4 LottoTickets 객체 구현
+
+**정상 케이스:**
+- [ ] 여러 개의 로또를 관리한다
+- [ ] 구매한 로또 개수를 반환한다
+- [ ] 모든 로또를 반환한다
+- [ ] 당첨 번호와 비교하여 각 로또의 등수를 판별한다
+
+**예외 케이스:**
+- [ ] 로또 리스트가 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 목록이 없습니다.`
+- [ ] 로또 리스트가 비어있으면 `IllegalArgumentException` 발생
+    - `[ERROR] 최소 1개 이상의 로또를 구매해야 합니다.`
+
+**커밋:** `feat(domain): LottoTickets 객체 구현`
+
+#### 1.5 LottoResult 객체 구현
+
+**정상 케이스:**
+- [ ] 등수별 당첨 개수를 저장한다
+- [ ] 총 수익금을 계산한다
+- [ ] 수익률을 계산한다 (소수점 둘째 자리 반올림)
+- [ ] 등수별 당첨 개수를 반환한다
+
+**예외 케이스:**
+- [ ] 구매 금액이 0 이하면 `IllegalArgumentException` 발생
+    - `[ERROR] 구매 금액은 0보다 커야 합니다.`
+
+**커밋:** `feat(domain): LottoResult 객체 구현`
+
+---
+
+### 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. 입력 검증 구현
+
+#### 3.1 구매 금액 검증
+
+**정상 케이스:**
+- [ ] 1,000원 이상의 금액이면 통과
+- [ ] 1,000원 단위로 나누어떨어지면 통과
+
+**예외 케이스:**
+- [ ] 음수를 입력하면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액은 양수여야 합니다.`
+- [ ] 0을 입력하면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액은 0보다 커야 합니다.`
+- [ ] 1,000원 미만이면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액은 1,000원 이상이어야 합니다.`
+- [ ] 1,000원으로 나누어떨어지지 않으면 `IllegalArgumentException` 발생
+    - `[ERROR] 구입 금액은 1,000원 단위여야 합니다.`
+
+**커밋:** `feat(validator): 구매 금액 검증 구현`
+
+#### 3.2 당첨 번호 검증
+
+**정상 케이스:**
+- [ ] 6개의 번호면 통과
+- [ ] 각 번호가 1~45 범위 내에 있으면 통과
+- [ ] 중복되지 않으면 통과
+
+**예외 케이스:**
+- [ ] 번호 리스트가 null이면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호를 입력해주세요.`
+- [ ] 번호가 6개가 아니면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호는 6개여야 합니다.`
+- [ ] 1~45 범위를 벗어나면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.`
+- [ ] 중복된 번호가 있으면 `IllegalArgumentException` 발생
+    - `[ERROR] 당첨 번호는 중복될 수 없습니다.`
+
+**커밋:** `feat(validator): 당첨 번호 검증 구현`
+
+#### 3.3 보너스 번호 검증
+
+**정상 케이스:**
+- [ ] 1~45 범위의 숫자면 통과
+- [ ] 당첨 번호와 중복되지 않으면 통과
+
+**예외 케이스:**
+- [ ] 1~45 범위를 벗어나면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호는 1부터 45 사이의 숫자여야 합니다.`
+- [ ] 당첨 번호와 중복되면 `IllegalArgumentException` 발생
+    - `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`
+
+**커밋:** `feat(validator): 보너스 번호 검증 구현`
+
+---
+
+### 4. 로또 번호 생성
+
+#### 4.1 자동 로또 번호 생성
+
+**정상 케이스:**
+- [ ] 1~45 범위에서 중복되지 않는 6개의 숫자를 생성한다
+- [ ] `Randoms.pickUniqueNumbersInRange()` 사용
+- [ ] 구매 금액에 맞는 개수만큼 로또를 생성한다
+
+**예외 케이스:**
+- [ ] 생성할 로또 개수가 0 이하면 `IllegalArgumentException` 발생
+    - `[ERROR] 로또 개수는 1개 이상이어야 합니다.`
+
+**커밋:** `feat(util): 로또 번호 자동 생성 구현`
+
+---
+
+### 5. 입출력 기능
+
+#### 5.1 구매 금액 입력
+- [ ] 입력 안내 메시지 출력: "구입금액을 입력해 주세요."
+- [ ] `Console.readLine()`으로 입력 받기
+- [ ] 입력받은 문자열을 그대로 반환
+
+**커밋:** `feat(view): 구매 금액 입력 기능 구현`
+
+#### 5.2 당첨 번호 입력
+- [ ] 빈 줄 출력
+- [ ] 입력 안내 메시지 출력: "당첨 번호를 입력해 주세요."
+- [ ] `Console.readLine()`으로 입력 받기
+- [ ] 입력받은 문자열을 그대로 반환
+
+**커밋:** `feat(view): 당첨 번호 입력 기능 구현`
+
+#### 5.3 보너스 번호 입력
+- [ ] 빈 줄 출력
+- [ ] 입력 안내 메시지 출력: "보너스 번호를 입력해 주세요."
+- [ ] `Console.readLine()`으로 입력 받기
+- [ ] 입력받은 문자열을 그대로 반환
+
+**커밋:** `feat(view): 보너스 번호 입력 기능 구현`
+
+#### 5.4 구매한 로또 출력
+- [ ] 빈 줄 출력
+- [ ] "n개를 구매했습니다." 출력
+- [ ] 각 로또를 오름차순 정렬하여 출력
+- [ ] 형식: `[번호1, 번호2, 번호3, 번호4, 번호5, 번호6]`
+- [ ] 각 로또마다 줄바꿈
+
+**커밋:** `feat(view): 구매 로또 출력 기능 구현`
+
+#### 5.5 당첨 통계 출력
+- [ ] 빈 줄 출력
+- [ ] "당첨 통계" 헤더 출력
+- [ ] 구분선 "---" 출력
+- [ ] 5등부터 1등까지 순서대로 출력
+- [ ] 형식: "n개 일치 (금액원) - m개"
+- [ ] 2등: "5개 일치, 보너스 볼 일치 (금액원) - m개"
+- [ ] 금액은 천 단위 쉼표 포함
+
+**커밋:** `feat(view): 당첨 통계 출력 기능 구현`
+
+#### 5.6 수익률 출력
+- [ ] "총 수익률은 n%입니다." 형식으로 출력
+- [ ] 소수점 둘째 자리에서 반올림
+- [ ] 천 단위 쉼표 포함
+
+**커밋:** `feat(view): 수익률 출력 기능 구현`
+
+#### 5.7 에러 메시지 출력
+- [ ] "[ERROR]"로 시작하는 에러 메시지 출력
+- [ ] `System.out.println()` 사용
+
+**커밋:** `feat(view): 에러 메시지 출력 기능 구현`
+
+---
+
+### 6. 게임 진행 서비스
+
+#### 6.1 LottoGameService 구현
+- [ ] 구매 금액 입력 및 검증 (재시도 로직)
+- [ ] 로또 자동 발행
+- [ ] 구매한 로또 출력
+- [ ] 당첨 번호 입력 및 검증 (재시도 로직)
+- [ ] 보너스 번호 입력 및 검증 (재시도 로직)
+- [ ] 당첨 결과 계산
+- [ ] 당첨 통계 및 수익률 출력
+- [ ] 각 입력 단계에서 예외 발생 시 해당 단계부터 재시도
+
+**재시도 흐름:**
+- [ ] 구매 금액 예외 → 구매 금액 입력부터 재시도
+- [ ] 당첨 번호 예외 → 당첨 번호 입력부터 재시도
+- [ ] 보너스 번호 예외 → 보너스 번호 입력부터 재시도
+
+**커밋:** `feat(service): LottoGameService 게임 진행 로직 구현`
+
+---
+
+### 7. 메인 실행
+
+#### 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 → Parser → Validator → Util → View → Service → Application)
+
+```
+┌─────────────────┐
+│  Application    │ (진입점)
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│    Service      │ (조율 + 재시도 로직)
+└────┬────────────┘
+     │
+     ├──────────┬──────────┬──────────┐
+     ▼          ▼          ▼          ▼
+┌─────────┐  ┌──────────┐ ┌──────────┐ ┌──────────┐
+│ Domain  │  │  Parser  │ │   View   │ │   Util   │
+└─────────┘  └──────────┘ └──────────┘ └──────────┘
+     ▲          ▲
+     │          │
+┌────┴──────────┴────┐
+│    Validator       │
+└────────────────────┘
+```
+
+---
+
+## ✅ 프로그래밍 요구사항 준수
+
+- [ ] JDK 21에서 실행 가능
+- [ ] indent depth 2 이하
+- [ ] 3항 연산자 미사용
+- [ ] else 예약어 미사용
+- [ ] 함수 길이 15라인 이하
+- [ ] 함수가 한 가지 일만 수행
+- [ ] Java Enum 활용 (Rank)
+- [ ] JUnit 5, AssertJ 테스트 작성
+- [ ] `Randoms.pickUniqueNumbersInRange()` 사용
+- [ ] `Console.readLine()` 사용
+- [ ] 제공된 Lotto 클래스 활용 (필드 추가 불가)
+- [ ] UI 로직 제외 단위 테스트 작성
+- [ ] `IllegalArgumentException`, `IllegalStateException` 등 명확한 예외 타입 사용
+
+---
+
+## 📊 상수 관리 현황
+
+### 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     # 비즈니스 상수
+```
+---
+
+## 🧪 테스트
+
+### 테스트 구조
+```
+src/test/java/lotto/
+├── domain/
+│   ├── LottoTest.java
+│   ├── RankTest.java
+│   ├── WinningLottoTest.java
+│   ├── LottoTicketsTest.java
+│   └── LottoResultTest.java
+├── parser/
+│   ├── PurchaseAmountParserTest.java
+│   ├── WinningNumbersParserTest.java
+│   └── BonusNumberParserTest.java
+├── validator/
+│   └── InputValidatorTest.java
+├── util/
+│   └── LottoGeneratorTest.java
+└── service/
+    └── LottoGameServiceTest.java
+```
+
+### 테스트 작성 원칙
+- [ ] 정상 케이스와 예외 케이스 모두 테스트
+- [ ] 경계값 테스트 (0, 1, 45, 46 등)
+- [ ] `@ParameterizedTest` 활용하여 여러 케이스 검증
+- [ ] `assertThatThrownBy()` 로 예외 메시지까지 검증
+- [ ] UI 로직(InputView, OutputView)은 테스트 제외
+
+---
+
+## 💭 회고
+
+### 이번 주차 학습 목표
+- [ ] Java Enum을 활용한 등수 관리
+- [ ] 일급 컬렉션 패턴 적용 (LottoTickets, LottoResult)
+- [ ] 예외 발생 시 재입력 로직 구현
+- [ ] Parser 레이어 분리로 책임 명확화
+- [ ] 다양한 예외 타입 활용 (IllegalArgumentException, NumberFormatException)
+- [ ] 2주차 공통 피드백 반영
+
+### 2주차 피드백 반영 사항
+- [ ] 함수 분리를 통한 indent depth 관리
+- [ ] Early return 패턴으로 else 제거
+- [ ] 매직 넘버 상수화
+- [ ] 도메인 로직과 UI 로직 분리
+- [ ] 함수 길이 15라인 이하 유지
+
+### 예상 고민 포인트
+- Parser와 Validator의 경계 설정
+- 재시도 로직의 중복 제거
+- Enum을 활용한 등수 및 상금 관리
+- 일급 컬렉션 적용 범위
+
+---
+
+## 📚 학습 내용
+
+- Java Enum 활용 (상태와 행위를 함께 관리)
+- 일급 컬렉션 (First-Class Collection)
+- 예외 처리
\ No newline at end of file
diff --git a/src/main/java/lotto/Application.java b/src/main/java/lotto/Application.java
index d190922ba4..ff20da09af 100644
--- a/src/main/java/lotto/Application.java
+++ b/src/main/java/lotto/Application.java
@@ -1,7 +1,10 @@
 package lotto;
 
+import lotto.service.LottoGameService;
+
 public class Application {
-    public static void main(String[] args) {
-        // TODO: 프로그램 구현
-    }
-}
+	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/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/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/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/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
new file mode 100644
index 0000000000..011cb381a9
--- /dev/null
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -0,0 +1,71 @@
+package lotto.domain;
+
+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 {
+
+	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(LOTTO_NUMBERS_NULL);
+		}
+	}
+
+	private void validateSize(List<Integer> numbers) {
+		if (numbers.size() != LOTTO_NUMBER_COUNT) {
+			throw new IllegalArgumentException(LOTTO_NUMBERS_SIZE);
+		}
+	}
+	private void validateDuplicate(List<Integer> numbers) {
+		if (numbers.size() != new HashSet<>(numbers).size()) {
+			throw new IllegalArgumentException(LOTTO_NUMBERS_DUPLICATE);
+		}
+	}
+
+	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(LOTTO_NUMBERS_RANGE);
+		}
+	}
+
+	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);
+	}
+
+	@Override
+	public String toString() {
+		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
new file mode 100644
index 0000000000..ae1a748cb4
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoResult.java
@@ -0,0 +1,69 @@
+package lotto.domain;
+
+import static lotto.common.ErrorMessages.*;
+
+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(LOTTO_RESULT_PURCHASE_AMOUNT);
+		}
+		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();
+	}
+
+	/**
+	 * 총 수익률을 계산합니다.
+	 *
+	 * @return 수익률 (퍼센트, 소수점 포함)
+	 */
+	public double calculateProfitRate() {
+		long totalProfit = calculateTotalProfit();
+		return (double) totalProfit * 100 / purchaseAmount;
+	}
+
+	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/domain/LottoTickets.java b/src/main/java/lotto/domain/LottoTickets.java
new file mode 100644
index 0000000000..2108a8fc94
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoTickets.java
@@ -0,0 +1,44 @@
+package lotto.domain;
+
+import static lotto.common.ErrorMessages.*;
+
+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(LOTTO_TICKETS_NULL);
+		}
+
+		if (lottos.size() < MIN_LOTTO_COUNT) {
+			throw new IllegalArgumentException(LOTTO_TICKETS_EMPTY);
+		}
+
+		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/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/main/java/lotto/domain/WinningLotto.java b/src/main/java/lotto/domain/WinningLotto.java
new file mode 100644
index 0000000000..ddc15483d8
--- /dev/null
+++ b/src/main/java/lotto/domain/WinningLotto.java
@@ -0,0 +1,57 @@
+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 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(LOTTO_NUMBERS_NULL);
+		}
+	}
+
+	private void validateBonusNumberRange(int bonusNumber) {
+		if (bonusNumber < MIN_LOTTO_NUMBER || bonusNumber > MAX_LOTTO_NUMBER) {
+			throw new IllegalArgumentException(BONUS_NUMBER_RANGE);
+		}
+	}
+
+	private void validateDuplicateWithWinningNumbers(Lotto winningNumbers, int bonusNumber) {
+		if (winningNumbers.contains(bonusNumber)) {
+			throw new IllegalArgumentException(BONUS_NUMBER_DUPLICATE);
+		}
+	}
+
+	/**
+	 * 구매한 로또와 당첨 번호를 비교하여 등수를 반환합니다.
+	 */
+	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/main/java/lotto/parser/BonusNumberParser.java b/src/main/java/lotto/parser/BonusNumberParser.java
new file mode 100644
index 0000000000..6bb392d378
--- /dev/null
+++ b/src/main/java/lotto/parser/BonusNumberParser.java
@@ -0,0 +1,20 @@
+package lotto.parser;
+
+import static lotto.common.ErrorMessages.*;
+
+public class BonusNumberParser {
+
+	/**
+	 * 사용자 입력 문자열(보너스 번호)을 정수로 파싱하여 반환합니다.
+	 *
+	 * @param input 사용자가 입력한 보너스 번호 문자열
+	 * @return 파싱된 보너스 번호 (정수)
+	 * @throws IllegalArgumentException 입력이 null 또는 빈 문자열인 경우
+	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
+	 */
+	public static int parse(String input) {
+		ParserUtils.validateNotNullOrEmpty(input, BONUS_NUMBER_EMPTY);
+		String trimmedInput = input.trim();
+		return ParserUtils.parseToInteger(trimmedInput, BONUS_NUMBER_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
new file mode 100644
index 0000000000..9d62cc9c69
--- /dev/null
+++ b/src/main/java/lotto/parser/PurchaseAmountParser.java
@@ -0,0 +1,20 @@
+package lotto.parser;
+
+import static lotto.common.ErrorMessages.*;
+
+public class PurchaseAmountParser {
+
+	/**
+	 * 사용자 입력 문자열(구입 금액)을 정수로 파싱하여 반환합니다.
+	 *
+	 * @param input 사용자가 입력한 구입 금액 문자열
+	 * @return 파싱된 구입 금액 (정수)
+	 * @throws IllegalArgumentException 입력이 null 또는 빈 문자열인 경우
+	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
+	 */
+	public static int parse(String input) {
+		ParserUtils.validateNotNullOrEmpty(input, PURCHASE_AMOUNT_EMPTY);
+		String trimmedInput = input.trim();
+		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
new file mode 100644
index 0000000000..143d9f99b7
--- /dev/null
+++ b/src/main/java/lotto/parser/WinningNumbersParser.java
@@ -0,0 +1,47 @@
+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 = ",";
+
+	/**
+	 * 사용자 입력 문자열(당첨 번호)을 정수 리스트로 파싱하여 반환합니다.
+	 *
+	 * @param input 사용자가 입력한 당첨 번호 문자열 (쉼표로 구분됨)
+	 * @return 파싱된 당첨 번호 리스트 (정수)
+	 * @throws IllegalArgumentException 입력이 null, 빈 문자열, 또는 빈 값이 포함된 경우
+	 * @throws NumberFormatException 숫자가 아닌 값이 포함된 경우
+	 */
+	public static List<Integer> parse(String input) {
+		ParserUtils.validateNotNullOrEmpty(input, WINNING_NUMBERS_EMPTY);
+
+		List<String> numberStrings = splitBySeparator(input);
+		return parseToIntegers(numberStrings);
+	}
+
+	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(WINNING_NUMBERS_EMPTY_VALUE);
+		}
+	}
+
+	private static List<Integer> parseToIntegers(List<String> numberStrings) {
+		return numberStrings.stream()
+			.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/service/LottoGameService.java b/src/main/java/lotto/service/LottoGameService.java
new file mode 100644
index 0000000000..7e92cb350e
--- /dev/null
+++ b/src/main/java/lotto/service/LottoGameService.java
@@ -0,0 +1,110 @@
+package lotto.service;
+
+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;
+
+/**
+ * 로또 게임의 전체 흐름을 관리하는 서비스 클래스입니다.
+ */
+public class LottoGameService {
+	private final InputView inputView;
+	private final OutputView outputView;
+
+	public LottoGameService() {
+		this.inputView = new InputView();
+		this.outputView = new OutputView();
+	}
+
+	public LottoGameService(InputView inputView, OutputView outputView) {
+		this.inputView = inputView;
+		this.outputView = outputView;
+	}
+
+	/**
+	 * 로또 게임을 실행합니다.
+	 */
+	public void run() {
+		int purchaseAmount = inputPurchaseAmount();
+		LottoTickets lottoTickets = purchaseLottos(purchaseAmount);
+		outputView.printLottoTickets(lottoTickets.getLottos());
+
+		Lotto winningNumbers = inputWinningNumbers();
+		int bonusNumber = inputBonusNumber(winningNumbers);
+
+		WinningLotto winningLotto = new WinningLotto(winningNumbers, bonusNumber);
+		LottoResult result = lottoTickets.compareWithWinningLotto(winningLotto, purchaseAmount);
+
+		outputView.printWinningStatistics(result);
+		outputView.printProfitRate(result);
+	}
+
+	/**
+	 * 구매 금액을 입력받고 검증합니다.
+	 * 예외 발생 시 재입력을 요청합니다.
+	 */
+	private int inputPurchaseAmount() {
+		while (true) {
+			try {
+				String input = inputView.inputPurchaseAmount();
+				int amount = PurchaseAmountParser.parse(input);
+				InputValidator.validatePurchaseAmount(amount);
+				return amount;
+			} catch (IllegalArgumentException e) {
+				outputView.printErrorMessage(e.getMessage());
+			}
+		}
+	}
+
+	/**
+	 * 구매 금액만큼 로또를 자동 생성합니다.
+	 */
+	private LottoTickets purchaseLottos(int purchaseAmount) {
+		List<Lotto> lottos = LottoGenerator.generateLottos(purchaseAmount);
+		return new LottoTickets(lottos);
+	}
+
+	/**
+	 * 당첨 번호를 입력받고 검증합니다.
+	 * 예외 발생 시 재입력을 요청합니다.
+	 */
+	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());
+			}
+		}
+	}
+
+	/**
+	 * 보너스 번호를 입력받고 검증합니다.
+	 * 예외 발생 시 재입력을 요청합니다.
+	 */
+	private int inputBonusNumber(Lotto winningNumbers) {
+		while (true) {
+			try {
+				String input = inputView.inputBonusNumber();
+				int bonusNumber = BonusNumberParser.parse(input);
+				InputValidator.validateBonusNumber(winningNumbers, bonusNumber);
+				return bonusNumber;
+			} catch (IllegalArgumentException e) {
+				outputView.printErrorMessage(e.getMessage());
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/util/LottoGenerator.java b/src/main/java/lotto/util/LottoGenerator.java
new file mode 100644
index 0000000000..4b1aa77bbf
--- /dev/null
+++ b/src/main/java/lotto/util/LottoGenerator.java
@@ -0,0 +1,29 @@
+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.common.LottoConstants.*;
+
+public class LottoGenerator {
+
+	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/main/java/lotto/validator/InputValidator.java b/src/main/java/lotto/validator/InputValidator.java
new file mode 100644
index 0000000000..f359d409b6
--- /dev/null
+++ b/src/main/java/lotto/validator/InputValidator.java
@@ -0,0 +1,56 @@
+package lotto.validator;
+
+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 {
+
+	/**
+	 * 구매 금액이 유효한지 검증합니다.
+	 *
+	 * @param amount 구매 금액
+	 * @throws IllegalArgumentException 금액이 0 이하, 1000원 미만, 1000원 단위가 아닌 경우
+	 */
+	public static void validatePurchaseAmount(int amount) {
+		if (amount <= 0) {
+			throw new IllegalArgumentException(PURCHASE_AMOUNT_ZERO);
+		}
+		if (amount < LOTTO_PRICE) {
+			throw new IllegalArgumentException(PURCHASE_AMOUNT_MINIMUM);
+		}
+		if (amount % LOTTO_PRICE != 0) {
+			throw new IllegalArgumentException(PURCHASE_AMOUNT_UNIT);
+		}
+	}
+
+	/**
+	 * 당첨 번호가 유효한지 검증합니다.
+	 * Lotto 객체 생성을 통해 null, 개수, 범위, 중복 검증을 수행합니다.
+	 *
+	 * @param numbers 당첨 번호 리스트
+	 * @throws IllegalArgumentException Lotto 생성 조건을 만족하지 않는 경우
+	 */
+	public static void validateWinningNumbers(List<Integer> numbers) {
+		new Lotto(numbers);
+	}
+
+	/**
+	 * 보너스 번호가 유효한지 검증합니다.
+	 * WinningLotto 객체 생성을 통해 범위 및 중복 검증을 수행합니다.
+	 *
+	 * @param winningNumbers 당첨 번호 Lotto 객체
+	 * @param bonusNumber 보너스 번호
+	 * @throws IllegalArgumentException WinningLotto 생성 조건을 만족하지 않는 경우
+	 */
+	public static void validateBonusNumber(Lotto winningNumbers, int bonusNumber) {
+		new WinningLotto(winningNumbers, bonusNumber);
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/lotto/view/InputView.java b/src/main/java/lotto/view/InputView.java
new file mode 100644
index 0000000000..827592492f
--- /dev/null
+++ b/src/main/java/lotto/view/InputView.java
@@ -0,0 +1,43 @@
+package lotto.view;
+
+import camp.nextstep.edu.missionutils.Console;
+
+import static lotto.common.ViewMessages.*;
+
+/**
+ * 사용자 입력을 받는 View 클래스입니다.
+ */
+public class InputView {
+
+	/**
+	 * 구매 금액을 입력받습니다.
+	 *
+	 * @return 사용자가 입력한 구매 금액 문자열
+	 */
+	public String inputPurchaseAmount() {
+		System.out.println(INPUT_PURCHASE_AMOUNT);
+		return Console.readLine();
+	}
+
+	/**
+	 * 당첨 번호를 입력받습니다.
+	 *
+	 * @return 사용자가 입력한 당첨 번호 문자열 (쉼표로 구분)
+	 */
+	public String inputWinningNumbers() {
+		System.out.println();
+		System.out.println(INPUT_WINNING_NUMBERS);
+		return Console.readLine();
+	}
+
+	/**
+	 * 보너스 번호를 입력받습니다.
+	 *
+	 * @return 사용자가 입력한 보너스 번호 문자열
+	 */
+	public String inputBonusNumber() {
+		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
new file mode 100644
index 0000000000..a5a509fd8b
--- /dev/null
+++ b/src/main/java/lotto/view/OutputView.java
@@ -0,0 +1,76 @@
+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.Stream;
+
+import static lotto.common.ViewMessages.*;
+
+/**
+ * 게임 결과를 출력하는 View 클래스입니다.
+ */
+public class OutputView {
+	private static final DecimalFormat MONEY_FORMAT = new DecimalFormat("#,###");
+
+	/**
+	 * 구매한 로또 목록을 출력합니다.
+	 * 각 로또 번호는 오름차순으로 정렬되어 출력됩니다.
+	 *
+	 * @param lottos 구매한 로또 리스트
+	 */
+	public void printLottoTickets(List<Lotto> lottos) {
+		System.out.println();
+		System.out.printf(PURCHASED_LOTTO_COUNT_FORMAT + "%n", lottos.size());
+		lottos.forEach(lotto -> System.out.println(lotto.toString()));
+	}
+
+	/**
+	 * 당첨 통계를 출력합니다.
+	 * 5등부터 1등까지 순서대로 출력합니다.
+	 *
+	 * @param lottoResult 당첨 결과
+	 */
+	public void printWinningStatistics(LottoResult lottoResult) {
+		System.out.println();
+		System.out.println(WINNING_STATISTICS_HEADER);
+		System.out.println(SEPARATOR);
+
+		Stream.of(Rank.values())
+			.filter(Rank::isWinning)
+			.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();
+		int count = lottoResult.getPrizeCount(rank);
+
+		System.out.printf(RANK_FORMAT + "%n", description, prize, count);
+	}
+
+	/**
+	 * 수익률을 출력합니다.
+	 * 소수점 첫째 자리까지 표시하며 반올림됩니다.
+	 *
+	 * @param lottoResult 당첨 결과
+	 */
+	public void printProfitRate(LottoResult lottoResult) {
+		double profitRate = lottoResult.calculateProfitRate();
+		System.out.printf(PROFIT_RATE_FORMAT + "%n", profitRate);
+	}
+
+	/**
+	 * 에러 메시지를 출력합니다.
+	 *
+	 * @param message 에러 메시지 (이미 [ERROR] 접두사 포함)
+	 */
+	public void printErrorMessage(String message) {
+		System.out.println(message);
+	}
+}
\ 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/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/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
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/LottoTicketsTest.java b/src/test/java/lotto/domain/LottoTicketsTest.java
new file mode 100644
index 0000000000..aeb4edd750
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoTicketsTest.java
@@ -0,0 +1,72 @@
+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);
+
+		assertThat(result.getPrizeCount(Rank.FIRST)).isEqualTo(1);
+		assertThat(result.getPrizeCount(Rank.NONE)).isEqualTo(0);
+	}
+
+	@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/RankTest.java b/src/test/java/lotto/domain/RankTest.java
new file mode 100644
index 0000000000..3979fb8e3f
--- /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 test1() {
+		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 test2() {
+		Rank rank = Rank.valueOf(5, true);
+
+		assertThat(rank).isEqualTo(Rank.SECOND);
+		assertThat(rank.getPrize()).isEqualTo(30_000_000);
+	}
+
+	@DisplayName("3: 5개 일치하고 보너스볼 불일치하면 3등")
+	@Test
+	void test3() {
+		Rank rank = Rank.valueOf(5, false);
+
+		assertThat(rank).isEqualTo(Rank.THIRD);
+		assertThat(rank.getPrize()).isEqualTo(1_500_000);
+	}
+
+	@DisplayName("4: 4개 일치하면 4등")
+	@Test
+	void test4() {
+		Rank rank = Rank.valueOf(4, false);
+
+		assertThat(rank).isEqualTo(Rank.FOURTH);
+		assertThat(rank.getPrize()).isEqualTo(50_000);
+	}
+
+	@DisplayName("5: 3개 일치하면 5등")
+	@Test
+	void test5() {
+		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 test6(int matchCount, boolean matchBonus) {
+		Rank rank = Rank.valueOf(matchCount, matchBonus);
+
+		assertThat(rank).isEqualTo(Rank.NONE);
+		assertThat(rank.getPrize()).isEqualTo(0);
+	}
+
+	@DisplayName("7: 당첨 여부 확인")
+	@Test
+	void test7() {
+		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
diff --git a/src/test/java/lotto/domain/WinningLottoTest.java b/src/test/java/lotto/domain/WinningLottoTest.java
new file mode 100644
index 0000000000..0b26ab4534
--- /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
+		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
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
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
new file mode 100644
index 0000000000..0400779ec1
--- /dev/null
+++ b/src/test/java/lotto/parser/PurchaseAmountParserTest.java
@@ -0,0 +1,66 @@
+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 PurchaseAmountParserTest {
+
+	@DisplayName("정상1: 유효한 문자열 금액을 정수로 파싱한다")
+	@Test
+	void test1() {
+		// Given
+		String input = "8000";
+
+		// When
+		int result = PurchaseAmountParser.parse(input);
+
+		// Then
+		assertThat(result).isEqualTo(8000);
+	}
+
+	@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))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액을 입력해주세요.");
+	}
+
+	@DisplayName("예외2: 입력이 빈 문자열 또는 공백이면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"", " "})
+	void test4(String input) {
+		assertThatThrownBy(() -> PurchaseAmountParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액을 입력해주세요.");
+	}
+
+	@DisplayName("예외3: 숫자가 아닌 문자가 포함되면 NumberFormatException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"1000원", "a1000", "1,000"})
+	void test5(String input) {
+		assertThatThrownBy(() -> PurchaseAmountParser.parse(input))
+			.isInstanceOf(NumberFormatException.class)
+			.hasMessage("[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..aee508835b
--- /dev/null
+++ b/src/test/java/lotto/parser/WinningNumbersParserTest.java
@@ -0,0 +1,88 @@
+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("정상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))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 당첨 번호를 입력해주세요.");
+	}
+
+	@DisplayName("예외2: 입력이 빈 문자열 또는 공백이면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: \"{0}\"")
+	@ValueSource(strings = {"", " ", "  "})
+	void test4(String input) {
+		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 당첨 번호를 입력해주세요.");
+	}
+
+	@DisplayName("예외3: 숫자가 아닌 값이 포함되면 NumberFormatException 발생")
+	@Test
+	void test5() {
+		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"})
+	void test6(String input) {
+		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 당첨 번호는 빈 값일 수 없습니다.");
+	}
+
+	@DisplayName("예외5: 문자열이 쉼표로 끝나는 경우 IllegalArgumentException 발생")
+	@Test
+	void test7() {
+		String input = "1,2,3,4,5,6,";
+
+		assertThatThrownBy(() -> WinningNumbersParser.parse(input))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 당첨 번호는 빈 값일 수 없습니다.");
+	}
+}
\ 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
diff --git a/src/test/java/lotto/util/LottoGeneratorTest.java b/src/test/java/lotto/util/LottoGeneratorTest.java
new file mode 100644
index 0000000000..b7ce1dc7fc
--- /dev/null
+++ b/src/test/java/lotto/util/LottoGeneratorTest.java
@@ -0,0 +1,74 @@
+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.common.LottoConstants.*;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LottoGeneratorTest {
+
+	@DisplayName("정상1: 구입 금액에 따라 정확한 개수의 로또를 생성한다")
+	@ParameterizedTest(name = "구입 금액: {0}원")
+	@ValueSource(ints = {1000, 5000, 10000})
+	void test1(int purchaseAmount) {
+		// Given & When
+		List<Lotto> lottos = LottoGenerator.generateLottos(purchaseAmount);
+		int expectedCount = purchaseAmount / LOTTO_PRICE;
+
+		// Then
+		assertThat(lottos).hasSize(expectedCount);
+	}
+
+	@DisplayName("정상2: 생성된 각 로또가 유효한 번호 6개를 포함하고 있는지 검증한다")
+	@Test
+	void test2() {
+		// Given
+		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. 오름차순으로 정렬되어 있어야 한다.
+			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
diff --git a/src/test/java/lotto/validator/InputValidatorTest.java b/src/test/java/lotto/validator/InputValidatorTest.java
new file mode 100644
index 0000000000..c95ee4cfa2
--- /dev/null
+++ b/src/test/java/lotto/validator/InputValidatorTest.java
@@ -0,0 +1,137 @@
+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 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원 단위의 금액은 검증을 통과한다")
+	@ParameterizedTest(name = "입력: {0}")
+	@ValueSource(ints = {1000, 8000, 10000})
+	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("정상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, 0})
+	void test5(int amount) {
+		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 test6(int amount) {
+		assertThatThrownBy(() -> validatePurchaseAmount(amount))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액은 1,000원 이상이어야 합니다.");
+	}
+
+	@DisplayName("예외4: 1,000원으로 나누어떨어지지 않으면 IllegalArgumentException 발생")
+	@ParameterizedTest(name = "입력: {0}")
+	@ValueSource(ints = {1001, 1500, 8999})
+	void test7(int amount) {
+		assertThatThrownBy(() -> validatePurchaseAmount(amount))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 구입 금액은 1,000원 단위여야 합니다.");
+	}
+
+
+	@DisplayName("예외5: 번호 리스트가 null이면 IllegalArgumentException 발생")
+	@Test
+	void test8() {
+		assertThatThrownBy(() -> validateWinningNumbers(null))
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessage("[ERROR] 로또 번호를 입력해주세요.");
+	}
+
+	@DisplayName("예외6: 번호가 6개가 아니면 IllegalArgumentException 발생")
+	@Test
+	void test9() {
+		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 test10(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 test11() {
+		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 test12(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 test13() {
+		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
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 {
+}
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