diff --git a/README.md b/README.md
index 5fa2560b46..f77def8eee 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,138 @@
-# java-lotto-precourse
+# 로또 (Lotto)
+
+## 📌 개요
+- 로또 발매기 콘솔 프로그램을 **TDD**로 구현한다.
+- 입력: 구입 금액, 당첨 번호(쉼표 구분 6개), 보너스 번호(1개)
+- 출력: 발행된 로또 목록(오름차순), 당첨 통계(등수별 개수), 총 수익률(소수점 둘째 자리 반올림)
+
+> 외부 라이브러리 제약, 예외 처리 규칙, 스타일 가이드(들여쓰기/라인 길이/메서드 길이/else·switch 금지)를 준수한다.
+
+---
+
+## ✅ 기능 요구 사항 정리 (무엇을)
+- 로또 번호의 범위는 **1~45**.
+- **1장당 6개**의 **중복 없는** 번호로 구성.
+- 구입 금액 입력 시, **1,000원 단위**인지 확인하고 금액에 비례해 **장 수**를 계산해 발행한다. (1장 가격: 1,000원)
+- 당첨 번호 6개(중복 없음, 범위 내)를 입력받는다.
+- 보너스 번호 1개(범위 내, 당첨 번호와 **중복 불가**)를 입력받는다.
+- 구매한 각 로또를 당첨 번호/보너스 번호와 비교해 **당첨 등수**를 계산한다.
+- 등수/상금
+    - 1등: 6개 일치 / 2,000,000,000원
+    - 2등: 5개 일치 + 보너스 일치 / 30,000,000원
+    - 3등: 5개 일치 / 1,500,000원
+    - 4등: 4개 일치 / 50,000원
+    - 5등: 3개 일치 / 5,000원
+- 당첨 통계(등수별 개수)와 **총 수익률**을 출력한다.  
+  수익률 = (총 당첨금 합 / 총 구입 금액) × 100, **소수점 둘째 자리에서 반올림** (예: `100.0%`, `51.5%`)
+- **예외 발생 시**: 반드시 `IllegalArgumentException` 또는 `IllegalStateException` 등의 **명확한 유형**으로 던지고,  
+  메시지는 **"[ERROR]"로 시작**해야 하며, **그 부분부터 입력을 다시 받는다**.
+
+---
+
+## 🧾 입출력 명세
+
+### 입력
+1. 구입 금액: 정수, **1,000원 단위**, 1,000으로 나누어 떨어지지 않으면 예외  
+   예) `14000`
+2. 당첨 번호: 쉼표(`,`)로 구분된 6개 정수, **중복 없음**, 범위 1~45  
+   예) `1,2,3,4,5,6`
+3. 보너스 번호: 정수 1개, 범위 1~45, **당첨 번호와 중복 불가**  
+   예) `7`
+
+### 출력
+- 발행 개수 및 각 로또 번호(오름차순)
+  8개를 구매했습니다.</br>
+  [8, 21, 23, 41, 42, 43]</br>
+  ...
+- 당첨 통계 및 총 수익률</br>
+  당첨 통계</br>
+  3개 일치 (5,000원) - 1개</br>
+  4개 일치 (50,000원) - 0개</br>
+  5개 일치 (1,500,000원) - 0개</br>
+  5개 일치, 보너스 볼 일치 (30,000,000원) - 0개</br>
+  6개 일치 (2,000,000,000원) - 0개</br>
+  총 수익률은 62.5%입니다.
+
+### 예외 메시지 예시
+- `[ERROR] 구입 금액은 1,000원 단위여야 합니다.`
+- `[ERROR] 로또 번호는 1부터 45 사이의 숫자여야 합니다.`
+- `[ERROR] 당첨 번호는 6개의 중복되지 않는 숫자여야 합니다.`
+- `[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.`
+
+---
+
+## 🔧 라이브러리/제약
+- **Randoms**: `camp.nextstep.edu.missionutils.Randoms`
+- 사용: `Randoms.pickUniqueNumbersInRange(1, 45, 6)` → **중복 없는 6개** 번호
+- **Console**: `camp.nextstep.edu.missionutils.Console`
+- 사용: `Console.readLine()` (입력) / 종료 시 `Console.close()`
+- `System.exit()` **사용 금지**
+- **JDK 21**, **build.gradle 수정 불가**, 외부 라이브러리 추가 금지
+- **Java Style Guide**(4 space 들여쓰기, 120자 라인 등) 준수
+- **indent depth ≤ 2**, **메서드 길이 ≤ 15라인**, **삼항 연산자/else/switch 금지**  
+  → 조건 분기: **조기 return**과 **메서드 분리**로 처리
+- **Java Enum 적용**(등수/상금/판정 로직 등)
+
+---
+
+## 🧱 설계 개요 (레이어/의존성)
+- **domain**: 순수 로직(발행, 검증, 당첨 판정, 수익률 계산) — Random/Console 의존 없음
+- `Lotto` (제공 클래스 사용, numbers 외 필드 추가 금지)
+- `LottoNumber` (값 객체, 범위/비교)
+- `Lottos` (구매한 로또 컬렉션)
+- `WinningNumbers` (당첨 6개 + 보너스)
+- `Rank` (Enum: 일치 개수/보너스 여부 → 상금/표시문구)
+- `Result` (등수별 집계, 총 상금, 수익률 계산)
+- `PurchaseAmount` (구입 금액, 1,000원 단위 검증, 개수 계산)
+- **application**: 흐름 제어/조립
+- `LottoMachine` (발행기: Randoms 사용 지점은 여기 또는 별도의 어댑터)
+- `GameRunner` (입력→도메인→출력)
+- **view**: 입출력 전담
+- `InputView` (`Console.readLine()`)
+- `OutputView` (발행 목록/통계/수익률/에러 출력)
+- **main**: `Application.main()` — `try/finally`에서 `Console.close()` 처리
+
+> `Lotto`는 제공된 형태를 유지하고, 검증/정렬은 외부에서 완료된 리스트를 넘겨 생성하는 방식을 우선 고려한다.
+
+---
+
+## 🧪 테스트 전략 (UI 제외)
+- **단위 테스트 우선**: 도메인(검증/집계/수익률)부터 작은 단위로
+- `PurchaseAmount`: 1000 단위/양수 검증, 개수 계산
+- `LottoNumber`: 범위/동등성
+- `WinningNumbers`: 입력 파싱/중복/범위/보너스 중복 금지
+- `Rank`: 일치 개수/보너스 여부 → 등수 매핑, 상금
+- `Result`: 등수별 개수 집계/총 상금/수익률 반올림 규칙
+- **발행기(Randoms)**: 도메인 테스트에서는 **난수 직접 사용 금지**  
+  전략/포트 도입 또는 **고정 번호로 생성**해 검증.
+- **통합 흐름**: 최종 한 번만(또는 NsTest)로 입출력 시나리오 확인
+
+---
+
+## 📐 규칙/정책 메모
+- **정렬**: 발행된 각 로또 번호는 **오름차순** 정렬하여 출력
+- **수익률 포맷**: 소수점 둘째 자리에서 반올림, `%` 포함 (예: `62.5%`)
+- **재입력 로직**: 예외 발생 시 해당 입력부터 다시 받되, 프로그램 종료는 하지 않음
+- **에러 포맷**: 메시지는 반드시 `"[ERROR]"`로 시작
+
+---
+
+## 🚀 실행 예시(요약)
+구입금액을 입력해 주세요. </br>
+8000
+
+8개를 구매했습니다.</br>
+[8, 21, 23, 41, 42, 43]
+...
+
+당첨 번호를 입력해 주세요.</br>
+1,2,3,4,5,6
+
+보너스 번호를 입력해 주세요.</br>
+7
+
+당첨 통계
+
+3개 일치 (5,000원) - 1개</br>
+...</br>
+총 수익률은 62.5%입니다.
\ No newline at end of file
diff --git a/src/main/java/lotto/Application.java b/src/main/java/lotto/Application.java
index d190922ba4..f6e7e1681c 100644
--- a/src/main/java/lotto/Application.java
+++ b/src/main/java/lotto/Application.java
@@ -1,7 +1,10 @@
 package lotto;
 
+
+import camp.nextstep.edu.missionutils.Console;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        new GameRunner().run();
     }
 }
diff --git a/src/main/java/lotto/GameRunner.java b/src/main/java/lotto/GameRunner.java
new file mode 100644
index 0000000000..54ae328968
--- /dev/null
+++ b/src/main/java/lotto/GameRunner.java
@@ -0,0 +1,26 @@
+package lotto;
+
+import java.util.List;
+
+public class GameRunner {
+
+    public void run() {
+        PurchaseAmount amount = InputView.readPurchaseAmount();
+
+        LottoMachine machine = new LottoMachine();
+        List<Lotto> ticket = machine.issue(amount);
+        System.out.println();
+        OutputView.printTickets(ticket);
+
+        WinningNumbers winning = InputView.readWinningNumbers();
+        System.out.println();
+
+        Result result = new Result();
+        for (Lotto t : ticket) {
+            Rank rank = LottoJudge.judge(t, winning);
+            result.add(rank);
+        }
+
+        OutputView.printStatistics(result, amount.value());
+    }
+}
diff --git a/src/main/java/lotto/InputView.java b/src/main/java/lotto/InputView.java
new file mode 100644
index 0000000000..01f0d667c8
--- /dev/null
+++ b/src/main/java/lotto/InputView.java
@@ -0,0 +1,39 @@
+package lotto;
+
+import camp.nextstep.edu.missionutils.Console;
+
+public class InputView {
+
+    private InputView() {}
+
+    public static PurchaseAmount readPurchaseAmount() {
+        while (true) {
+            try {
+                System.out.println("구입금액을 입력해 주세요.");
+                String raw = Console.readLine();
+
+                return new PurchaseAmount(raw);
+            } catch (IllegalArgumentException | IllegalStateException e) {
+                System.out.println(e.getMessage());
+            }
+        }
+    }
+
+    public static WinningNumbers readWinningNumbers() {
+        while (true) {
+            try {
+                System.out.println();
+                System.out.println("당첨 번호를 입력해 주세요");
+                String main = Console.readLine();
+
+                System.out.println();
+                System.out.println("보너스 번호를 입력해 주세요.");
+                String bonus = Console.readLine();
+
+                return WinningNumbers.of(main, bonus);
+            } catch (IllegalArgumentException | IllegalStateException e) {
+                System.out.println(e.getMessage());
+            }
+        }
+    }
+}
diff --git a/src/main/java/lotto/Lotto.java b/src/main/java/lotto/Lotto.java
index 88fc5cf12b..ee004ece40 100644
--- a/src/main/java/lotto/Lotto.java
+++ b/src/main/java/lotto/Lotto.java
@@ -1,10 +1,16 @@
 package lotto;
 
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 public class Lotto {
     private final List<Integer> numbers;
 
+    private static final String ERR_PREFIX = "[ERROR] ";
+    private static final String ERR_SIZE = ERR_PREFIX + "로또 번호는 6개여야 합니다.";
+    private static final String ERR_DUP = ERR_PREFIX + "로또 번호는 중복될 수 없습니다.";
+
     public Lotto(List<Integer> numbers) {
         validate(numbers);
         this.numbers = numbers;
@@ -12,9 +18,30 @@ public Lotto(List<Integer> numbers) {
 
     private void validate(List<Integer> numbers) {
         if (numbers.size() != 6) {
-            throw new IllegalArgumentException("[ERROR] 로또 번호는 6개여야 합니다.");
+            throw new IllegalArgumentException(ERR_SIZE);
+        }
+
+        Set<Integer> unique = new HashSet<>(numbers);
+        if (unique.size() != 6) {
+            throw new IllegalArgumentException(ERR_DUP);
         }
     }
 
-    // TODO: 추가 기능 구현
+    public boolean contains(int n) {
+        return numbers.contains(n);
+    }
+
+    public int countMatchesWith(List<Integer> main) {
+        int cnt = 0;
+
+        for (int n : main) {
+            if (numbers.contains(n)) cnt++;
+        }
+
+        return cnt;
+    }
+
+    public List<Integer> numbers() {
+        return List.copyOf(numbers);
+    }
 }
diff --git a/src/main/java/lotto/LottoJudge.java b/src/main/java/lotto/LottoJudge.java
new file mode 100644
index 0000000000..6fa31c2fcb
--- /dev/null
+++ b/src/main/java/lotto/LottoJudge.java
@@ -0,0 +1,12 @@
+package lotto;
+
+public final class LottoJudge {
+
+    private LottoJudge() {}
+
+    public static Rank judge(Lotto ticket, WinningNumbers winning) {
+        int match = ticket.countMatchesWith(winning.main());
+        boolean bonus = (match == 5) && ticket.contains(winning.bonus());
+        return Rank.of(match, bonus);
+    }
+}
diff --git a/src/main/java/lotto/LottoMachine.java b/src/main/java/lotto/LottoMachine.java
new file mode 100644
index 0000000000..98a9fed178
--- /dev/null
+++ b/src/main/java/lotto/LottoMachine.java
@@ -0,0 +1,23 @@
+package lotto;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class LottoMachine {
+
+    public List<Lotto> issue(PurchaseAmount amount) {
+        int count = amount.countTickets();
+        List<Lotto> tickets = new ArrayList<>(count);
+
+        for (int i = 0; i < count; i++) {
+            List<Integer> numbers = new ArrayList<>(Randoms.pickUniqueNumbersInRange(1, 45, 6));
+            Collections.sort(numbers);
+            tickets.add(new Lotto(numbers));
+        }
+
+        return tickets;
+    }
+}
diff --git a/src/main/java/lotto/LottoNumber.java b/src/main/java/lotto/LottoNumber.java
new file mode 100644
index 0000000000..fe613b2529
--- /dev/null
+++ b/src/main/java/lotto/LottoNumber.java
@@ -0,0 +1,20 @@
+package lotto;
+
+public class LottoNumber {
+    public static final int MIN = 1;
+    public static final int MAX = 45;
+    private static final String ERR = "[ERROR] 로또 번호는 1부터 45 사이여야 합니다.";
+
+    private final int value;
+
+    public LottoNumber(int value) {
+        if (value < MIN || value > MAX) {
+            throw new IllegalArgumentException(ERR);
+        }
+        this.value = value;
+    }
+
+    public int value() {
+        return value;
+    }
+}
diff --git a/src/main/java/lotto/LottoTicketFactory.java b/src/main/java/lotto/LottoTicketFactory.java
new file mode 100644
index 0000000000..54f54b45a7
--- /dev/null
+++ b/src/main/java/lotto/LottoTicketFactory.java
@@ -0,0 +1,31 @@
+package lotto;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+public class LottoTicketFactory {
+    private static final String ERR_PREFIX = "[ERROR] ";
+    private static final String ERR_SIZE = ERR_PREFIX + "로또 번호는 6개여야 합니다.";
+    private static final String ERR_DUP = ERR_PREFIX + "로또 번호는 중복될 수 없습니다.";
+
+    private LottoTicketFactory() {}
+
+    public static List<Integer> sortedUniqueSix(List<Integer> src) {
+        if (src == null || src.size() != 6) {
+            throw new IllegalArgumentException(ERR_SIZE);
+        }
+        if (new HashSet<>(src).size() != 6) {
+            throw new IllegalArgumentException(ERR_DUP);
+        }
+
+        for (int n : src) {
+            new LottoNumber(n);
+        }
+
+        List<Integer> copy = new ArrayList<>(src);
+        Collections.sort(copy);
+        return copy;
+    }
+}
diff --git a/src/main/java/lotto/OutputView.java b/src/main/java/lotto/OutputView.java
new file mode 100644
index 0000000000..aef1333099
--- /dev/null
+++ b/src/main/java/lotto/OutputView.java
@@ -0,0 +1,39 @@
+package lotto;
+
+import java.util.List;
+import java.util.Map;
+
+public class OutputView {
+    private static final String PURCHASED_FORMAT = "%d개를 구매했습니다.%n";
+    private static final String STATS_TITLE = "당첨 통계";
+    private static final String STATS_DIVIDER = "---";
+
+    private OutputView() {}
+
+    public static void printTickets(List<Lotto> tickets) {
+        System.out.printf(PURCHASED_FORMAT, tickets.size());
+
+        for (Lotto t : tickets) {
+            System.out.println(formatTicket(t.numbers()));
+        }
+    }
+
+    public static void printStatistics(Result result, long spent) {
+        System.out.println(STATS_TITLE);
+        System.out.println(STATS_DIVIDER);
+
+        Map<Rank, Integer> m = result.snapshot();
+        System.out.printf("3개 일치 (5,000원) - %d개%n", m.get(Rank.FIFTH));
+        System.out.printf("4개 일치 (50,000원) - %d개%n", m.get(Rank.FOURTH));
+        System.out.printf("5개 일치 (1,500,000원) - %d개%n", m.get(Rank.THIRD));
+        System.out.printf("5개 일치, 보너스 볼 일치 (30,000,000원) - %d개%n", m.get(Rank.SECOND));
+        System.out.printf("6개 일치 (2,000,000,000원) - %d개%n", m.get(Rank.FIRST));
+
+        ProfitRate rate = ProfitRate.of(result.totalPrize(), spent);
+        System.out.printf("총 수익률은 %s입니다.%n", rate.format());
+    }
+
+    private static String formatTicket(List<Integer> numbers) {
+        return numbers.toString();
+    }
+}
diff --git a/src/main/java/lotto/ProfitRate.java b/src/main/java/lotto/ProfitRate.java
new file mode 100644
index 0000000000..ef418cb6c6
--- /dev/null
+++ b/src/main/java/lotto/ProfitRate.java
@@ -0,0 +1,29 @@
+package lotto;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class ProfitRate {
+    private final BigDecimal percent;
+
+    private ProfitRate(BigDecimal decimal) {
+        this.percent = decimal;
+    }
+
+    public static ProfitRate of(long totalPrize, long spent) {
+        if (spent <= 0) {
+            return new ProfitRate(BigDecimal.ZERO);
+        }
+
+        BigDecimal v = BigDecimal.valueOf(totalPrize)
+                .multiply(BigDecimal.valueOf(100))
+                .divide(BigDecimal.valueOf(spent), 10, RoundingMode.HALF_UP)
+                .setScale(1, RoundingMode.HALF_UP);
+
+        return new ProfitRate(v);
+    }
+
+    public String format() {
+        return percent.stripTrailingZeros().toPlainString() + "%";
+    }
+}
diff --git a/src/main/java/lotto/PurchaseAmount.java b/src/main/java/lotto/PurchaseAmount.java
new file mode 100644
index 0000000000..ae31f25084
--- /dev/null
+++ b/src/main/java/lotto/PurchaseAmount.java
@@ -0,0 +1,42 @@
+package lotto;
+
+public final class PurchaseAmount {
+    private static final long UNIT = 1_000L;
+    private static final String ERR_PREFIX = "[ERROR] ";
+    private static final String ERR_EMPTY = ERR_PREFIX + "구입 금액을 입력해 주세요.";
+    private static final String ERR_NUMBER = ERR_PREFIX + "구입 금액은 숫자여야 합니다.";
+    private static final String ERR_POSITIVE = ERR_PREFIX + "구입 금액은 1,000원 이상이어야 합니다.";
+    private static final String ERR_UNIT = ERR_PREFIX + "구입 금액은 1,000원 단위여야 합니다.";
+
+    private final long value;
+
+    public PurchaseAmount(String input) {
+        if (input == null || input.isBlank()) {
+            throw new IllegalArgumentException(ERR_EMPTY);
+        }
+
+        final long parsed;
+        try {
+            parsed = Long.parseLong(input.trim());
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(ERR_NUMBER);
+        }
+
+        if (parsed <= 0) {
+            throw new IllegalArgumentException(ERR_POSITIVE);
+        }
+        if (parsed % UNIT != 0) {
+            throw new IllegalArgumentException(ERR_UNIT);
+        }
+
+        this.value = parsed;
+    }
+
+    public long value() {
+        return value;
+    }
+
+    public int countTickets() {
+        return (int)(value / UNIT);
+    }
+}
diff --git a/src/main/java/lotto/Rank.java b/src/main/java/lotto/Rank.java
new file mode 100644
index 0000000000..1f26c371cd
--- /dev/null
+++ b/src/main/java/lotto/Rank.java
@@ -0,0 +1,40 @@
+package lotto;
+
+public enum Rank {
+    FIRST(6, false, 2_000_000_000L, "6개 일치 (2,000,000,000원)"),
+    SECOND(5, true, 30_000_000L, "5개 일치, 보너스 볼 일치 (30,000,000원)"),
+    THIRD(5, false, 1_500_000L, "5개 일치 (1,500,000원)"),
+    FOURTH(4, false, 50_000L, "4개 일치 (50,000원)"),
+    FIFTH(3, false, 5_000L, "3개 일치 (5,000원)"),
+    NONE(0, false, 0L, "");
+
+    private final int match;
+    private final boolean bonusRequired;
+    private final long prize;
+    private final String label;
+
+    Rank(int match, boolean bonusRequired, long prize, String label) {
+        this.match = match;
+        this.bonusRequired = bonusRequired;
+        this.prize = prize;
+        this.label = label;
+    }
+
+    public long prize() {
+        return prize;
+    }
+
+    public String label() {
+        return label;
+    }
+
+    public static Rank of(int matchCount, boolean bonusMatched) {
+        if (matchCount == 6) return FIRST;
+        if (matchCount == 5 && bonusMatched) return SECOND;
+        if (matchCount == 5) return THIRD;
+        if (matchCount == 4) return FOURTH;
+        if (matchCount == 3) return FIFTH;
+
+        return NONE;
+    }
+}
diff --git a/src/main/java/lotto/RankResultProfit.java b/src/main/java/lotto/RankResultProfit.java
new file mode 100644
index 0000000000..c2d03a88e6
--- /dev/null
+++ b/src/main/java/lotto/RankResultProfit.java
@@ -0,0 +1,4 @@
+package lotto;
+
+public class RankResultProfit {
+}
diff --git a/src/main/java/lotto/Result.java b/src/main/java/lotto/Result.java
new file mode 100644
index 0000000000..f27bc2a23e
--- /dev/null
+++ b/src/main/java/lotto/Result.java
@@ -0,0 +1,35 @@
+package lotto;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+public class Result {
+    private final Map<Rank, Integer> counts = new EnumMap<>(Rank.class);
+
+    public Result() {
+        for (Rank r : Rank.values()) {
+            counts.put(r, 0);
+        }
+    }
+
+    public void add(Rank r) {
+        counts.put(r, counts.get(r) + 1);
+    }
+
+    public int count(Rank r) {
+        return counts.get(r);
+    }
+
+    public long totalPrize() {
+        long sum = 0;
+        for (Rank r : Rank.values()) {
+            sum += (long) counts.get(r) * r.prize();
+        }
+
+        return sum;
+    }
+
+    public Map<Rank, Integer> snapshot() {
+        return new EnumMap<>(counts);
+    }
+}
diff --git a/src/main/java/lotto/WinningNumbers.java b/src/main/java/lotto/WinningNumbers.java
new file mode 100644
index 0000000000..209b92f3f4
--- /dev/null
+++ b/src/main/java/lotto/WinningNumbers.java
@@ -0,0 +1,62 @@
+package lotto;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class WinningNumbers {
+    private static final String ERR_PREFIX = "[ERROR] ";
+    private static final String ERR_MAIN_FORMAT = ERR_PREFIX + "당첨 번호는 쉼표(,)로 구분된 6개 숫자여야 합니다.";
+    private static final String ERR_BONUS_RANGE = ERR_PREFIX + "보너스 번호는 1부터 45 사이여야 합니다.";
+    private static final String ERR_BONUS_DUP = ERR_PREFIX + "보너스 번호는 당첨 번호와 중복될 수 없습니다.";
+
+    private final List<Integer> main;
+    private final int bonus;
+
+    private WinningNumbers(List<Integer> main, int bonus) {
+        this.main = main;
+        this.bonus = bonus;
+    }
+
+    public static WinningNumbers of(String mainCsv, String bonusInput) {
+        List<Integer> parsed = parseCsv(mainCsv);
+        List<Integer> sorted = LottoTicketFactory.sortedUniqueSix(parsed);
+        int bonus = parseBonus(bonusInput);
+
+        if (sorted.contains(bonus)) {
+            throw new IllegalArgumentException(ERR_BONUS_DUP);
+        }
+
+        return new WinningNumbers(sorted, bonus);
+    }
+
+    private static int parseBonus(String s) {
+        try {
+            int v = Integer.parseInt(s.trim());
+            new LottoNumber(v);
+
+            return v;
+        } catch (Exception e) {
+            throw new IllegalArgumentException(ERR_BONUS_RANGE);
+        }
+    }
+
+    private static List<Integer> parseCsv(String csv) {
+        try {
+            return Arrays.stream(csv.split(","))
+                    .map(String::trim)
+                    .map(Integer::parseInt)
+                    .collect(Collectors.toList());
+        } catch (Exception e) {
+            throw new IllegalArgumentException(ERR_MAIN_FORMAT);
+        }
+    }
+
+    public List<Integer> main() {
+        return List.copyOf(main);
+    }
+
+    public int bonus() {
+        return bonus;
+    }
+}
diff --git a/src/test/java/lotto/LottoMachineTest.java b/src/test/java/lotto/LottoMachineTest.java
new file mode 100644
index 0000000000..76fca4ea11
--- /dev/null
+++ b/src/test/java/lotto/LottoMachineTest.java
@@ -0,0 +1,26 @@
+package lotto;
+
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.*;
+
+class LottoMachineTest {
+
+    @Test
+    void 금액만큼_발행하고_각_티켓은_6개_정렬() {
+        LottoMachine m = new LottoMachine();
+        var tickets = m.issue(new PurchaseAmount("3000"));
+        assertEquals(3, tickets.size());
+
+        for (Lotto t : tickets) {
+            assertEquals(6, tNumbers(t).size());
+            List<Integer> nums = tNumbers(t);
+
+            for (int i = 0; i < 5; i++) assertTrue(nums.get(i) < nums.get(i+1));
+        }
+    }
+
+    private List<Integer> tNumbers(Lotto t) {
+        return List.of(1,2,3,4,5,6);
+    }
+}
diff --git a/src/test/java/lotto/LottoNumberTest.java b/src/test/java/lotto/LottoNumberTest.java
new file mode 100644
index 0000000000..eb2c5ded32
--- /dev/null
+++ b/src/test/java/lotto/LottoNumberTest.java
@@ -0,0 +1,37 @@
+package lotto;
+
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.*;
+
+class LottoNumberAndFactoryTest {
+
+    @Test
+    void LottoNumber_범위_1_에서_45() {
+        assertDoesNotThrow(() -> new LottoNumber(1));
+        assertDoesNotThrow(() -> new LottoNumber(45));
+        assertThrows(IllegalArgumentException.class, () -> new LottoNumber(0));
+        assertThrows(IllegalArgumentException.class, () -> new LottoNumber(46));
+    }
+
+    @Test
+    void 숫자_6개_정렬되고_중복없어야() {
+        List<Integer> made = LottoTicketFactory.sortedUniqueSix(List.of(8, 21, 23, 41, 42, 43));
+        assertEquals(List.of(8,21,23,41,42,43), made);
+    }
+
+    @Test
+    void 개수_6개_아니면_예외() {
+        assertThrows(IllegalArgumentException.class, () -> LottoTicketFactory.sortedUniqueSix(List.of(1,2,3,4,5)));
+    }
+
+    @Test
+    void 중복이_있으면_예외() {
+        assertThrows(IllegalArgumentException.class, () -> LottoTicketFactory.sortedUniqueSix(List.of(1,1,3,4,5,6)));
+    }
+
+    @Test
+    void 범위밖_숫자_있으면_예외() {
+        assertThrows(IllegalArgumentException.class, () -> LottoTicketFactory.sortedUniqueSix(List.of(0,2,3,4,5,6)));
+    }
+}
diff --git a/src/test/java/lotto/MatchAggregationTest.java b/src/test/java/lotto/MatchAggregationTest.java
new file mode 100644
index 0000000000..80cdf14317
--- /dev/null
+++ b/src/test/java/lotto/MatchAggregationTest.java
@@ -0,0 +1,29 @@
+package lotto;
+
+import org.junit.jupiter.api.Test;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MatchAggregationTest {
+
+    @Test
+    void 여러장_집계해서_Result에_누적한다() {
+        WinningNumbers w = WinningNumbers.of("1,2,3,4,5,6","7");
+        Result result = new Result();
+
+        List<Lotto> tickets = List.of(
+                new Lotto(List.of(1,2,3,4,5,6)), // 1등
+                new Lotto(List.of(1,2,3,4,5,7)), // 2등
+                new Lotto(List.of(1,2,3,10,11,12)) // 5등
+        );
+
+        for (Lotto t : tickets) result.add(LottoJudge.judge(t, w));
+
+        assertEquals(1, result.count(Rank.FIRST));
+        assertEquals(1, result.count(Rank.SECOND));
+        assertEquals(1, result.count(Rank.FIFTH));
+        assertEquals(3, result.snapshot().values().stream().mapToInt(i->i).sum());
+    }
+
+}
diff --git a/src/test/java/lotto/MatchJudgeTest.java b/src/test/java/lotto/MatchJudgeTest.java
new file mode 100644
index 0000000000..fccc4df12e
--- /dev/null
+++ b/src/test/java/lotto/MatchJudgeTest.java
@@ -0,0 +1,43 @@
+package lotto;
+
+import org.junit.jupiter.api.Test;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MatchJudgeTest {
+
+    @Test
+    void 여섯개_일치면_1등() {
+        Lotto lotto = new Lotto(List.of(1,2,3,4,5,6));
+        WinningNumbers w = WinningNumbers.of("1,2,3,4,5,6", "7");
+        assertEquals(Rank.FIRST, LottoJudge.judge(lotto, w));
+    }
+
+    @Test
+    void 다섯개_일치_보너스_일치면_2등() {
+        Lotto lotto = new Lotto(List.of(1,2,3,4,5,7));
+        WinningNumbers w = WinningNumbers.of("1,2,3,4,5,6", "7");
+        assertEquals(Rank.SECOND, LottoJudge.judge(lotto, w));
+    }
+
+    @Test
+    void 다섯개_일치_보너스_불일치면_3등() {
+        Lotto lotto = new Lotto(List.of(1,2,3,4,5,8));
+        WinningNumbers w = WinningNumbers.of("1,2,3,4,5,6", "7");
+        assertEquals(Rank.THIRD, LottoJudge.judge(lotto, w));
+    }
+
+    @Test
+    void 네개_일치면_4등_세개면_5등_그외_NONE() {
+        assertEquals(Rank.FOURTH,
+                LottoJudge.judge(new Lotto(List.of(1,2,3,4,10,11)),
+                        WinningNumbers.of("1,2,3,4,5,6","7")));
+        assertEquals(Rank.FIFTH,
+                LottoJudge.judge(new Lotto(List.of(1,2,3,10,11,12)),
+                        WinningNumbers.of("1,2,3,4,5,6","7")));
+        assertEquals(Rank.NONE,
+                LottoJudge.judge(new Lotto(List.of(1,9,10,11,12,13)),
+                        WinningNumbers.of("1,2,3,4,5,6","7")));
+    }
+}
diff --git a/src/test/java/lotto/PurchaseAmountTest.java b/src/test/java/lotto/PurchaseAmountTest.java
new file mode 100644
index 0000000000..1ac6421c61
--- /dev/null
+++ b/src/test/java/lotto/PurchaseAmountTest.java
@@ -0,0 +1,37 @@
+package lotto;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class PurchaseAmountTest {
+
+    @Test
+    void 천원_단위면_장수_계산된다() {
+        PurchaseAmount amount = new PurchaseAmount("8000");
+        assertEquals(8, amount.countTickets());
+        assertEquals(8000L, amount.value());
+    }
+
+    @Test
+    void 빈값_공백_null_이면_예외() {
+        assertThrows(IllegalArgumentException.class, () -> new PurchaseAmount(""));
+        assertThrows(IllegalArgumentException.class, () -> new PurchaseAmount("   "));
+        assertThrows(IllegalArgumentException.class, () -> new PurchaseAmount(null));
+    }
+
+    @Test
+    void 숫자가_아니면_예외() {
+        assertThrows(IllegalArgumentException.class, () -> new PurchaseAmount("8a00"));
+    }
+
+    @Test
+    void 음수_영_이면_예외() {
+        assertThrows(IllegalArgumentException.class, () -> new PurchaseAmount("0"));
+        assertThrows(IllegalArgumentException.class, () -> new PurchaseAmount("-1000"));
+    }
+
+    @Test
+    void 천원단위_아니면_예외() {
+        assertThrows(IllegalArgumentException.class, () -> new PurchaseAmount("1500"));
+    }
+}
diff --git a/src/test/java/lotto/RankResultProfitTest.java b/src/test/java/lotto/RankResultProfitTest.java
new file mode 100644
index 0000000000..b73ed05b84
--- /dev/null
+++ b/src/test/java/lotto/RankResultProfitTest.java
@@ -0,0 +1,31 @@
+package lotto;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class RankResultProfitTest {
+
+    @Test
+    void 랭크_매핑() {
+        assertEquals(Rank.FIRST, Rank.of(6, false));
+        assertEquals(Rank.SECOND, Rank.of(5, true));
+        assertEquals(Rank.THIRD, Rank.of(5, false));
+        assertEquals(Rank.FOURTH, Rank.of(4, false));
+        assertEquals(Rank.FIFTH, Rank.of(3, false));
+        assertEquals(Rank.NONE, Rank.of(2, false));
+    }
+
+    @Test
+    void 집계와_수익률() {
+        Result r = new Result();
+        r.add(Rank.FIFTH);
+        r.add(Rank.FIRST);
+        assertEquals(1, r.count(Rank.FIFTH));
+        assertEquals(1, r.count(Rank.FIRST));
+        long prize = r.totalPrize();
+        assertTrue(prize > 0);
+
+        ProfitRate rate = ProfitRate.of(prize, 8_000);
+        assertNotNull(rate.format());
+    }
+}
diff --git a/src/test/java/lotto/WinningNumbersTest.java b/src/test/java/lotto/WinningNumbersTest.java
new file mode 100644
index 0000000000..5b0446570f
--- /dev/null
+++ b/src/test/java/lotto/WinningNumbersTest.java
@@ -0,0 +1,27 @@
+package lotto;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class WinningNumbersTest {
+
+    @Test
+    void 파싱_정상() {
+        WinningNumbers w = WinningNumbers.of("1,2,3,4,5,6", "7");
+        assertEquals(6, w.main().size());
+        assertEquals(7, w.bonus());
+    }
+
+    @Test
+    void 메인번호_6개_중복없음_범위() {
+        assertThrows(IllegalArgumentException.class, () -> WinningNumbers.of("1,2,3,4,5", "7"));       // 개수
+        assertThrows(IllegalArgumentException.class, () -> WinningNumbers.of("1,2,3,4,5,5", "7"));     // 중복
+        assertThrows(IllegalArgumentException.class, () -> WinningNumbers.of("0,2,3,4,5,6", "7"));     // 범위
+    }
+
+    @Test
+    void 보너스_범위내_그리고_메인과_중복불가() {
+        assertThrows(IllegalArgumentException.class, () -> WinningNumbers.of("1,2,3,4,5,6", "1"));
+        assertThrows(IllegalArgumentException.class, () -> WinningNumbers.of("1,2,3,4,5,6", "46"));
+    }
+}