diff --git a/README.md b/README.md
index 5fa2560b46..b90b672af2 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,244 @@
-# java-lotto-precourse
+# 🎰 로또 게임 (Lotto Game)
+
+사용자가 입력한 금액만큼 로또를 자동으로 발행하고, 당첨 번호와 보너스 번호를 기준으로 결과 통계와 수익률을 출력하는 콘솔 기반 프로그램입니다.
+
+Java 21 환경에서 동작하며, 기능별 책임을 분리해 구현하는 데 중점을 두었습니다.
+
+<br>
+<br>
+
+## 🍭 **🎯 프로젝트의 지향점 및** 방향
+
+관련된 데이터와 동작을 함께 묶어 **각 클래스가 분명한 책임을 갖도록 구성**하고, **여러 객체들이 역할에 따라 협력**하며 하나의 기능을 완성할 수 있도록 설계합니다.
+
+TDD 사이클 중 **Inside-Out 방식을 기반으로**, **입출력보다는 먼저 도메인 로직을 중심으로 개발을 시작**하고, 테스트 가능한 작은 단위부터 점차 확장해 나갑니다.
+
+<br>
+<br>
+
+## 🔁 시퀀스 다이어그램
+
+애플리케이션의 전체 동작 과정과 객체 간의 상호작용을 시각화하기 위해 시퀀스 다이어그램을 사용했습니다.
+
+```mermaid
+sequenceDiagram
+    participant U as 사용자
+    participant I as InputView
+    participant O as OutputView
+    participant C as LottoController
+    participant M as Money
+    participant F as LottoFactory
+    participant G as LottoGenerator
+    participant L as Lotto
+    participant W as WinningNumbers
+    participant R as LottoResults
+
+Note over U,C: 🎫 1단계: 로또 구매
+    loop 유효한 금액이 입력될 때까지
+        U->>I: 구입 금액 입력
+        I->>C: 금액 전달
+        C->>M: Money 생성 및 검증
+        alt 검증 성공
+            M-->>C: 유효한 Money 객체
+        else 검증 실패
+            M-->>C: IllegalArgumentException
+            C->>O: 에러 메시지 출력
+            O->>U: 에러 표시
+        end
+    end
+
+    C->>M: getLottoCount() 호출
+    M-->>C: 구매 가능한 로또 개수(count)
+
+    C->>F: generate(count) 호출
+    F->>G: generate(count) 위임
+
+    loop count번
+        G->>G: Randoms.pickUniqueNumbersInRange(1,45,6)
+        G->>L: Lotto(numbers) 생성
+    end
+    G-->>F: List<Lotto> 반환
+    F-->>C: List<Lotto> 반환
+
+    C->>O: 구매한 로또 목록 출력
+    O->>U: 로또 목록 표시
+    		
+Note over U,C: 🏆 2단계: 당첨 번호 입력
+    loop 유효한 당첨 번호가 입력될 때까지
+        U->>I: 당첨 번호 입력 (쉼표 구분)
+        I->>C: 당첨 번호 전달
+        C->>W: WinningNumbers 생성 및 검증
+        alt 검증 성공
+            W-->>C: 당첨 번호 객체 생성됨
+        else 검증 실패
+            W-->>C: IllegalArgumentException
+            C->>O: 에러 메시지 출력
+            O->>U: 에러 표시
+        end
+    end
+
+    loop 유효한 보너스 번호가 입력될 때까지
+        U->>I: 보너스 번호 입력
+        I->>C: 보너스 번호 전달
+        C->>W: 보너스 번호 설정 및 검증
+        alt 검증 성공
+            W-->>C: 최종 당첨 번호 객체 완성
+        else 검증 실패
+            W-->>C: IllegalArgumentException
+            C->>O: 에러 메시지 출력
+            O->>U: 에러 표시
+        end
+    end
+    Note over U,C: 📊 3단계: 결과 분석 및 출력
+    C->>R: LottoResults 생성 (List<Lotto>, WinningNumbers)
+    loop 각 로또에 대해
+        R->>R: 등수별 카운트 증가
+        R->>R: 총 상금 누적
+    end
+    C->>R: calculateYield(구입 금액) 호출
+    R-->>C: 수익률 반환
+    C->>O: 당첨 통계 출력
+    O->>U: 통계 표시
+    C->>O: 수익률 출력
+    O->>U: 수익률 표시
+```
+
+<br>
+<br>
+
+## **🧱 객체 역할 요약**
+
+| 객체 이름                  | 역할(책임)                                      | 보유 값(상태)                        | 주요 행위                                                            |
+|------------------------|---------------------------------------------|---------------------------------|------------------------------------------------------------------|
+| `Money`                | 구입 금액을 표현하고 관련 규칙을 검증하는 값 객체                | * 구입 금액                         | - 금액 유효성 검사, 구매 가능한 로또 수 계산                                      |
+| `Lotto`                | 로또 한 장을 표현하며 번호 규칙(개수, 범위, 중복)의 불변성을 보장     | * 6개의 로또 번호                     | - 번호 정렬 및 중복 검사, 당첨 번호와 일치 개수 계산, 보너스 포함 여부 확인                   |
+| `LottoGenerator`       | 로또 번호 생성 전략을 추상화하는 인터페이스                    |                                 | - 요청된 개수만큼 `Lotto` 리스트 생성                                        |
+| `RandomLottoGenerator` | 랜덤 전략으로 로또 규칙에 맞는 번호를 생성                    |                                 | - `Randoms.pickUniqueNumbersInRange()`를 사용해 번호 생성, `Lotto` 객체 생성 |
+| `LottoFactory`         | 로또 생성 전략(`LottoGenerator`)에 생성 요청을 위임하는 팩토리 | * `LottoGenerator` 구현체          | - 생성기 null 검증, 생성 개수 검증, 생성기에 로또 생성 위임                           |
+| `WinningNumbers`       | 당첨 번호와 보너스 번호를 가지며 관련 규칙(개수, 범위, 중복)을 책임짐   | * 6개 당첨 번호, 1개 보너스 번호           | - 당첨 번호 유효성 검사, 보너스 번호 유효성 검사 및 중복 확인                            |
+| `LottoRank`            | 당첨 등수(1~5등, 꽝)의 조건(일치 개수, 보너스)과 상금을 정의      | * Enum(일치 개수, 보너스 포함 여부, 당첨 금액) | - 일치 수/보너스 포함 여부로 등수 반환, 상금 반환                                   |
+| `LottoResults`         | 전체 당첨 결과를 집계하고 최종 수익률을 계산                   | * 등수별 당첨 횟수, 누적 상금              | - 각 로또에 대한 등수 계산, 당첨 결과 누적, 수익률 계산                               |
+| `InputView`            | 사용자로부터 입력을 받는 모든 로직을 담당                     | * 입력 접두사                        | - 사용자로부터 입력을 받음, `Console.readLine()` 사용                         |
+| `OutputView`           | 사용자에게 정보를 출력하는 모든 로직을 담당                    | * 출력 접두사                        | - 구매한 로또 목록 출력, 당첨 결과 출력, 수익률 출력                                 |
+| `InputValidator`       | 문자열 입력을 숫자/리스트로 변환하고 형식을 검증하는 유틸리티          | -                               | - 구입 금액/당첨 번호/보너스 번호 문자열 파싱, 공백 및 숫자 형식 검증                       |
+| `LottoController`      | 애플리케이션의 전체 실행 흐름을 조율. View와 Domain 객체들을 연결  |                                 | - 전체 흐름 제어                                                       |
+
+<br>
+<br>
+
+## **🚰 구현 순서 (Inside-Out 방식)**
+
+### **1단계: 핵심 도메인 모델 구현**
+
+> 비즈니스의 가장 본질적인 규칙과 데이터를 정의하고 테스트합니다.
+>
+
+- `Money`: 금액을 표현하고, 1,000원 단위 검증 및 로또 구매 가능 개수 계산 책임을 가집니다.
+- `Lotto`: 로또 한 장(6개 번호)을 표현하며, 번호 개수, 범위, 중복 등 규칙의 불변성을 보장합니다.
+
+### **2단계: 당첨 규칙 및 판정 로직 구현**
+
+> 당첨을 결정하는 기준과 로직을 구현합니다.
+>
+
+- `WinningNumbers`: 당첨 번호(6개)와 보너스 번호(1개)를 가지며, 관련된 유효성 검증 책임을 가집니다.
+- `LottoRank`: 5개 등수와 '꽝'에 대한 조건(일치 개수, 보너스 여부)과 상금을 `enum`으로 정의합니다. **(등수 판정 로직 포함)**
+
+### **3단계: 결과 집계 및 분석 로직 구현**
+
+> 구매한 로또들의 결과를 종합하여 통계를 내는 책임을 구현합니다.
+>
+
+- `LottoResults`: 구매한 모든 `Lotto`와 `WinningNumbers`를 비교하여, 등수별 당첨 횟수를 집계하고 최종 수익률을 계산합니다.
+
+### **4단계: 로또 생성 로직 구현**
+
+> 도메인 규칙에 따라 로또를 생성하는 책임을 구현합니다.
+>
+
+- `LottoFactory`: `LottoGenerator`를 사용해 규칙에 맞는 로또 목록을 생성합니다.
+
+### **5단계: 입출력(UI) 계층 구현**
+
+> 사용자와 상호작용하는 부분을 구현합니다.
+>
+
+- `InputView`: 사용자로부터 구입 금액, 당첨 번호, 보너스 번호를 입력받는 책임을 가집니다.
+- `OutputView`: 구매 내역, 당첨 통계, 수익률, 에러 메시지 등 모든 출력 내용을 형식에 맞게 보여주는 책임을 가집니다.
+- `InputValidator`: `InputView`를 통해 들어온 사용자 입력 값의 형식(숫자인지, 쉼표로 구분되는지 등)을 검증합니다.
+
+### **6단계: 애플리케이션 통합 및 실행**
+
+> 구현된 모든 객체를 조립하여 프로그램을 완성합니다.
+>
+
+- `LottoController`: 전체 애플리케이션의 실행 흐름(로또 구매 → 당첨 번호 입력 → 결과 발표)을 제어하고, 예외 발생 시 재입력 로직을 처리합니다.
+- `Application`: 프로그램의 시작점(`main` 메서드)으로, `LottoController`를 생성하고 실행합니다.
+
+### **7단계: 리팩토링 및 최종 검토**
+
+> 코드 품질을 개선하고 요구사항을 최종 점검합니다.
+>
+
+- `ValidationUtil`, `Retry` 등 중복 로직을 유틸리티 클래스로 추출합니다.
+- 전체 코드에 대해 프로그래밍 제약 조건(들여쓰기, 메서드 길이 등) 준수 여부를 검토합니다.
+
+<br>
+<br>
+
+## 📋 예외 처리
+
+사용자의 입력 오류로 예외가 발생하면  **`[ERROR] ...` 로 시작하는 에러 메시지를 사용자에게 출력하고 해당 입력부터 다시 입력을 진행할 수 있도록 합니다.**
+
+| 예외 상황                      | 에러 메시지                                    |
+|----------------------------|-------------------------------------------|
+| 당첨 결과를 계산할 로또 목록이 null인 경우 | `[ERROR] 당첨 결과를 계산할 로또 목록은 null일 수 없습니다.` |
+| 로또 목록에 null이 포함된 경우        | `[ERROR] 로또 목록에 null이 포함될 수 없습니다.`        |
+| 당첨 번호가 null인 경우            | `[ERROR] 당첨 번호는 null일 수 없습니다.`            |
+| 수익률 계산시 구입금액이 0 이하인 경우     | `[ERROR] 구입 금액은 0보다 커야 합니다.`              |
+| 구입 금액이 0 이하인 경우            | `[ERROR] 구입 금액은 0보다 커야 합니다.`              |
+| 구입 금액이 1,000원 단위가 아닌 경우    | `[ERROR] 1,000원 단위로 입력해 주세요.`             |
+| 로또 번호 리스트가 null인 경우        | `[ERROR] 로또 번호는 null일 수 없습니다.`            |
+| 비교할 로또 번호 리스트가 null인 경우    | `[ERROR] 비교할 로또가 null일 수 없습니다.`           |
+| 로또 번호가 6개가 아닌 경우           | `[ERROR] 로또 번호는 6개여야 합니다.`                |
+| 로또 번호에 중복이 있는 경우           | `[ERROR] 로또 번호는 중복될 수 없습니다.`              |
+| 로또 번호가 1~45 범위를 벗어나는 경우    | `[ERROR] 로또 번호는 1부터 45 사이여야 합니다.`         |
+| 보너스 번호가 1~45 범위를 벗어난 경우    | `[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.`        |
+| 보너스 번호가 당첨 번호와 중복되는 경우     | `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`      |
+| 로또 생성기가 null인 경우           | `[ERROR] 로또 생성기는 null일 수 없습니다.`           |
+| 로또 생성 개수가 0 이하인 경우         | `[ERROR] 로또 생성 개수는 1개 이상이어야 합니다.`         |
+| 입력 문자열이 null 또는 공백인 경우     | `[ERROR] 입력은 비어 있을 수 없습니다.`               |
+| 구입 금액 입력이 숫자가 아닌 경우        | `[ERROR] 구입 금액은 숫자여야 합니다.`                |
+| 당첨 번호 입력에 숫자가 아닌 값이 포함된 경우 | `[ERROR] 당첨 번호는 숫자여야 합니다.`                |
+| 보너스 번호 입력이 숫자가 아닌 경우       | `[ERROR] 보너스 번호는 숫자여야 합니다.`               |
+
+<br>
+<br>
+
+## ⚙️ 개발 및 기술 제약
+
+- 이 프로그램은 **Java 21**에서 실행되어야 한다.
+- 프로그램의 시작점은 **`Application` 클래스의 `main()`** 메서드여야 한다.
+- **제공된 `build.gradle` 파일은 수정할 수 없다.** 외부 라이브러리를 추가하지 않는다.
+- 로또 번호 생성은 **`camp.nextstep.edu.missionutils.Randoms.pickUniqueNumbersInRange(1, 45, 6)`** 을 사용한다.
+- 사용자 입력은 **`camp.nextstep.edu.missionutils.Console.readLine()`** 으로만 받는다.
+- 프로그램 종료를 위해 **`System.exit()`를 호출해서는 안 된다.**
+- 들여쓰기는 **2단계 이내**로 유지한다.
+- **`else` 문, `switch/case`, 삼항 연산자**는 사용하지 않는다.
+- 하나의 메서드는 **한 가지 일만** 하도록 작성하고, **15줄을 넘기지 않도록** 한다.
+- 제공된 `Lotto` 클래스에는 **필드를 추가하지 않는다.**
+
+<br>
+<br>
+
+## 📝 구현 기록 / 고민 정보
+
+구현 과정에서 배우고 고민했던 것들을 기록하는 공간입니다.
+
+- [도메인 설계시 고려했던 것](https://github.com/JohnPrk/java-lotto-8/issues/1)
+- [Inside-Out vs Outside-In TDD 선택 이유](https://github.com/JohnPrk/java-lotto-8/issues/2)
+- [Supplier는 무엇인가?](https://github.com/JohnPrk/java-lotto-8/issues/3)
+- [2023년 구현 vs 지금 구현 비교[회고]](https://github.com/JohnPrk/java-lotto-8/issues/4)
+
+<br>
+<br>
diff --git a/src/main/java/lotto/Application.java b/src/main/java/lotto/Application.java
index d190922ba4..14e77be8a8 100644
--- a/src/main/java/lotto/Application.java
+++ b/src/main/java/lotto/Application.java
@@ -1,7 +1,14 @@
 package lotto;
 
+import lotto.controller.LottoController;
+import lotto.domain.LottoFactory;
+import lotto.domain.RandomLottoGenerator;
+
 public class Application {
+
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        LottoFactory lottoFactory = new LottoFactory(new RandomLottoGenerator());
+        LottoController controller = new LottoController(lottoFactory);
+        controller.run();
     }
 }
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/controller/LottoController.java b/src/main/java/lotto/controller/LottoController.java
new file mode 100644
index 0000000000..5864bd78c5
--- /dev/null
+++ b/src/main/java/lotto/controller/LottoController.java
@@ -0,0 +1,71 @@
+package lotto.controller;
+
+import lotto.domain.*;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
+import java.util.List;
+
+public class LottoController {
+
+    private final LottoFactory lottoFactory;
+
+    public LottoController(LottoFactory lottoFactory) {
+        this.lottoFactory = lottoFactory;
+    }
+
+    public void run() {
+        Money money = readMoney();
+        int lottoCount = money.getLottoCount();
+        List<Lotto> lottos = lottoFactory.generate(lottoCount);
+        OutputView.printLottos(lottos);
+        WinningNumbers winningNumbers = readWinningNumbers();
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+        OutputView.printStatistics(results);
+        double yield = results.calculateYield(money.getAmount());
+        OutputView.printYield(yield);
+    }
+
+    private Money readMoney() {
+        while (true) {
+            try {
+                int purchaseAmount = InputView.readPurchaseAmount();
+                return new Money(purchaseAmount);
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private WinningNumbers readWinningNumbers() {
+        while (true) {
+            try {
+                List<Integer> numbers = readWinningNumberList();
+                int bonus = readBonusNumber();
+                return new WinningNumbers(numbers, bonus);
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private List<Integer> readWinningNumberList() {
+        while (true) {
+            try {
+                return InputView.readWinningNumbers();
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+
+    private int readBonusNumber() {
+        while (true) {
+            try {
+                return InputView.readBonusNumber();
+            } catch (IllegalArgumentException e) {
+                OutputView.printError(e.getMessage());
+            }
+        }
+    }
+}
diff --git a/src/main/java/lotto/domain/Lotto.java b/src/main/java/lotto/domain/Lotto.java
new file mode 100644
index 0000000000..18bdc0ef86
--- /dev/null
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -0,0 +1,78 @@
+package lotto.domain;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class Lotto {
+
+    private static final int LOTTO_SIZE = 6;
+    private static final int MIN_NUMBER = 1;
+    private static final int MAX_NUMBER = 45;
+    private final List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        validateNotNull(numbers);
+        validateCount(numbers);
+        validateRange(numbers);
+        validateDuplicate(numbers);
+        this.numbers = sortNumbers(numbers);
+    }
+
+    public List<Integer> getNumbers() {
+        return Collections.unmodifiableList(numbers);
+    }
+
+    public boolean containsNumber(int number) {
+        return numbers.contains(number);
+    }
+
+    public int countMatchingNumbers(Lotto otherLotto) {
+        validateOtherLottoNotNull(otherLotto);
+        Set<Integer> otherNumbers = new HashSet<>(otherLotto.numbers);
+        return (int) numbers.stream()
+                .filter(otherNumbers::contains)
+                .count();
+    }
+
+    private void validateOtherLottoNotNull(Lotto otherLotto) {
+        if (otherLotto == null) {
+            throw new IllegalArgumentException("[ERROR] 비교할 로또가 null일 수 없습니다.");
+        }
+    }
+
+    private void validateNotNull(List<Integer> numbers) {
+        if (numbers == null) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 null일 수 없습니다.");
+        }
+    }
+
+    private void validateCount(List<Integer> numbers) {
+        if (numbers.size() != LOTTO_SIZE) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 6개여야 합니다.");
+        }
+    }
+
+    private void validateRange(List<Integer> numbers) {
+        for (int number : numbers) {
+            if (number < MIN_NUMBER || number > MAX_NUMBER) {
+                throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이여야 합니다.");
+            }
+        }
+    }
+
+    private void validateDuplicate(List<Integer> numbers) {
+        Set<Integer> uniqueNumbers = new HashSet<>(numbers);
+        if (uniqueNumbers.size() != LOTTO_SIZE) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 중복될 수 없습니다.");
+        }
+    }
+
+    private List<Integer> sortNumbers(List<Integer> numbers) {
+        return numbers.stream()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+}
diff --git a/src/main/java/lotto/domain/LottoFactory.java b/src/main/java/lotto/domain/LottoFactory.java
new file mode 100644
index 0000000000..8315a0c24b
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoFactory.java
@@ -0,0 +1,30 @@
+package lotto.domain;
+
+import java.util.List;
+
+public class LottoFactory {
+
+    private final LottoGenerator generator;
+
+    public LottoFactory(LottoGenerator generator) {
+        validateGenerator(generator);
+        this.generator = generator;
+    }
+
+    public List<Lotto> generate(int count) {
+        validateCount(count);
+        return generator.generate(count);
+    }
+
+    private void validateGenerator(LottoGenerator generator) {
+        if (generator == null) {
+            throw new IllegalArgumentException("[ERROR] 로또 생성기는 null일 수 없습니다.");
+        }
+    }
+
+    private void validateCount(int count) {
+        if (count <= 0) {
+            throw new IllegalArgumentException("[ERROR] 로또 생성 개수는 1개 이상이어야 합니다.");
+        }
+    }
+}
diff --git a/src/main/java/lotto/domain/LottoGenerator.java b/src/main/java/lotto/domain/LottoGenerator.java
new file mode 100644
index 0000000000..d3e9241185
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoGenerator.java
@@ -0,0 +1,9 @@
+package lotto.domain;
+
+import java.util.List;
+
+public interface LottoGenerator {
+
+    List<Lotto> generate(int count);
+
+}
diff --git a/src/main/java/lotto/domain/LottoRank.java b/src/main/java/lotto/domain/LottoRank.java
new file mode 100644
index 0000000000..d2496e1afe
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoRank.java
@@ -0,0 +1,37 @@
+package lotto.domain;
+
+import java.util.Arrays;
+
+public enum LottoRank {
+
+    FIRST(6, false, 2_000_000_000L),
+    SECOND(5, true, 30_000_000L),
+    THIRD(5, false, 1_500_000L),
+    FOURTH(4, false, 50_000L),
+    FIFTH(3, false, 5_000L),
+    NONE(0, false, 0L);
+
+    private final int matchCount;
+    private final boolean requiresBonus;
+    private final long prize;
+
+    LottoRank(int matchCount, boolean requiresBonus, long prize) {
+        this.matchCount = matchCount;
+        this.requiresBonus = requiresBonus;
+        this.prize = prize;
+    }
+
+    public long getPrize() {
+        return prize;
+    }
+
+    public static LottoRank from(int matchCount, boolean bonusMatched) {
+        if (matchCount == 5) {
+            return bonusMatched ? SECOND : THIRD;
+        }
+        return Arrays.stream(values())
+                .filter(rank -> rank.matchCount == matchCount)
+                .findFirst()
+                .orElse(NONE);
+    }
+}
diff --git a/src/main/java/lotto/domain/LottoResults.java b/src/main/java/lotto/domain/LottoResults.java
new file mode 100644
index 0000000000..9a512b497c
--- /dev/null
+++ b/src/main/java/lotto/domain/LottoResults.java
@@ -0,0 +1,71 @@
+package lotto.domain;
+
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class LottoResults {
+
+    private final Map<LottoRank, Integer> results = new EnumMap<>(LottoRank.class);
+    private long totalPrize;
+
+    public LottoResults(List<Lotto> lottos, WinningNumbers winningNumbers) {
+        validateLottos(lottos);
+        validateLottoElements(lottos);
+        validateWinningNumbers(winningNumbers);
+        countResults(lottos, winningNumbers);
+    }
+
+    public int getCountOf(LottoRank rank) {
+        return results.getOrDefault(rank, 0);
+    }
+
+    public long getTotalPrize() {
+        return totalPrize;
+    }
+
+    public double calculateYield(long purchaseAmount) {
+        if (purchaseAmount <= 0) {
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");
+        }
+        return (double) totalPrize / purchaseAmount;
+    }
+
+    private void validateLottos(List<Lotto> lottos) {
+        if (lottos == null) {
+            throw new IllegalArgumentException("[ERROR] 당첨 결과를 계산할 로또 목록은 null일 수 없습니다.");
+        }
+    }
+
+    private void validateLottoElements(List<Lotto> lottos) {
+        for (Lotto lotto : lottos) {
+            if (lotto == null) {
+                throw new IllegalArgumentException("[ERROR] 로또 목록에 null이 포함될 수 없습니다.");
+            }
+        }
+    }
+
+    private void validateWinningNumbers(WinningNumbers winningNumbers) {
+        if (winningNumbers == null) {
+            throw new IllegalArgumentException("[ERROR] 당첨 번호는 null일 수 없습니다.");
+        }
+    }
+
+    private void countResults(List<Lotto> lottos, WinningNumbers winningNumbers) {
+        for (Lotto lotto : lottos) {
+            LottoRank rank = toRank(lotto, winningNumbers);
+            incrementRankCount(rank);
+            totalPrize += rank.getPrize();
+        }
+    }
+
+    private LottoRank toRank(Lotto lotto, WinningNumbers winningNumbers) {
+        int matchCount = winningNumbers.countMatchingNumbers(lotto);
+        boolean bonusMatched = winningNumbers.containsBonusNumber(lotto);
+        return LottoRank.from(matchCount, bonusMatched);
+    }
+
+    private void incrementRankCount(LottoRank rank) {
+        results.put(rank, results.getOrDefault(rank, 0) + 1);
+    }
+}
diff --git a/src/main/java/lotto/domain/Money.java b/src/main/java/lotto/domain/Money.java
new file mode 100644
index 0000000000..257fdfee61
--- /dev/null
+++ b/src/main/java/lotto/domain/Money.java
@@ -0,0 +1,33 @@
+package lotto.domain;
+
+public class Money {
+
+    private static final int UNIT_MONEY_FOR_BUY_LOTTO = 1000;
+    private final int amount;
+
+    public Money(int amount) {
+        validatePositive(amount);
+        validateUnit(amount);
+        this.amount = amount;
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+
+    private void validatePositive(int amount) {
+        if (amount <= 0) {
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");
+        }
+    }
+
+    private void validateUnit(int amount) {
+        if (amount % UNIT_MONEY_FOR_BUY_LOTTO != 0) {
+            throw new IllegalArgumentException("[ERROR] 1,000원 단위로 입력해 주세요.");
+        }
+    }
+
+    public int getLottoCount() {
+        return amount / UNIT_MONEY_FOR_BUY_LOTTO;
+    }
+}
diff --git a/src/main/java/lotto/domain/RandomLottoGenerator.java b/src/main/java/lotto/domain/RandomLottoGenerator.java
new file mode 100644
index 0000000000..4897ff372b
--- /dev/null
+++ b/src/main/java/lotto/domain/RandomLottoGenerator.java
@@ -0,0 +1,23 @@
+package lotto.domain;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RandomLottoGenerator implements LottoGenerator {
+
+    private static final int LOTTO_NUMBER_MIN = 1;
+    private static final int LOTTO_NUMBER_MAX = 45;
+    private static final int LOTTO_SIZE = 6;
+
+    @Override
+    public List<Lotto> generate(int count) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            List<Integer> numbers = Randoms.pickUniqueNumbersInRange(LOTTO_NUMBER_MIN, LOTTO_NUMBER_MAX, LOTTO_SIZE);
+            lottos.add(new Lotto(numbers));
+        }
+        return lottos;
+    }
+}
diff --git a/src/main/java/lotto/domain/WinningNumbers.java b/src/main/java/lotto/domain/WinningNumbers.java
new file mode 100644
index 0000000000..b90dc0b219
--- /dev/null
+++ b/src/main/java/lotto/domain/WinningNumbers.java
@@ -0,0 +1,45 @@
+package lotto.domain;
+
+import java.util.List;
+
+public class WinningNumbers {
+
+    private final Lotto winningLotto;
+    private final int bonusNumber;
+
+    public WinningNumbers(List<Integer> winningNumbers, int bonusNumber) {
+        Lotto lotto = new Lotto(winningNumbers);
+        validateBonusNumber(lotto, bonusNumber);
+        this.winningLotto = lotto;
+        this.bonusNumber = bonusNumber;
+    }
+
+    public int getBonusNumber() {
+        return bonusNumber;
+    }
+
+    public int countMatchingNumbers(Lotto lotto) {
+        return winningLotto.countMatchingNumbers(lotto);
+    }
+
+    public boolean containsBonusNumber(Lotto lotto) {
+        return lotto.containsNumber(bonusNumber);
+    }
+
+    private void validateBonusNumber(Lotto winningLotto, int bonusNumber) {
+        validateBonusRange(bonusNumber);
+        validateBonusDuplicate(winningLotto, bonusNumber);
+    }
+
+    private void validateBonusRange(int bonusNumber) {
+        if (bonusNumber < 1 || bonusNumber > 45) {
+            throw new IllegalArgumentException("[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.");
+        }
+    }
+
+    private void validateBonusDuplicate(Lotto winningLotto, int bonusNumber) {
+        if (winningLotto.containsNumber(bonusNumber)) {
+            throw new IllegalArgumentException("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+        }
+    }
+}
diff --git a/src/main/java/lotto/view/InputValidator.java b/src/main/java/lotto/view/InputValidator.java
new file mode 100644
index 0000000000..17c772e86b
--- /dev/null
+++ b/src/main/java/lotto/view/InputValidator.java
@@ -0,0 +1,54 @@
+package lotto.view;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class InputValidator {
+
+    private static final String NUMBER_DELIMITER = ",";
+
+    private InputValidator() {
+    }
+
+    public static int parsePurchaseAmount(String input) {
+        validateNotBlank(input);
+        String trimmed = input.trim();
+        try {
+            return Integer.parseInt(trimmed);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 숫자여야 합니다.");
+        }
+    }
+
+    public static List<Integer> parseWinningNumbers(String input) {
+        validateNotBlank(input);
+        String[] parts = input.split(NUMBER_DELIMITER);
+        return Arrays.stream(parts)
+                .map(String::trim)
+                .map(part -> parseNumber(part, "[ERROR] 당첨 번호는 숫자여야 합니다."))
+                .toList();
+    }
+
+    public static int parseBonusNumber(String input) {
+        validateNotBlank(input);
+        String trimmed = input.trim();
+        return parseNumber(trimmed, "[ERROR] 보너스 번호는 숫자여야 합니다.");
+    }
+
+    private static void validateNotBlank(String input) {
+        if (input == null) {
+            throw new IllegalArgumentException("[ERROR] 입력은 비어 있을 수 없습니다.");
+        }
+        if (input.trim().isEmpty()) {
+            throw new IllegalArgumentException("[ERROR] 입력은 비어 있을 수 없습니다.");
+        }
+    }
+
+    private static int parseNumber(String value, String errorMessage) {
+        try {
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(errorMessage);
+        }
+    }
+}
diff --git a/src/main/java/lotto/view/InputView.java b/src/main/java/lotto/view/InputView.java
new file mode 100644
index 0000000000..6d48cbfb6f
--- /dev/null
+++ b/src/main/java/lotto/view/InputView.java
@@ -0,0 +1,29 @@
+package lotto.view;
+
+import camp.nextstep.edu.missionutils.Console;
+
+import java.util.List;
+
+public class InputView {
+
+    public static int readPurchaseAmount() {
+        System.out.println("구입금액을 입력해 주세요.");
+        String input = Console.readLine();
+        System.out.println();
+        return InputValidator.parsePurchaseAmount(input);
+    }
+
+    public static List<Integer> readWinningNumbers() {
+        System.out.println("당첨 번호를 입력해 주세요.");
+        String input = Console.readLine();
+        System.out.println();
+        return InputValidator.parseWinningNumbers(input);
+    }
+
+    public static int readBonusNumber() {
+        System.out.println("보너스 번호를 입력해 주세요.");
+        String input = Console.readLine();
+        System.out.println();
+        return InputValidator.parseBonusNumber(input);
+    }
+}
diff --git a/src/main/java/lotto/view/OutputView.java b/src/main/java/lotto/view/OutputView.java
new file mode 100644
index 0000000000..60569371a9
--- /dev/null
+++ b/src/main/java/lotto/view/OutputView.java
@@ -0,0 +1,41 @@
+package lotto.view;
+
+import lotto.domain.Lotto;
+import lotto.domain.LottoRank;
+import lotto.domain.LottoResults;
+
+import java.util.List;
+
+public class OutputView {
+
+    public static void printLottos(List<Lotto> lottos) {
+        System.out.printf("%d개를 구매했습니다.%n", lottos.size());
+        for (Lotto lotto : lottos) {
+            System.out.println(lotto.getNumbers());
+        }
+    }
+
+    public static void printStatistics(LottoResults results) {
+        System.out.println("당첨 통계");
+        System.out.println("---");
+        printRankResult(results, LottoRank.FIFTH, "3개 일치 (5,000원) - %d개");
+        printRankResult(results, LottoRank.FOURTH, "4개 일치 (50,000원) - %d개");
+        printRankResult(results, LottoRank.THIRD, "5개 일치 (1,500,000원) - %d개");
+        printRankResult(results, LottoRank.SECOND, "5개 일치, 보너스 볼 일치 (30,000,000원) - %d개");
+        printRankResult(results, LottoRank.FIRST, "6개 일치 (2,000,000,000원) - %d개");
+    }
+
+    private static void printRankResult(LottoResults results, LottoRank rank, String format) {
+        int count = results.getCountOf(rank);
+        System.out.printf(format + "%n", count);
+    }
+
+    public static void printYield(double yield) {
+        double percentage = yield * 100;
+        System.out.printf("총 수익률은 %.1f%%입니다.%n", percentage);
+    }
+
+    public static void printError(String message) {
+        System.out.println(message);
+    }
+}
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/FakeLottoGeneratorTest.java b/src/test/java/lotto/domain/FakeLottoGeneratorTest.java
new file mode 100644
index 0000000000..13a66540ee
--- /dev/null
+++ b/src/test/java/lotto/domain/FakeLottoGeneratorTest.java
@@ -0,0 +1,62 @@
+package lotto.domain;
+
+import lotto.domain.testDouble.FakeLottoGenerator;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class FakeLottoGeneratorTest {
+
+    @Test
+    void 준비된_번호_시퀀스를_사용해_요청한_개수만큼_로또를_생성한다() {
+
+        // given
+        List<List<Integer>> numbersSequences = List.of(
+                List.of(1, 2, 3, 4, 5, 6),
+                List.of(7, 8, 9, 10, 11, 12)
+        );
+        LottoGenerator generator = new FakeLottoGenerator(numbersSequences);
+
+        // when
+        List<Lotto> lottos = generator.generate(2);
+
+        // then
+        assertThat(lottos).hasSize(2);
+        assertThat(lottos.get(0).getNumbers()).containsExactly(1, 2, 3, 4, 5, 6);
+        assertThat(lottos.get(1).getNumbers()).containsExactly(7, 8, 9, 10, 11, 12);
+    }
+
+    @Test
+    void 준비된_번호보다_많은_개수를_요청하면_NoSuchElementException이_발생한다() {
+
+        // given
+        List<List<Integer>> numbersSequences = List.of(
+                List.of(1, 2, 3, 4, 5, 6)
+        );
+        LottoGenerator generator = new FakeLottoGenerator(numbersSequences);
+
+        // when & then
+        assertThatThrownBy(() -> generator.generate(2))
+                .isInstanceOf(NoSuchElementException.class);
+    }
+
+    @Test
+    void of_정적_팩터리_메서드는_단일_번호_세트로_로또를_생성한다() {
+
+        // given
+        FakeLottoGenerator generator = FakeLottoGenerator.of(
+                List.of(1, 2, 3, 4, 5, 6)
+        );
+
+        // when
+        List<Lotto> lottos = generator.generate(1);
+
+        // then
+        assertThat(lottos).hasSize(1);
+        assertThat(lottos.get(0).getNumbers()).containsExactly(1, 2, 3, 4, 5, 6);
+    }
+}
diff --git a/src/test/java/lotto/domain/LottoFactoryTest.java b/src/test/java/lotto/domain/LottoFactoryTest.java
new file mode 100644
index 0000000000..a2f0bd5791
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoFactoryTest.java
@@ -0,0 +1,61 @@
+package lotto.domain;
+
+import lotto.domain.testDouble.FakeLottoGenerator;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullSource;
+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 LottoFactoryTest {
+
+    @Test
+    void 유효한_생성기와_개수로_로또_목록을_생성한다() {
+
+        // given
+        FakeLottoGenerator generator = new FakeLottoGenerator(
+                List.of(
+                        List.of(1, 2, 3, 4, 5, 6),
+                        List.of(7, 8, 9, 10, 11, 12),
+                        List.of(13, 14, 15, 16, 17, 18)
+                )
+        );
+        LottoFactory factory = new LottoFactory(generator);
+        int count = 3;
+
+        // when
+        List<Lotto> lottos = factory.generate(count);
+
+        // then
+        assertThat(lottos).hasSize(count);
+        assertThat(lottos).allSatisfy(lotto -> assertThat(lotto).isNotNull());
+    }
+
+    @ParameterizedTest
+    @NullSource
+    void 생성기가_null이면_예외가_발생한다(LottoGenerator generator) {
+
+        // when & then
+        assertThatThrownBy(() -> new LottoFactory(generator))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 생성기는 null일 수 없습니다.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1, -10})
+    void 생성_개수가_0_이하이면_예외가_발생한다(int count) {
+
+        // given
+        LottoGenerator generator = FakeLottoGenerator.of(List.of(1, 2, 3, 4, 5, 6));
+        LottoFactory factory = new LottoFactory(generator);
+
+        // when & then
+        assertThatThrownBy(() -> factory.generate(count))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 생성 개수는 1개 이상이어야 합니다.");
+    }
+}
diff --git a/src/test/java/lotto/domain/LottoRankTest.java b/src/test/java/lotto/domain/LottoRankTest.java
new file mode 100644
index 0000000000..ffbb85c6a7
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoRankTest.java
@@ -0,0 +1,152 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LottoRankTest {
+
+    @Test
+    void 여섯_개가_모두_일치하면_1등이다() {
+
+        // given
+        int matchCount = 6;
+        boolean bonusMatched = false;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, bonusMatched);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.FIRST);
+    }
+
+    @Test
+    void 다섯_개와_보너스까지_일치하면_2등이다() {
+
+        // given
+        int matchCount = 5;
+        boolean bonusMatched = true;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, bonusMatched);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.SECOND);
+    }
+
+    @Test
+    void 다섯_개만_일치하고_보너스는_다르면_3등이다() {
+
+        // given
+        int matchCount = 5;
+        boolean bonusMatched = false;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, bonusMatched);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.THIRD);
+    }
+
+    @Test
+    void 네_개가_일치하면_4등이다() {
+
+        // given
+        int matchCount = 4;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, false);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.FOURTH);
+    }
+
+    @Test
+    void 세_개가_일치하면_5등이다() {
+
+        // given
+        int matchCount = 3;
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, false);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.FIFTH);
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1, 2})
+    void 두_개_이하로_일치하면_꽝이다(int matchCount) {
+
+        // when
+        LottoRank rank = LottoRank.from(matchCount, false);
+
+        // then
+        assertThat(rank).isEqualTo(LottoRank.NONE);
+    }
+
+    @ParameterizedTest
+    @MethodSource("providePrizePerRank")
+    void 등수별_당첨금을_반환한다(LottoRank rank, long expectedPrize) {
+
+        //when
+        long prize = rank.getPrize();
+
+        // then
+        assertThat(prize).isEqualTo(expectedPrize);
+    }
+
+
+    @ParameterizedTest
+    @MethodSource("bonusShouldBeIgnoredCases")
+    void 보너스는_다섯_개가_맞을_때를_제외하고는_영향을_주지_않는다(int matchCount) {
+
+        // when
+        LottoRank withBonus = LottoRank.from(matchCount, true);
+        LottoRank withoutBonus = LottoRank.from(matchCount, false);
+
+        // then
+        assertThat(withBonus).isEqualTo(withoutBonus);
+    }
+
+    @Test
+    void 다섯_개_일치_시_보너스_여부에_따라_등수가_바뀐다() {
+
+        // when
+        LottoRank withBonus = LottoRank.from(5, true);
+        LottoRank withoutBonus = LottoRank.from(5, false);
+
+        // then
+        assertThat(withBonus).isEqualTo(LottoRank.SECOND);
+        assertThat(withoutBonus).isEqualTo(LottoRank.THIRD);
+        assertThat(withBonus).isNotEqualTo(withoutBonus);
+    }
+
+    private static Stream<Arguments> bonusShouldBeIgnoredCases() {
+        return Stream.of(
+                Arguments.of(0),
+                Arguments.of(1),
+                Arguments.of(2),
+                Arguments.of(3),
+                Arguments.of(4),
+                Arguments.of(6)
+        );
+    }
+
+    private static Stream<Arguments> providePrizePerRank() {
+        return Stream.of(
+                Arguments.of(LottoRank.FIRST, 2_000_000_000L),
+                Arguments.of(LottoRank.SECOND, 30_000_000L),
+                Arguments.of(LottoRank.THIRD, 1_500_000L),
+                Arguments.of(LottoRank.FOURTH, 50_000L),
+                Arguments.of(LottoRank.FIFTH, 5_000L),
+                Arguments.of(LottoRank.NONE, 0L)
+        );
+    }
+}
diff --git a/src/test/java/lotto/domain/LottoResultsTest.java b/src/test/java/lotto/domain/LottoResultsTest.java
new file mode 100644
index 0000000000..fbd85777bf
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoResultsTest.java
@@ -0,0 +1,157 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LottoResultsTest {
+
+    @Test
+    void 주어진_로또들과_당첨_번호_로또를_비교하여_순위를_올리고_집계할_수_있다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto first = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+        Lotto second = new Lotto(List.of(1, 2, 3, 4, 5, 7));
+        Lotto third = new Lotto(List.of(1, 2, 3, 4, 5, 45));
+        Lotto fourth = new Lotto(List.of(1, 2, 3, 4, 11, 45));
+        Lotto fifth = new Lotto(List.of(1, 2, 3, 7, 11, 45));
+        Lotto none = new Lotto(List.of(10, 11, 12, 13, 14, 15));
+        List<Lotto> lottos = List.of(first, second, third, fourth, fifth, none);
+
+        // when
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+
+        // then
+        assertThat(results.getCountOf(LottoRank.FIRST)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.SECOND)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.THIRD)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.FOURTH)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.FIFTH)).isEqualTo(1);
+        assertThat(results.getCountOf(LottoRank.NONE)).isEqualTo(1);
+    }
+
+    @Test
+    void 주어진_로또들과_당첨_번호_로또의_일치_개수가_2_이하라면_NONE만_증가한다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        List<Lotto> lottos = List.of(
+                new Lotto(List.of(10, 11, 12, 13, 14, 15)),
+                new Lotto(List.of(20, 21, 22, 23, 24, 25)),
+                new Lotto(List.of(1, 2, 22, 23, 24, 25)),
+                new Lotto(List.of(20, 21, 3, 23, 24, 25)),
+                new Lotto(List.of(20, 21, 3, 4, 24, 25)),
+                new Lotto(List.of(20, 21, 10, 11, 5, 25)),
+                new Lotto(List.of(20, 21, 10, 11, 5, 6))
+        );
+
+        // when
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+
+        // then
+        for (LottoRank rank : LottoRank.values()) {
+            if (rank == LottoRank.NONE) {
+                assertThat(results.getCountOf(rank)).isEqualTo(7);
+                continue;
+            }
+            assertThat(results.getCountOf(rank)).isEqualTo(0);
+        }
+    }
+
+    @Test
+    void 당첨된_로또들의_총_당첨금을_합산한다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto first = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+        Lotto fifth = new Lotto(List.of(1, 2, 3, 40, 41, 42));
+        List<Lotto> lottos = List.of(first, fifth);
+
+        // when
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+
+        // then
+        assertThat(results.getTotalPrize()).isEqualTo(2_000_005_000L);
+    }
+
+    @Test
+    void 수익률을_구입금액으로_계산한다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto first = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+        Lotto third = new Lotto(List.of(1, 2, 3, 4, 17, 6));
+        List<Lotto> lottos = List.of(first, third);
+        LottoResults results = new LottoResults(lottos, winningNumbers);
+
+        // when
+        double yield = results.calculateYield(lottos.size() * 1000);
+
+        // then
+        assertThat(yield).isEqualTo(2_001_500_000D / 2_000D);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    void 로또_목록이_null이면_예외가_발생한다(List<Lotto> lottos) {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+
+        // when & then
+        assertThatThrownBy(() -> new LottoResults(lottos, winningNumbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 당첨 결과를 계산할 로또 목록은 null일 수 없습니다.");
+    }
+
+    @Test
+    void 로또_목록에_null이_포함되면_예외가_발생한다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        List<Lotto> lottos = new ArrayList<>();
+        lottos.add(new Lotto(List.of(1, 2, 3, 4, 5, 6)));
+        lottos.add(null);
+
+        // when & then
+        assertThatThrownBy(() -> new LottoResults(lottos, winningNumbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 목록에 null이 포함될 수 없습니다.");
+    }
+
+    @Test
+    void 당첨번호가_null이면_예외가_발생한다() {
+        // given
+        List<Lotto> lottos = List.of(new Lotto(List.of(1, 2, 3, 4, 5, 6)));
+
+        // when & then
+        assertThatThrownBy(() -> new LottoResults(lottos, null))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 당첨 번호는 null일 수 없습니다.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -10})
+    void 수익률_계산시_구입금액이_0_이하이면_예외가_발생한다(int purchaseAmount) {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        LottoResults results = new LottoResults(
+                List.of(new Lotto(List.of(1, 2, 3, 4, 5, 6))),
+                winningNumbers
+        );
+
+        // when & then
+        assertThatThrownBy(() -> results.calculateYield(purchaseAmount))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 구입 금액은 0보다 커야 합니다.");
+    }
+}
diff --git a/src/test/java/lotto/domain/LottoTest.java b/src/test/java/lotto/domain/LottoTest.java
new file mode 100644
index 0000000000..d535420017
--- /dev/null
+++ b/src/test/java/lotto/domain/LottoTest.java
@@ -0,0 +1,177 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.*;
+
+class LottoTest {
+
+    @Test
+    void 로또_번호가_6개보다_많으면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 6개여야 합니다.");
+    }
+
+    @Test
+    void 로또_번호가_6개보다_적으면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 6개여야 합니다.");
+    }
+
+    @Test
+    void 로또_번호에_중복된_숫자가_있으면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 5);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 중복될 수 없습니다.");
+    }
+
+    @ParameterizedTest()
+    @ValueSource(ints = {0, 46})
+    void 로또_번호가_1부터_45_사이의_값이_아니면_예외가_발생한다(int invalidNumber) {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, invalidNumber);
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 1부터 45 사이여야 합니다.");
+    }
+
+    @ParameterizedTest
+    @NullSource
+    void 로또_번호가_null이면_예외가_발생한다(List<Integer> numbers) {
+
+        // when & then
+        assertThatThrownBy(() -> new Lotto(numbers))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 null일 수 없습니다.");
+    }
+
+    @Test
+    void 로또_번호가_정상_범위에서_극_값인_1과_45를_포함해도_예외가_발생하지_않는다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 45);
+
+        // when & then
+        assertThatNoException().isThrownBy(() -> new Lotto(numbers));
+    }
+
+    @Test
+    void 정상_범위의_6개_값을_사용하면_객체_생성이_가능하다() {
+
+        // given
+        List<Integer> numbers = List.of(8, 1, 45, 3, 20, 10);
+
+        // when
+        Lotto lotto = new Lotto(numbers);
+
+        // then
+        assertThat(lotto).isNotNull();
+        assertThat(lotto.getNumbers()).hasSize(6);
+    }
+
+    @Test
+    void 로또_번호는_오름차순으로_정렬되어_저장된다() {
+
+        // given
+        List<Integer> numbers = List.of(8, 1, 45, 3, 20, 10);
+
+        // when
+        Lotto lotto = new Lotto(numbers);
+
+        // then
+        assertThat(lotto.getNumbers()).containsExactly(1, 3, 8, 10, 20, 45);
+    }
+
+    @Test
+    void 로또가_특정_번호를_포함하면_true를_반환한다() {
+
+        // given
+        Lotto lotto = new Lotto(List.of(1, 3, 5, 10, 20, 45));
+
+        // when & then
+        assertThat(lotto.containsNumber(10)).isTrue();
+        assertThat(lotto.containsNumber(7)).isFalse();
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideLottoMatchScenarios")
+    void 다른_로또와_일치하는_번호_개수를_계산할_수_있다(Lotto priorLotto, Lotto nextLotto, int expectedMatchCount) {
+
+        // when
+        int matchCount = priorLotto.countMatchingNumbers(nextLotto);
+
+        // then
+        assertThat(matchCount).isEqualTo(expectedMatchCount);
+    }
+
+    @Test
+    void 비교할_로또가_null이면_예외가_발생한다() {
+
+        // given
+        Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+        // when & then
+        assertThatThrownBy(() -> lotto.countMatchingNumbers(null))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 비교할 로또가 null일 수 없습니다.");
+    }
+
+    @Test
+    void 로또_번호_목록은_외부에서_수정할_수_없다() {
+
+        // given
+        Lotto lotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+
+        // when & then
+        assertThatThrownBy(() -> lotto.getNumbers().add(7))
+                .isInstanceOf(UnsupportedOperationException.class);
+    }
+
+    private static Stream<Arguments> provideLottoMatchScenarios() {
+        return Stream.of(
+                Arguments.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+                        new Lotto(List.of(4, 5, 6, 40, 41, 42)),
+                        3
+                ),
+                Arguments.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+                        new Lotto(List.of(7, 8, 9, 10, 11, 12)),
+                        0
+                ),
+                Arguments.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)),
+                        6
+                )
+        );
+    }
+}
diff --git a/src/test/java/lotto/domain/MoneyTest.java b/src/test/java/lotto/domain/MoneyTest.java
new file mode 100644
index 0000000000..f28728b1dc
--- /dev/null
+++ b/src/test/java/lotto/domain/MoneyTest.java
@@ -0,0 +1,53 @@
+package lotto.domain;
+
+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 MoneyTest {
+
+    private static final int UNIT_MONEY_FOR_BUY_LOTTO = 1000;
+
+    @ParameterizedTest
+    @ValueSource(ints = {1000, 5000, 1000000000})
+    void 로또_구매_금액이_천_원으로_나눠지면_Money_객체가_생성된다(int amount) {
+        // when
+        Money money = new Money(amount);
+
+        // then
+        assertThat(money).isNotNull();
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {500, 1100, 2500})
+    void 로또_구매_금액이_천_원으로_나눠지지_않으면_예외가_발생한다(int amount) {
+        // when & then
+        assertThatThrownBy(() -> new Money(amount))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 1,000원 단위로 입력해 주세요.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1000, -5000})
+    void 로또_구매_금액이_0원_이하면_예외가_발생한다(int amount) {
+        // when & then
+        assertThatThrownBy(() -> new Money(amount))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 구입 금액은 0보다 커야 합니다.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {1000, 3000, 100000})
+    void 로또_구매_금액을_입력하면_구매_가능한_로또_개수를_반환한다(int amount) {
+        // given
+        Money money = new Money(amount);
+
+        // when
+        int count = money.getLottoCount();
+
+        // then
+        assertThat(count).isEqualTo(amount / UNIT_MONEY_FOR_BUY_LOTTO);
+    }
+}
diff --git a/src/test/java/lotto/domain/RandomLottoGeneratorTest.java b/src/test/java/lotto/domain/RandomLottoGeneratorTest.java
new file mode 100644
index 0000000000..18d47aa941
--- /dev/null
+++ b/src/test/java/lotto/domain/RandomLottoGeneratorTest.java
@@ -0,0 +1,25 @@
+package lotto.domain;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class RandomLottoGeneratorTest {
+
+    @Test
+    void 로또_생성_요청_개수만큼_랜덤_로또를_생성한다() {
+
+        // given
+        LottoGenerator generator = new RandomLottoGenerator();
+        int count = 5;
+
+        // when
+        List<Lotto> lottos = generator.generate(count);
+
+        // then
+        assertThat(lottos).hasSize(count)
+                .doesNotContainNull();
+    }
+}
diff --git a/src/test/java/lotto/domain/WinningNumbersTest.java b/src/test/java/lotto/domain/WinningNumbersTest.java
new file mode 100644
index 0000000000..f802764dc6
--- /dev/null
+++ b/src/test/java/lotto/domain/WinningNumbersTest.java
@@ -0,0 +1,106 @@
+package lotto.domain;
+
+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.*;
+
+class WinningNumbersTest {
+
+    @ParameterizedTest
+    @ValueSource(ints = {1, 45})
+    void 보너스_번호가_정상_범위에서_극_값인_1과_45_값이_들어가도_예외가_발생하지_않는다(int validBonusNumber) {
+
+        // given
+        List<Integer> numbers = List.of(2, 3, 4, 5, 6, 7);
+
+        // when & then
+        assertThatNoException()
+                .isThrownBy(() -> new WinningNumbers(numbers, validBonusNumber));
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, 46})
+    void 보너스_번호가_정상_범위를_벗어난_1부터_45_사이의_값이_아니면_예외가_발생한다(int invalidBonusNumber) {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
+
+        // when & then
+        assertThatThrownBy(() -> new WinningNumbers(numbers, invalidBonusNumber))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 보너스 번호는 1부터 45 사이여야 합니다.");
+    }
+
+    @Test
+    void 보너스_번호가_당첨_번호와_중복되면_예외가_발생한다() {
+
+        // given
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
+
+        // when & then
+        assertThatThrownBy(() -> new WinningNumbers(numbers, 6))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+    }
+
+    @Test
+    void 당첨_번호_로또의_생성자_검증이_보너스_번호_검증보다_먼저_수행된다() {
+
+        // given
+        List<Integer> invalidNumbers = List.of(1, 2, 3, 4, 5, 5);
+
+        // when & then
+        assertThatThrownBy(() -> new WinningNumbers(invalidNumbers, 7))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 로또 번호는 중복될 수 없습니다.");
+    }
+
+    @Test
+    void 당첨_번호와_보너스_번호가_모두_유효하면_생성된다() {
+
+        // given
+        List<Integer> lottoNumbers = List.of(4, 36, 3, 28, 44, 11);
+        int bonusNumber = 7;
+
+        // when
+        WinningNumbers winningNumbers = new WinningNumbers(lottoNumbers, bonusNumber);
+
+        // then
+        assertThat(winningNumbers).isNotNull();
+        assertThat(winningNumbers.getBonusNumber()).isEqualTo(bonusNumber);
+
+        Lotto testLotto = new Lotto(lottoNumbers);
+        assertThat(winningNumbers.countMatchingNumbers(testLotto)).isEqualTo(6);
+    }
+
+    @Test
+    void 당첨_번호_로또와_비교할_로또의_값_일치_개수를_구할_수_있다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto lotto = new Lotto(List.of(1, 2, 10, 11, 12, 13));
+
+        // when
+        int matchCount = winningNumbers.countMatchingNumbers(lotto);
+
+        // then
+        assertThat(matchCount).isEqualTo(2);
+    }
+
+    @Test
+    void 보너스_번호를_포함하는지_확인할_수_있다() {
+
+        // given
+        WinningNumbers winningNumbers = new WinningNumbers(List.of(1, 2, 3, 4, 5, 6), 7);
+        Lotto containsBonus = new Lotto(List.of(7, 10, 20, 30, 40, 45));
+        Lotto notContainsBonus = new Lotto(List.of(8, 10, 20, 30, 40, 45));
+
+        // when & then
+        assertThat(winningNumbers.containsBonusNumber(containsBonus)).isTrue();
+        assertThat(winningNumbers.containsBonusNumber(notContainsBonus)).isFalse();
+    }
+}
diff --git a/src/test/java/lotto/domain/testDouble/FakeLottoGenerator.java b/src/test/java/lotto/domain/testDouble/FakeLottoGenerator.java
new file mode 100644
index 0000000000..012f2aed3c
--- /dev/null
+++ b/src/test/java/lotto/domain/testDouble/FakeLottoGenerator.java
@@ -0,0 +1,31 @@
+package lotto.domain.testDouble;
+
+import lotto.domain.Lotto;
+import lotto.domain.LottoGenerator;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class FakeLottoGenerator implements LottoGenerator {
+
+    private final Iterator<List<Integer>> numbersIterator;
+
+    public FakeLottoGenerator(List<List<Integer>> numbersSequences) {
+        this.numbersIterator = numbersSequences.iterator();
+    }
+
+    @Override
+    public List<Lotto> generate(int count) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            List<Integer> numbers = numbersIterator.next();
+            lottos.add(new Lotto(numbers));
+        }
+        return lottos;
+    }
+
+    public static FakeLottoGenerator of(List<Integer> numbers) {
+        return new FakeLottoGenerator(List.of(numbers));
+    }
+}
diff --git a/src/test/java/lotto/view/InputValidatorTest.java b/src/test/java/lotto/view/InputValidatorTest.java
new file mode 100644
index 0000000000..e6da7d9c90
--- /dev/null
+++ b/src/test/java/lotto/view/InputValidatorTest.java
@@ -0,0 +1,132 @@
+package lotto.view;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullSource;
+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 InputValidatorTest {
+
+    @Test
+    void 구입_금액_문자열을_정수로_파싱한다() {
+
+        // given
+        String input = "3000";
+
+        // when
+        int amount = InputValidator.parsePurchaseAmount(input);
+
+        // then
+        assertThat(amount).isEqualTo(3000);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    @ValueSource(strings = {"", " ", "   "})
+    void 구입_금액_입력이_null_또는_공백이면_예외가_발생한다(String input) {
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parsePurchaseAmount(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 입력은 비어 있을 수 없습니다.");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"abc", "1000원", "1 000", "1,000"})
+    void 구입_금액에_숫자가_아닌_값이_포함되면_예외가_발생한다(String input) {
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parsePurchaseAmount(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 구입 금액은 숫자여야 합니다.");
+    }
+
+    @Test
+    void 쉼표로_구분된_당첨_번호를_정수_리스트로_파싱한다() {
+
+        // given
+        String input = "1,2,3,4,5,6";
+
+        // when
+        List<Integer> numbers = InputValidator.parseWinningNumbers(input);
+
+        // then
+        assertThat(numbers).containsExactly(1, 2, 3, 4, 5, 6);
+    }
+
+    @Test
+    void 당첨_번호_파싱시_공백을_무시한다() {
+
+        // given
+        String input = " 1,  2 ,3 , 4,5 ,6 ";
+
+        // when
+        List<Integer> numbers = InputValidator.parseWinningNumbers(input);
+
+        // then
+        assertThat(numbers).containsExactly(1, 2, 3, 4, 5, 6);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    @ValueSource(strings = {"", " ", "   "})
+    void 당첨_번호_입력이_null_또는_공백이면_예외가_발생한다(String input) {
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parseWinningNumbers(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 입력은 비어 있을 수 없습니다.");
+    }
+
+    @Test
+    void 당첨_번호에_숫자가_아닌_값이_포함되면_예외가_발생한다() {
+
+        // given
+        String input = "1, 2, 세, 4, 5, 6";
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parseWinningNumbers(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 당첨 번호는 숫자여야 합니다.");
+    }
+
+    @Test
+    void 보너스_번호_문자열을_정수로_파싱한다() {
+
+        // given
+        String input = "7";
+
+        // when
+        int bonus = InputValidator.parseBonusNumber(input);
+
+        // then
+        assertThat(bonus).isEqualTo(7);
+    }
+
+    @ParameterizedTest
+    @NullSource
+    @ValueSource(strings = {"", " ", "   "})
+    void 보너스_번호_입력이_null_또는_공백이면_예외가_발생한다(String input) {
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parseBonusNumber(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 입력은 비어 있을 수 없습니다.");
+    }
+
+    @Test
+    void 보너스_번호에_숫자가_아닌_값이_들어오면_예외가_발생한다() {
+        // given
+        String input = "보너스";
+
+        // when & then
+        assertThatThrownBy(() -> InputValidator.parseBonusNumber(input))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessage("[ERROR] 보너스 번호는 숫자여야 합니다.");
+    }
+}