diff --git a/README.md b/README.md
index 8a4f22ed0..694f4632d 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,106 @@
-# java-planetlotto-precourse
+# 💻 우테코 8기 최종 - 행성 로또
+Console을 이용하여 우테코 로또 발매기인 행성 로또를 구현한다.
+구입 금액에 맞춰 로또를 발행하고, 당첨 내역을 출력한다.
+
+---
+
+## **📥 입출력 명세**
+
+### ▫ 입력
+1. 로또 구입 금액을 입력 받는다. 
+2. 당첨 번호를 입력 받는다. 번호는 쉼표(,)를 기준으로 구분한다.
+3. 보너스 번호를 입력 받는다.
+
+### ▫ 출력
+
+1. 발행한 로또 수량 및 번호를 출력한다. 로또 번호는 오름차순으로 정렬하여 보여준다.
+2. 당첨 내역을 출력한다.
+3. 예외 상황 시 에러 문구를 출력해야 한다. 단, 에러 문구는 "[ERROR]"로 시작해야 한다.
+
+
+### ▫ 실행 예시
+
+```
+구입금액을 입력해 주세요.
+1000
+
+2개를 구매했습니다.
+[8, 11, 13, 21, 22]
+[1, 3, 6, 14, 22]
+
+당첨 번호를 입력해 주세요.
+1, 2, 3, 4, 5
+
+보너스 번호 번호를 입력해 주세요.
+6
+
+당첨 통계
+---
+5개 일치 (100,000,000원) - 0개
+4개 일치, 보너스 번호 일치 (10,000,000원) - 0개
+4개 일치 (1,500,000원) - 0개
+3개 일치, 보너스 번호 일치 (500,000원) - 0개
+2개 일치, 보너스 번호 일치 (5,000원) - 1개
+0개 일치 (0원) - 1개
+```
+---
+
+## 📄기능 구현 목록
+
+### 1) 입력 흐름
+
+- [x] InputView, OutputView 입출력 구성방식 확인 및 초기 패키지 구성
+- [x] 구입금액 입력받은거 검증
+- [x] 당첨번호 입력받은거 검증
+- [x] 보너스 번호 입력받은거 검증
+
+### 2) 주요 기능
+- [x] Lotto 도메인 구현
+- [x] Lottos 도메인 구현
+- [x] LottoGenerator 구현
+- [x] Rank(Enum) 구현
+- [x] WinningNumbers 도메인 구현
+- [x] 로또 생성 기능 구현
+- [x] WinCountCalculator 구현(로또 당첨 횟수 계산)
+- [x] 로또 당첨 내역 기능 구현
+
+
+### 3) 예외 및 주의사항 체크
+- [x] 로또 번호의 숫자 범위는 1~30까지이다.
+- [x] 1개의 로또를 발행할 때 중복되지 않는 5개의 숫자를 뽑는다.
+- [x] 로또 구입 금액을 입력하면 구입 금액에 해당하는 만큼 로또를 발행해야 한다.
+- [x] 로또 1장의 가격은 500원이다.
+- [x] 사용자가 잘못된 값을 입력할 경우 IllegalArgumentException를 발생시키고, "[ERROR]"로 시작하는 에러 메시지를 출력 후 그 부분부터 입력을 다시 받는다.
+- [x] 구입 금액은 500원 단위로 입력 받으며 500원으로 나누어 떨어지지 않는 경우 예외 처리한다.
+- [x] 로또 번호는 오름차순으로 정렬하여 보여준다.
+- [x] 에러 문구는 "[ERROR]"로 시작해야 한다. 
+- [x] 입력/출력 역할은 제공된 InputView, OutputView에서 수행하며 기존 메서드를 수정, 삭제할 수 없다.
+- [x] OutputView에 있는 printErrorMessage 사용하기
+
+### 4) 도전 목표
+- 기본 요구 사항을 모두 충족한 후, 아래 중 하나를 선택하여 도전하세요. 단, 도전 과제 수행 여부와 관계없이 기본 기능은 반드시 작동해야 합니다.
+- 도전 방향:
+    - [x] 리팩터링: 작동은 그대로 유지하면서 코드 품질을 높이는 방향을 목표로 한다.
+- 상세 구현 목표:
+    - [x] 매직 넘버를 사용하지 않는다.
+    - [x] 도메인에서 활용할 수 있는 기능이 있으면 최대한 활용한다.
+    - [x] private, static 의미에 맞게 사용하기
+    - [x] 이중 검증(validate) 구현
+    - [x] 모든 코드 정렬
+    - 상세 과정은 커밋 메시지를 확인하세요.
+  
+
+### 5) 프로그래밍 요구사항 체크
+- [x] 프로그래밍 요구 사항에서 달리 명시하지 않는 한 파일, 패키지 이름을 수정하거나 이동하지 않는다.
+- [x] 자바 코드 컨벤션을 지키면서 프로그래밍한다.
+- [x] 기본으로 제공되는 테스트가 통과해야 한다.
+
+
+
+### 6) 테스트 기능 목록 체크
+- [x] 기능테스트: 전체 기능 구현: ("1000", "1,2,3,4,5", "6") 입력 시 실행예시에 맞게 출력
+- [x] 예외테스트: 구입금액("500j") 입력 시 에러발생
+- [x] 에러 테스트: 로또 번호의 개수가 5개가 넘어가면 예외가 발생
+- [x] 에러 테스트: 로또 번호에 중복된 숫자가 있으면 예외가 발생
+- [x] Rank 기능 테스트
+- [x] WinningNumbers 기능 테스트
\ No newline at end of file
diff --git a/src/main/java/planetlotto/Application.java b/src/main/java/planetlotto/Application.java
index 27d0a8f96..f77ad05db 100644
--- a/src/main/java/planetlotto/Application.java
+++ b/src/main/java/planetlotto/Application.java
@@ -1,7 +1,9 @@
 package planetlotto;
 
+import planetlotto.controller.LottoController;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        new LottoController().run();
     }
 }
diff --git a/src/main/java/planetlotto/controller/LottoController.java b/src/main/java/planetlotto/controller/LottoController.java
new file mode 100644
index 000000000..1a992493e
--- /dev/null
+++ b/src/main/java/planetlotto/controller/LottoController.java
@@ -0,0 +1,76 @@
+package planetlotto.controller;
+
+import planetlotto.domain.*;
+import planetlotto.support.validator.BonusNumber;
+import planetlotto.support.validator.PurchaseAmount;
+import planetlotto.support.validator.WinningNumber;
+import planetlotto.view.InputView;
+import planetlotto.view.OutputView;
+
+import java.util.List;
+import java.util.Map;
+
+public class LottoController {
+    private final LottoGenerator lottoGenerator = new LottoGenerator();
+    private final CountByRank countByRank = new CountByRank();
+
+    public void run() {
+        int purchaseAmount = readPurchaseAmountWithRetry();
+
+        Lottos lottos = lottoGenerator.generate(purchaseAmount / 500);
+        OutputView.printPurchasedLottos(lottos.getLottosAs2DList());
+
+        List<Integer> winning = readWinningNumbersWithRetry();
+
+        int bonusNumber = readBonusNumberWithRetry();
+
+        WinningNumbers winningNumbers = new WinningNumbers(winning, bonusNumber);
+
+        Map<Rank, Integer> ranks = ResultCalculator.tallyRanks(lottos, winningNumbers);
+
+        Map<Integer, Integer> countsByrank = countByRank.calculate(ranks);
+
+        OutputView.printResult(countsByrank);
+
+
+    }
+
+
+    private int readPurchaseAmountWithRetry() {
+        while (true) {
+            try {
+                int purchaseAmount = InputView.askAmount();
+                PurchaseAmount.validate(purchaseAmount);
+                return purchaseAmount;
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private List<Integer> readWinningNumbersWithRetry() {
+        while (true) {
+            try {
+                List<Integer> winning = InputView.askWinningLotto();
+                WinningNumber.validate(winning); //입력 검증
+
+                return winning;
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+
+    private int readBonusNumberWithRetry() {
+        while (true) {
+            try {
+                int bonusNumber = InputView.askBonusNumber();
+                BonusNumber.validate(bonusNumber); //입력 검증
+                return bonusNumber;
+
+            } catch (IllegalArgumentException e) {
+                OutputView.printErrorMessage(e.getMessage());
+            }
+        }
+    }
+}
diff --git a/src/main/java/planetlotto/domain/CountByRank.java b/src/main/java/planetlotto/domain/CountByRank.java
new file mode 100644
index 000000000..2693a9eaf
--- /dev/null
+++ b/src/main/java/planetlotto/domain/CountByRank.java
@@ -0,0 +1,20 @@
+package planetlotto.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class CountByRank {
+
+    public Map<Integer, Integer> calculate(Map<Rank, Integer> ranks) {
+        Map<Integer, Integer> countsByRank = new HashMap<>();
+
+        countsByRank.put(1, ranks.getOrDefault(Rank.FIRST, 0));
+        countsByRank.put(2, ranks.getOrDefault(Rank.SECOND, 0));
+        countsByRank.put(3, ranks.getOrDefault(Rank.THIRD, 0));
+        countsByRank.put(4, ranks.getOrDefault(Rank.FOURTH, 0));
+        countsByRank.put(5, ranks.getOrDefault(Rank.FIFTH, 0));
+        countsByRank.put(0, ranks.getOrDefault(Rank.NONE, 0));
+
+        return countsByRank;
+    }
+}
diff --git a/src/main/java/planetlotto/domain/Lotto.java b/src/main/java/planetlotto/domain/Lotto.java
new file mode 100644
index 000000000..8173a8fe4
--- /dev/null
+++ b/src/main/java/planetlotto/domain/Lotto.java
@@ -0,0 +1,66 @@
+package planetlotto.domain;
+
+import java.util.*;
+
+public class Lotto {
+    // 상수
+    private static final int LOTTO_SIZE = 5;
+    private static final int MIN_NUMBER = 1;
+    private static final int MAX_NUMBER = 30;
+
+    private final List<Integer> numbers; // 오름차순 불변 리스트
+
+    public Lotto(List<Integer> numbers) {
+        validate(numbers);
+        this.numbers = toSortedUnmodifiable(numbers);
+    }
+
+    private void validate(List<Integer> numbers) {
+        validateNull(numbers);
+        validateSize(numbers);
+        validateRange(numbers);
+        validateDuplicate(numbers);
+    }
+
+    private static void validateNull(List<Integer> numbers) {
+        if (numbers == null) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호 목록이 null일 수 없습니다.");
+        }
+    }
+
+
+    private static void validateSize(List<Integer> numbers) {
+        if (numbers.size() != LOTTO_SIZE) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 " + LOTTO_SIZE + "개여야 합니다.");
+        }
+    }
+
+    private static void validateRange(List<Integer> numbers) {
+        for (Integer n : numbers) {
+            if (n == null || n < MIN_NUMBER || n > MAX_NUMBER) {
+                throw new IllegalArgumentException("[ERROR] 로또 번호는 " + MIN_NUMBER + "부터 " + MAX_NUMBER + " 사이여야 합니다.");
+            }
+        }
+    }
+
+    private static void validateDuplicate(List<Integer> numbers) {
+        Set<Integer> set = new HashSet<>(numbers);
+        if (set.size() != numbers.size()) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 중복될 수 없습니다.");
+        }
+    }
+
+
+    // --- 정렬 & 불변 보관 ---
+    private List<Integer> toSortedUnmodifiable(List<Integer> numbers) {
+        List<Integer> copy = new ArrayList<>(numbers);
+        Collections.sort(copy);
+        return Collections.unmodifiableList(copy);
+    }
+
+
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+
+}
diff --git a/src/main/java/planetlotto/domain/LottoGenerator.java b/src/main/java/planetlotto/domain/LottoGenerator.java
new file mode 100644
index 000000000..8563bbfed
--- /dev/null
+++ b/src/main/java/planetlotto/domain/LottoGenerator.java
@@ -0,0 +1,18 @@
+package planetlotto.domain;
+
+import camp.nextstep.edu.missionutils.Randoms;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LottoGenerator {
+
+    public Lottos generate(long count) {
+        List<Lotto> lottos = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            List<Integer> numbers = Randoms.pickUniqueNumbersInRange(1, 30, 5);
+            lottos.add(new Lotto(numbers));
+        }
+        return new Lottos(lottos);
+    }
+}
diff --git a/src/main/java/planetlotto/domain/Lottos.java b/src/main/java/planetlotto/domain/Lottos.java
new file mode 100644
index 000000000..24ce92060
--- /dev/null
+++ b/src/main/java/planetlotto/domain/Lottos.java
@@ -0,0 +1,28 @@
+package planetlotto.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Lottos {
+
+    public List<Lotto> lottos;
+
+    public Lottos(List<Lotto> lottos) {
+        this.lottos = lottos;
+    }
+
+
+    public int size() {
+        return lottos.size();
+    }
+
+    public List<List<Integer>> getLottosAs2DList() {
+        return lottos.stream()
+                .map(Lotto::getNumbers) // Lotto 객체의 getNumbers() 메소드 호출
+                .collect(Collectors.toList());
+    }
+
+    public List<Lotto> getLottos() {
+        return lottos;
+    }
+}
diff --git a/src/main/java/planetlotto/domain/Rank.java b/src/main/java/planetlotto/domain/Rank.java
new file mode 100644
index 000000000..0b3a7cb6d
--- /dev/null
+++ b/src/main/java/planetlotto/domain/Rank.java
@@ -0,0 +1,50 @@
+package planetlotto.domain;
+
+public enum Rank {
+
+    FIRST(5, false, 100_000_000L),
+    SECOND(4, true, 10_000_000L),
+    THIRD(4, false, 1_500_000L),
+    FOURTH(3, true, 500_000L),
+    FIFTH(2, true, 5_000L),
+    NONE(0, false, 0L);
+
+    private final int matchCount;
+    private final boolean isBonus;
+    private final long prize;
+
+    Rank(int matchCount, boolean isBonus, long prize) {
+        this.matchCount = matchCount;
+        this.isBonus = isBonus;
+        this.prize = prize;
+    }
+
+
+    public static Rank of(int matchCount, boolean isBonus) {
+        // 조기 반환으로 분기 (else/switch/3항 금지)
+        if (matchCount == 5) {
+            return FIRST;
+        }
+        if (matchCount == 4 && isBonus) {
+            return SECOND;
+        }
+        if (matchCount == 4) {
+            return THIRD;
+        }
+        if (matchCount == 3 && isBonus) {
+            return FOURTH;
+        }
+        if (matchCount == 2 && isBonus) {
+            return FIFTH;
+        }
+        return NONE;
+    }
+
+    public long getPrize(){
+        return prize;
+    }
+
+    public int getMatchCount(){
+        return matchCount;
+    }
+}
diff --git a/src/main/java/planetlotto/domain/ResultCalculator.java b/src/main/java/planetlotto/domain/ResultCalculator.java
new file mode 100644
index 000000000..1e3f53cba
--- /dev/null
+++ b/src/main/java/planetlotto/domain/ResultCalculator.java
@@ -0,0 +1,24 @@
+package planetlotto.domain;
+
+import java.util.*;
+
+public final class ResultCalculator {
+
+    private ResultCalculator() {
+    } // 객체 생성 금지용
+
+    /**
+     * 보유한 로또들을 등수별로 집계한다.
+     */
+    public static Map<Rank, Integer> tallyRanks(Lottos lottos, WinningNumbers winning) {
+        Map<Rank, Integer> tally = new EnumMap<>(Rank.class);
+        for (Lotto lotto : lottos.getLottos()) {
+            int matches = winning.countMatches(lotto);
+            boolean bonus = winning.isBonusMatched(lotto);
+            Rank rank = Rank.of(matches, bonus);
+            tally.put(rank, tally.getOrDefault(rank, 0) + 1);
+        }
+        return tally;
+    }
+
+}
diff --git a/src/main/java/planetlotto/domain/WinningNumbers.java b/src/main/java/planetlotto/domain/WinningNumbers.java
new file mode 100644
index 000000000..ebb95aeeb
--- /dev/null
+++ b/src/main/java/planetlotto/domain/WinningNumbers.java
@@ -0,0 +1,100 @@
+package planetlotto.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+public class WinningNumbers {
+
+    // 상수
+    private static final int REQUIRED_SIZE = 5;
+    private static final int MIN_NUMBER = 1;
+    private static final int MAX_NUMBER = 30;
+
+    private final List<Integer> numbers; // 오름차순 불변 리스트
+    private final int bonusNum;
+
+    public WinningNumbers(List<Integer> numbers, int bonusNum) {
+        validateNotNull(numbers);
+        validateSize(numbers);
+        validateRange(numbers);
+        validateUnique(numbers);
+        validateBonusRange(bonusNum);
+        validateBonusNotDuplicated(numbers, bonusNum);
+
+        this.numbers = toSortedUnmodifiable(numbers);
+        this.bonusNum = bonusNum;
+    }
+
+
+    // --- 검증 ---
+    private void validateNotNull(List<Integer> numbers) {
+        if (numbers == null) {
+            throw new IllegalArgumentException("[ERROR] 당첨 번호 목록이 null일 수 없습니다.");
+        }
+    }
+
+    private void validateSize(List<Integer> numbers) {
+        if (numbers.size() != REQUIRED_SIZE) {
+            throw new IllegalArgumentException("[ERROR] 당첨 번호는 " + REQUIRED_SIZE + "개여야 합니다.");
+        }
+    }
+
+    private void validateRange(List<Integer> numbers) {
+        for (Integer n : numbers) {
+            if (n == null || n < MIN_NUMBER || n > MAX_NUMBER) {
+                throw new IllegalArgumentException("[ERROR] 당첨 번호는 " + MIN_NUMBER + "부터 " + MAX_NUMBER + " 사이여야 합니다.");
+            }
+        }
+    }
+
+    private void validateUnique(List<Integer> numbers) {
+        if (new HashSet<>(numbers).size() != numbers.size()) {
+            throw new IllegalArgumentException("[ERROR] 당첨 번호는 중복될 수 없습니다.");
+        }
+    }
+
+    private void validateBonusRange(int bonus) {
+        if (bonus < MIN_NUMBER || bonus > MAX_NUMBER) {
+            throw new IllegalArgumentException("[ERROR] 보너스 번호는 " + MIN_NUMBER + "부터 " + MAX_NUMBER + " 사이여야 합니다.");
+        }
+    }
+
+    private void validateBonusNotDuplicated(List<Integer> numbers, int bonus) {
+        if (numbers.contains(bonus)) {
+            throw new IllegalArgumentException("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+        }
+    }
+
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+
+    public int getBonusNum() {
+        return bonusNum;
+    }
+
+    // --- 보관 ---
+    private List<Integer> toSortedUnmodifiable(List<Integer> numbers) {
+        List<Integer> copy = new ArrayList<>(numbers);
+        Collections.sort(copy);
+        return Collections.unmodifiableList(copy);
+    }
+
+
+    // --- 판정 보조 ---
+    public int countMatches(Lotto lotto) {
+        int count = 0;
+        for (Integer n : lotto.getNumbers()) {
+            if (numbers.contains(n)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public boolean isBonusMatched(Lotto lotto) {
+        return lotto.getNumbers().contains(bonusNum);
+    }
+}
diff --git a/src/main/java/planetlotto/support/validator/BonusNumber.java b/src/main/java/planetlotto/support/validator/BonusNumber.java
new file mode 100644
index 000000000..6946c00b8
--- /dev/null
+++ b/src/main/java/planetlotto/support/validator/BonusNumber.java
@@ -0,0 +1,14 @@
+package planetlotto.support.validator;
+
+public final class BonusNumber {
+
+    // 상수
+    private static final int MIN_NUMBER = 1;
+    private static final int MAX_NUMBER = 30;
+
+    public static void validate(int bonus) {
+        if (bonus < MIN_NUMBER || bonus > MAX_NUMBER) {
+            throw new IllegalArgumentException("보너스 숫자는 " + MIN_NUMBER + "부터 " + MAX_NUMBER + " 사이여야 합니다.");
+        }
+    }
+}
diff --git a/src/main/java/planetlotto/support/validator/PurchaseAmount.java b/src/main/java/planetlotto/support/validator/PurchaseAmount.java
new file mode 100644
index 000000000..49f695041
--- /dev/null
+++ b/src/main/java/planetlotto/support/validator/PurchaseAmount.java
@@ -0,0 +1,21 @@
+package planetlotto.support.validator;
+
+public final class PurchaseAmount {
+    public static void validate(int purchaseAmount) {
+        validateNegative(purchaseAmount);
+        validateFiveHundred(purchaseAmount);
+    }
+
+
+    private static void validateNegative(int amount) {
+        if (amount < 0) {
+            throw new IllegalArgumentException("구입 금액은 음수일 수 없습니다.");
+        }
+    }
+
+    private static void validateFiveHundred(int amount) {
+        if (amount % 500 != 0) {
+            throw new IllegalArgumentException("구입금액은 500원 단위로 입력해주세요.");
+        }
+    }
+}
diff --git a/src/main/java/planetlotto/support/validator/WinningNumber.java b/src/main/java/planetlotto/support/validator/WinningNumber.java
new file mode 100644
index 000000000..6b03ed3cd
--- /dev/null
+++ b/src/main/java/planetlotto/support/validator/WinningNumber.java
@@ -0,0 +1,40 @@
+package planetlotto.support.validator;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public final class WinningNumber {
+
+    // 상수
+    private static final int LOTTO_SIZE = 5;
+    private static final int MIN_NUMBER = 1;
+    private static final int MAX_NUMBER = 30;
+
+    public static void validate(List<Integer> WinningNumbers) {
+        validateDuplicate(WinningNumbers);
+        validateSize(WinningNumbers);
+        validateRange(WinningNumbers);
+    }
+
+    private static void validateDuplicate(List<Integer> result) {
+        Set<Integer> set = new HashSet<>(result);
+        if (set.size() != result.size()) {
+            throw new IllegalArgumentException("당첨번호에 중복되는 숫자가 있습니다.");
+        }
+    }
+
+    private static void validateSize(List<Integer> result) {
+        if (result.size() != LOTTO_SIZE) {
+            throw new IllegalArgumentException("로또 번호는 " + LOTTO_SIZE + "개여야 합니다.");
+        }
+    }
+
+    private static void validateRange(List<Integer> result) {
+        for (int number : result) {
+            if (number < MIN_NUMBER || number > MAX_NUMBER) {
+                throw new IllegalArgumentException("로또 번호의 숫자 범위는 1~30까지입니다.");
+            }
+        }
+    }
+}
diff --git a/src/test/java/planetlotto/domain/RankTest.java b/src/test/java/planetlotto/domain/RankTest.java
new file mode 100644
index 000000000..3e7fb367c
--- /dev/null
+++ b/src/test/java/planetlotto/domain/RankTest.java
@@ -0,0 +1,57 @@
+package planetlotto.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+class RankTest {
+
+    @Test
+    @DisplayName("일치 5개면 1등이며 상금은 100_000_000원")
+    void firstPrize() {
+        Rank rank = Rank.of(5, false);
+        assertThat(rank).isEqualTo(Rank.FIRST);
+        assertThat(rank.getPrize()).isEqualTo(100_000_000L);
+        assertThat(rank.getMatchCount()).isEqualTo(5);
+    }
+
+    @Test
+    @DisplayName("일치 4개+보너스면 2등이며 상금은 10_000_000원")
+    void secondPrize() {
+        Rank rank = Rank.of(4, true);
+        assertThat(rank).isEqualTo(Rank.SECOND);
+        assertThat(rank.getPrize()).isEqualTo(10_000_000L);
+        assertThat(rank.getMatchCount()).isEqualTo(4);
+    }
+
+    @Test
+    @DisplayName("일치 4개(보너스X)는 3등이며 상금은 1_500_000원")
+    void thirdPrize() {
+        Rank rank = Rank.of(4, false);
+        assertThat(rank).isEqualTo(Rank.THIRD);
+        assertThat(rank.getPrize()).isEqualTo(1_500_000L);
+        assertThat(rank.getMatchCount()).isEqualTo(4);
+    }
+
+    @Test
+    @DisplayName("일치 3개(보너스o)는 4등(500_000원), 2개(보너스o)는 5등(5_000원)")
+    void fourthAndFifthPrize() {
+        assertThat(Rank.of(3, true)).isEqualTo(Rank.FOURTH);
+        assertThat(Rank.of(3, true).getPrize()).isEqualTo(500_000L);
+
+        assertThat(Rank.of(2, true)).isEqualTo(Rank.FIFTH);
+        assertThat(Rank.of(2, true).getPrize()).isEqualTo(5_000L);
+    }
+
+    @Test
+    @DisplayName("그 외의 조합은 NONE(0원)")
+    void nonePrize() {
+        assertThat(Rank.of(2, false)).isEqualTo(Rank.NONE);
+        assertThat(Rank.of(0, false)).isEqualTo(Rank.NONE);
+        assertThat(Rank.of(1, true)).isEqualTo(Rank.NONE);
+        assertThat(Rank.of(2, false)).isEqualTo(Rank.NONE);
+        assertThat(Rank.NONE.getPrize()).isEqualTo(0L);
+        assertThat(Rank.NONE.getMatchCount()).isEqualTo(0);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/planetlotto/domain/WinningNumbersTest.java b/src/test/java/planetlotto/domain/WinningNumbersTest.java
new file mode 100644
index 000000000..4dec38c2b
--- /dev/null
+++ b/src/test/java/planetlotto/domain/WinningNumbersTest.java
@@ -0,0 +1,85 @@
+package planetlotto.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.*;
+
+class WinningNumbersTest {
+
+    @Test
+    @DisplayName("당첨 번호는 정확히 5개가 아니면 예외")
+    void sizeMustBeFive() {
+        assertThatThrownBy(() -> new WinningNumbers(List.of(1,2,3,4,5,6), 7))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("[ERROR]");
+
+        assertThatThrownBy(() -> new WinningNumbers(List.of(1,2,3,4,5,6,7), 8))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("[ERROR]");
+    }
+
+    @Test
+    @DisplayName("당첨 번호 각 숫자는 1~30 범위를 벗어나면 예외")
+    void winningNumbersMustBeInRange() {
+        assertThatThrownBy(() -> new WinningNumbers(List.of(0,2,3,4,5), 7))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("[ERROR]");
+
+        assertThatThrownBy(() -> new WinningNumbers(List.of(2,3,4,5,31), 7))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("[ERROR]");
+    }
+
+    @Test
+    @DisplayName("당첨 번호에 중복이 있으면 예외")
+    void winningNumbersMustBeUnique() {
+        assertThatThrownBy(() -> new WinningNumbers(List.of(1,1,3,4,5), 7))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("[ERROR]");
+    }
+
+    @Test
+    @DisplayName("보너스 번호는 1~30 범위를 벗어나면 예외")
+    void bonusMustBeInRange() {
+        assertThatThrownBy(() -> new WinningNumbers(List.of(1,2,3,4,6), 0))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("[ERROR]");
+
+        assertThatThrownBy(() -> new WinningNumbers(List.of(1,2,3,4,5), 31))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("[ERROR]");
+    }
+
+    @Test
+    @DisplayName("보너스 번호가 당첨 번호와 중복이면 예외")
+    void bonusMustNotDuplicateWinningNumbers() {
+        assertThatThrownBy(() -> new WinningNumbers(List.of(1,2,3,4,5), 5))
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageStartingWith("[ERROR]");
+    }
+
+    @Test
+    @DisplayName("내부 당첨 번호는 오름차순으로 보관되며 불변이다")
+    void internalNumbersAreSortedAndUnmodifiable() {
+        WinningNumbers w = new WinningNumbers(List.of(1,30,10,3,7), 8);
+        assertThat(w.getNumbers()).containsExactly(1,3,7,10,30);
+        assertThatThrownBy(() -> w.getNumbers().add(99))
+                .isInstanceOf(UnsupportedOperationException.class);
+    }
+
+    @Test
+    @DisplayName("일치 개수와 보너스 일치 여부를 계산할 수 있다")
+    void canCountMatchesAndBonus() {
+        WinningNumbers w = new WinningNumbers(List.of(1,2,3,4,5), 7);
+        Lotto lotto1 = new Lotto(List.of(1,2,3,10,11)); // 3개 일치
+        Lotto lotto2 = new Lotto(List.of(2,3,4,5,7));    // 5개 + 보너스
+
+        assertThat(w.countMatches(lotto1)).isEqualTo(3);
+        assertThat(w.countMatches(lotto2)).isEqualTo(4);
+        assertThat(w.isBonusMatched(lotto2)).isTrue();
+
+    }
+}
\ No newline at end of file