diff --git a/docs/README.md b/docs/README.md
index e69de29bb2d..3e082c5bb61 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -0,0 +1,71 @@
+# 📝설계 구조
+- Application : 애플리케이션 실행을 관리한다.
+- MainController : 데이터 전달 및 중계 역할을 한다.
+- view
+    - InputView : 입력과 관련된 책임 관리한다.
+    - OutputView : 출력과 관련된 책임 관리한다.
+- message(각 객체를 enum으로 관리)
+    - ErrorMessage : 에러 메시지를 관리한다.
+    - ViewMessage : 출력 메시지를 관리한다.
+- domain
+    - Lotto :  List<Integer>를 멤버변수로 갖는다. 숫자를 관리할 일급객체
+    - Lottos : Lotto객체의 List를 관리할 일급컬렉션
+    - User :  winningLotto , bounusNumber, lottoBudget,  멤버변수를갖는다.
+      - User의 멤버변수는 원시값으로 포장한다
+- Validator 클래스
+    - 공통 검증매서드를 관리한다
+  
+
+# 📝 구현 기능 목록
+### 게임 초기화
+
+- [x]  구입할 금액 입력
+   - [x] `예외처리` : 빈 문자열 입력 검증
+   - [x] `예외처리` : 숫자외 문자 입력 검증
+   - [x] `예외처리` : 음수 입력 검증
+   - [x] `예외처리` : 1000단위로 안떨어지는 경우 검증
+- [x] 로또 구입 기능
+    - pickUniqueNumbersInRange() 매서드 사용
+- [x]  당첨번호 입력
+   - [x] `예외처리` : 빈 문자열 입력 검증
+   - [x] `예외처리` : ,가 없을때 검증
+   - [x] `예외처리` : 1~45 사이를 벗어난 숫자
+   - [x] `예외처리` : 문자를 입력했을때 검증
+   - [x] `예외처리` : 6자리 미만이거나 초과일때 검증
+- [x]  보너스 번호 입력
+    - [x] `예외처리` : 1~45 사이를 벗어난 숫자
+    - [x] `예외처리` : 당첨번호와 중복 검증
+    - [x] `예외처리` : 빈 문자열 입력 검증
+<Br><Br>
+
+### 게임 진행
+- [x] 발행한 로또 수량 및 번호(오름차순) 출력한다.
+- [x] 당첨 체크 기능
+
+<Br><Br>
+
+### 게임 종료
+- [x] 당첨내역및 수익률 출력후 게임종료
+
+  <Br><Br>
+
+### 확인 목록
+- Git의 커밋 단위는 README.md에 정리한 기능 목록 단위로 추가
+- Java Enum을 적용
+- 입력문구
+  - 구입금액을 입력해 주세요.
+  - ${갯수}개를 구매했습니다.
+  - 당첨 번호를 입력해 주세요.
+  - 보너스 번호를 입력해 주세요.
+  - 당첨 통계
+  - \-\-\-
+  - 3개 일치 (5,000원) - 1개
+  - 4개 일치 (50,000원) - 0개
+  - 5개 일치 (1,500,000원) - 0개
+  - 5개 일치, 보너스 볼 일치 (30,000,000원) - 0개
+  - 6개 일치 (2,000,000,000원) - 0개
+  - 총 수익률은 62.5%입니다.
+- 사용자가 잘못된 값을 입력할 경우 
+  - "[ERROR]"로 시작하는 에러 메시지를 출력
+  - Exception이 아닌 IllegalArgumentException, IllegalStateException 등과 같은 명확한 유형을 처리한다.
+  - 그 부분부터 입력을 다시 받는다.
\ No newline at end of file
diff --git a/src/main/java/lotto/Application.java b/src/main/java/lotto/Application.java
index d190922ba44..21ec324f200 100644
--- a/src/main/java/lotto/Application.java
+++ b/src/main/java/lotto/Application.java
@@ -2,6 +2,6 @@
 
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        MainController.run();
     }
 }
diff --git a/src/main/java/lotto/Lotto.java b/src/main/java/lotto/Lotto.java
deleted file mode 100644
index 519793d1f73..00000000000
--- 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();
-        }
-    }
-
-    // TODO: 추가 기능 구현
-}
diff --git a/src/main/java/lotto/MainController.java b/src/main/java/lotto/MainController.java
new file mode 100644
index 00000000000..27a35c8ac62
--- /dev/null
+++ b/src/main/java/lotto/MainController.java
@@ -0,0 +1,28 @@
+package lotto;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import lotto.domain.Budget;
+import lotto.domain.Lotto;
+import lotto.domain.Lottos;
+import lotto.view.InputView;
+import lotto.view.OutputView;
+
+public class MainController {
+
+    public static void run() {
+        //게임 초기화
+        Budget budget = InputView.inputBudget();
+        Lotto winningLotto = InputView.createWinningLotto();
+        int bonusNumber = InputView.createBonusNumber(winningLotto);
+        //게임진행
+        Lottos purchasedLottos = Lotto.buyLottoUsingBudget(budget);
+
+        //GameEnd
+        Map<String, Long> resultMap = Lottos.compareLottos(purchasedLottos, winningLotto, bonusNumber);
+
+        OutputView.printResult(resultMap);
+        OutputView.printInvestmentRate(Budget.calculateTotalReturnRate(budget,resultMap));
+        ;
+    }
+}
diff --git a/src/main/java/lotto/Validator.java b/src/main/java/lotto/Validator.java
new file mode 100644
index 00000000000..ec42916cf38
--- /dev/null
+++ b/src/main/java/lotto/Validator.java
@@ -0,0 +1,56 @@
+package lotto;
+
+import lotto.domain.Lotto;
+import lotto.message.ErrorMessage;
+
+public class Validator {
+    public static void validatePositiveNumber(String inputString) {
+        if (Integer.parseInt(inputString)<=0){
+            throw new IllegalArgumentException(ErrorMessage.INPUT_NOT_POSITIVE_NUMBER.getMessage());
+        }
+    }
+
+    public static void validateBlank(String inputString) {
+        if (inputString == null || inputString.isBlank()) {
+            throw new IllegalArgumentException(ErrorMessage.INPUT_BLANK.getMessage());
+        }
+    }
+
+    public static void validateType(String inputString) {
+        try {
+            Integer.parseInt(inputString);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(ErrorMessage.INPUT_NOT_NUMBER.getMessage());
+        }
+    }
+
+    public static void validateDeliiter(String input) {
+        input.contains(",");
+    }
+    public static Integer parseAndValidateNotNumber(String input) {
+        try {
+            int number = Integer.parseInt(input);
+            validateNumberRange(number);
+            return number;
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(ErrorMessage.INPUT_NOT_NUMBER.getMessage());
+        }
+    }
+
+    public static void validateNumberRange(int number) {
+        if (number < 1 || number > 45) {
+            throw new IllegalArgumentException(ErrorMessage.INPUT_NOT_LOTTO_RANGE.getMessage());
+        }
+    }
+
+    public static int parseAndValidateBonusNumber(String input, Lotto winningLotto) {
+        validateBlank(input);
+
+        int bonusNumber = Validator.parseAndValidateNotNumber(input);
+        if (winningLotto.getNumbers().contains(bonusNumber)) {
+            throw new IllegalArgumentException(ErrorMessage.INPUT_DUPLICATED_NUMBER_WITH_WINNINGNUMBERS.getMessage());
+        }
+        return bonusNumber;
+    }
+
+}
diff --git a/src/main/java/lotto/domain/Budget.java b/src/main/java/lotto/domain/Budget.java
new file mode 100644
index 00000000000..d307b3d02bf
--- /dev/null
+++ b/src/main/java/lotto/domain/Budget.java
@@ -0,0 +1,46 @@
+package lotto.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+import lotto.message.ViewMessage;
+import lotto.view.InputView;
+
+public class Budget {
+    private int amount;
+
+    public Budget(int amount) {
+        validateBudget(amount);
+        this.amount = amount;
+    }
+    public static double calculateTotalReturnRate(Budget budget, Map<String, Long> resultMap) {
+        // 당첨금액과 상금을 맵으로 정의
+        Map<String, Long> prizeMap = new HashMap<>();
+        prizeMap.put("3개 일치 (5,000원) - ", 5000L);
+        prizeMap.put("4개 일치 (50,000원) - ", 50000L);
+        prizeMap.put("5개 일치 (1,500,000원) - ", 1500000L);
+        prizeMap.put("5개 일치, 보너스 볼 일치 (30,000,000원) - ", 30000000L);
+        prizeMap.put("6개 일치 (2,000,000,000원) - ", 2000000000L);
+
+        // 당첨 금액 계산
+        long totalPrize = resultMap.entrySet().stream()
+                .mapToLong(entry -> prizeMap.getOrDefault(entry.getKey(), 0L) * entry.getValue())
+                .sum();
+
+        // 총 투자 금액 계산
+        long totalInvestment = budget.getAmount();
+
+        // 수익률 계산
+        return (double) totalPrize / totalInvestment * 100;
+
+        // 결과 출력
+    }
+    private static void validateBudget(int amount) {
+        if (amount % 1000 != 0) {
+            throw new IllegalArgumentException("1000원 단위로만 금액을 입력해주세요.");
+        }
+    }
+    public int getAmount() {
+        return amount;
+    }
+
+}
diff --git a/src/main/java/lotto/domain/Lotto.java b/src/main/java/lotto/domain/Lotto.java
new file mode 100644
index 00000000000..e73b3f100fd
--- /dev/null
+++ b/src/main/java/lotto/domain/Lotto.java
@@ -0,0 +1,59 @@
+package lotto.domain;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import lotto.message.ViewMessage;
+import lotto.view.OutputView;
+
+public class Lotto {
+    private final List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        validate(numbers);
+        validateDuplicatedNumber(numbers);
+        this.numbers = numbers;
+    }
+
+    public static Lottos buyLottoUsingBudget(Budget budget) {
+        int lottoCount=budget.getAmount() / 1000;
+        Lottos lottos = new Lottos(new ArrayList<>());
+
+        for (int i = 0; i < lottoCount; i++) {
+            List<Integer> lottoNumbers = Randoms.pickUniqueNumbersInRange(1, 45, 6);
+            Lotto lotto = new Lotto(lottoNumbers);
+            lottos.addLotto(lotto);
+        }
+        OutputView.printBuyResult(lottoCount, lottos);
+        return lottos;
+    }
+
+    private void validate(List<Integer> numbers) {
+        if (numbers.size() != 6) {
+            throw new IllegalArgumentException();
+        }
+    }
+    private void validateDuplicatedNumber(List<Integer> numbers) {
+        Set<Integer> uniqueNumbers = new HashSet<>(numbers);
+        if (uniqueNumbers.size() != numbers.size()) {
+            throw new IllegalArgumentException("중복된 숫자가 있습니다.");
+        }
+    }
+    public List<Integer> getNumbers() {
+        return numbers;
+    }
+
+    public String printNumbers() {
+        String numberString = numbers.stream()
+                .sorted()
+                .map(String::valueOf)
+                .collect(Collectors.joining(", "));
+        return "[" + numberString + "]";
+    }
+
+}
diff --git a/src/main/java/lotto/domain/Lottos.java b/src/main/java/lotto/domain/Lottos.java
new file mode 100644
index 00000000000..1acf3e12a5f
--- /dev/null
+++ b/src/main/java/lotto/domain/Lottos.java
@@ -0,0 +1,58 @@
+package lotto.domain;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public record Lottos(List<Lotto> lottoList) {
+    public void addLotto(Lotto lotto) {
+        lottoList.add(lotto);
+    }
+    public String printAllLottoNumbers() {
+        return lottoList.stream()
+                .map(Lotto::printNumbers)
+                .collect(Collectors.joining("\n"));
+    }
+    public static Map<String, Long> compareLottos(Lottos purchasedLottos, Lotto winningLotto, int bonusNumber) {
+        Map<String, Long> resultMap = new LinkedHashMap<>();
+        List<Integer> winningLottoNumbers = winningLotto.getNumbers();
+
+        for (Lotto lotto : purchasedLottos.lottoList()){
+            List<Integer> purchasedNumbers = lotto.getNumbers();
+            long matchCount  = purchasedNumbers.stream()
+                    .filter(winningLottoNumbers::contains)
+                    .count();
+            boolean hasBonus = purchasedNumbers.contains(bonusNumber);
+            updateResult(resultMap, matchCount, hasBonus);
+        }
+        return resultMap;
+    }
+
+    public static void updateResult(Map<String, Long> resultMap, long matchCount, boolean hasBonus) {
+        resultMap.putIfAbsent("3개 일치 (5,000원) - ", 0L);
+        resultMap.putIfAbsent("4개 일치 (50,000원) - ", 0L);
+        resultMap.putIfAbsent("5개 일치 (1,500,000원) - ", 0L);
+        resultMap.putIfAbsent("5개 일치, 보너스 볼 일치 (30,000,000원) - ", 0L);
+        resultMap.putIfAbsent("6개 일치 (2,000,000,000원) - ", 0L);
+
+        if (matchCount == 3) {
+            resultMap.merge("3개 일치 (5,000원) - ", 1L, Long::sum);
+        }
+        if (matchCount == 4) {
+            resultMap.merge("4개 일치 (50,000원) - ", 1L, Long::sum);
+        }
+        if (matchCount == 5 && hasBonus) {
+            resultMap.merge("5개 일치, 보너스 볼 일치 (30,000,000원) - ", 1L, Long::sum);
+        }
+        if (matchCount == 5 && !hasBonus) {
+            resultMap.merge("5개 일치 (1,500,000원) - ", 1L, Long::sum);
+        }
+        if (matchCount == 6) {
+            resultMap.merge("6개 일치 (2,000,000,000원) - ", 1L, Long::sum);
+        }
+    }
+    public int getLottosSize() {
+        return lottoList.size();
+    }
+}
diff --git a/src/main/java/lotto/message/ErrorMessage.java b/src/main/java/lotto/message/ErrorMessage.java
new file mode 100644
index 00000000000..af5d787092d
--- /dev/null
+++ b/src/main/java/lotto/message/ErrorMessage.java
@@ -0,0 +1,17 @@
+package lotto.message;
+
+public enum ErrorMessage {
+    PURCHASED_COUNT_PRINT("개를 구매했습니다."),
+    INPUT_NOT_NUMBER("숫자가 아닌 값을 입력하셨습니다."),
+    INPUT_NOT_LOTTO_RANGE("번호는 1부터 45까지의 숫자여야 합니다."),
+    INPUT_DUPLICATED_NUMBER_WITH_WINNINGNUMBERS("보너스 번호는 당첨 번호와 중복될 수 없습니다. 다시입력해주세요."),
+    INPUT_BLANK("빈 값을 입력하셨습니다. 값을 입력해주세요."),
+    INPUT_NOT_POSITIVE_NUMBER("0또는 음수는 입력할수없습니다. 양수를 입력해주세요");
+    private final String message;
+    ErrorMessage(String message) {
+        this.message = message;
+    }
+    public String getMessage() {
+        return "[ERROR]" + message;
+    }
+}
diff --git a/src/main/java/lotto/message/ViewMessage.java b/src/main/java/lotto/message/ViewMessage.java
new file mode 100644
index 00000000000..2922385e3b6
--- /dev/null
+++ b/src/main/java/lotto/message/ViewMessage.java
@@ -0,0 +1,16 @@
+package lotto.message;
+
+public enum ViewMessage {
+    PURCHASED_COUNT_PRINT("개를 구매했습니다."),
+    TOTAL_RETURN_RATE ("총 수익률은 %.1f%%입니다.%n");
+    private final String message;
+
+    ViewMessage(String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+}
diff --git a/src/main/java/lotto/view/InputView.java b/src/main/java/lotto/view/InputView.java
new file mode 100644
index 00000000000..24360bd921b
--- /dev/null
+++ b/src/main/java/lotto/view/InputView.java
@@ -0,0 +1,85 @@
+package lotto.view;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.util.List;
+import java.util.stream.Stream;
+import lotto.Validator;
+import lotto.domain.Budget;
+import lotto.domain.Lotto;
+
+public class InputView {
+    public static int readInteger(String message) {
+        while (true) {
+            System.out.println(message);
+            String inputString = Console.readLine();
+            Integer reslt = attemptToParseInteger(inputString);
+            if (reslt != null) {
+                return reslt;
+            }
+        }
+    }
+
+    private static Integer attemptToParseInteger(String inputString) {
+        try {
+            Validator.validateBlank(inputString);
+            Validator.validateType(inputString);
+            Validator.validatePositiveNumber(inputString);
+            return Integer.parseInt(inputString);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return null;
+        }
+    }
+
+    public static Budget inputBudget() {
+        Budget budget = null;
+        while (budget == null) {
+            budget = attemptToInputBudget();
+        }
+        return budget;
+    }
+
+    private static Budget attemptToInputBudget() {
+        try {
+            return new Budget(InputView.readInteger("구입금액을 입력해 주세요."));
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage() + " 다시 입력해 주세요.");
+            return null;
+        }
+    }
+
+    public static Lotto createWinningLotto() {
+        System.out.println("로또 번호 6자리를 입력해주세요");
+        String input = Console.readLine();
+        Validator.validateBlank(input);
+        Validator.validateDeliiter(input);
+        List<Integer> winningNumbers = Stream.of(input.split(","))
+                .map(String::trim)
+                .map(Validator::parseAndValidateNotNumber)
+                .sorted()
+                .toList();
+        if (winningNumbers.size() != 6) {
+            throw new IllegalArgumentException("로또번호는 6개를 입니다. 입력 갯수를 확인하세요");
+        }
+
+        return new Lotto(winningNumbers);
+    }
+    public static int createBonusNumber(Lotto winningLotto) {
+        while (true) {
+            System.out.println("보너스 숫자를 입력해주세요");
+            String input = Console.readLine();
+            int bonusNumber = parseBounusNumber(input, winningLotto);
+            if (bonusNumber != -1) {
+                return bonusNumber;
+            }
+        }
+    }
+    private static int parseBounusNumber(String input, Lotto winningLotto) {
+        try{
+            return Validator.parseAndValidateBonusNumber(input, winningLotto);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return -1;
+        }
+    }
+}
diff --git a/src/main/java/lotto/view/OutputView.java b/src/main/java/lotto/view/OutputView.java
new file mode 100644
index 00000000000..173b251e5ad
--- /dev/null
+++ b/src/main/java/lotto/view/OutputView.java
@@ -0,0 +1,24 @@
+package lotto.view;
+
+import java.util.HashMap;
+import java.util.Map;
+import lotto.domain.Budget;
+import lotto.domain.Lotto;
+import lotto.domain.Lottos;
+import lotto.message.ViewMessage;
+
+public class OutputView {
+    public static void printBuyResult(int lottoCount, Lottos lottos) {
+        System.out.println(lottoCount + ViewMessage.PURCHASED_COUNT_PRINT.getMessage());
+        System.out.println(lottos.printAllLottoNumbers());
+    }
+    public static void printResult(Map<String, Long> resultMap) {
+        resultMap.forEach((key, value) ->{
+            System.out.println(key + value + "개");
+                }
+        );
+    }
+    public static void printInvestmentRate(double calculateTotalReturnRate) {
+        System.out.printf(ViewMessage.TOTAL_RETURN_RATE.getMessage(), calculateTotalReturnRate);
+    };
+}
diff --git a/src/test/java/lotto/LottoTest.java b/src/test/java/lotto/LottoTest.java
index 9f5dfe7eb83..e85ce0cceca 100644
--- a/src/test/java/lotto/LottoTest.java
+++ b/src/test/java/lotto/LottoTest.java
@@ -1,5 +1,9 @@
 package lotto;
 
+import lotto.domain.Budget;
+import lotto.domain.Lotto;
+import lotto.domain.Lottos;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
@@ -18,10 +22,17 @@ void createLottoByOverSize() {
     @DisplayName("로또 번호에 중복된 숫자가 있으면 예외가 발생한다.")
     @Test
     void createLottoByDuplicatedNumber() {
-        // TODO: 이 테스트가 통과할 수 있게 구현 코드 작성
         assertThatThrownBy(() -> new Lotto(List.of(1, 2, 3, 4, 5, 5)))
                 .isInstanceOf(IllegalArgumentException.class);
     }
-
-    // 아래에 추가 테스트 작성 가능
+    @DisplayName("입력금액만큼 로또 구매 로직 성공 테스트")
+    @Test
+    void buyLottoUsingBudgetSuccessTest() {
+        //given
+        Lottos purchasedLotto = Lotto.buyLottoUsingBudget(new Budget(3000));
+        //when
+        int lottoCount = purchasedLotto.getLottosSize();  // Lottos에 있는 Lotto 객체의 개수를 가져옴
+        //then
+        Assertions.assertThat(lottoCount).isEqualTo(3);
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/lotto/domain/BudgetTest.java b/src/test/java/lotto/domain/BudgetTest.java
new file mode 100644
index 00000000000..3116890292e
--- /dev/null
+++ b/src/test/java/lotto/domain/BudgetTest.java
@@ -0,0 +1,25 @@
+package lotto.domain;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class BudgetTest {
+
+    @DisplayName("수익금 계산 테스트")
+    @Test
+    void calculateTotalReturnRateTest() {
+        //given
+        Budget budget = new Budget(1000); // 투자 금액 1000원
+        Map<String, Long> resultMap = new HashMap<>();
+        resultMap.put("3개 일치 (5,000원) - ", 1L); // 5등 당첨 1장
+        //when
+        double totalReturnRate = Budget.calculateTotalReturnRate(budget, resultMap);
+        //then
+        Assertions.assertThat(totalReturnRate).isEqualTo(500);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/lotto/domain/LottosTest.java b/src/test/java/lotto/domain/LottosTest.java
new file mode 100644
index 00000000000..bb05b655ea2
--- /dev/null
+++ b/src/test/java/lotto/domain/LottosTest.java
@@ -0,0 +1,83 @@
+package lotto.domain;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+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;
+
+class LottosTest {
+
+    @DisplayName("등수계산로직 확인테스트")
+    @ParameterizedTest
+    @MethodSource("ValuesByRank")
+    void compareLottosTest(Lottos purchasedLottos,  Map<String, Long> expectedResults) {
+        //given
+
+        Lotto winningLotto = new Lotto(List.of(1, 2, 3, 4, 5, 6));
+        int bonusNumber = 7;
+        //when
+        Map<String, Long> purchasedLottosResult = Lottos.compareLottos(purchasedLottos, winningLotto, bonusNumber);
+        //then
+        Assertions.assertThat(purchasedLottosResult)
+                .isEqualTo(expectedResults);
+    }
+
+    static Stream<Arguments> ValuesByRank() {
+        return Stream.of(
+                Arguments.of(new Lottos(List.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 6)) // 1등
+                )), Map.of(
+                        "3개 일치 (5,000원) - ", 0L,
+                        "4개 일치 (50,000원) - ", 0L,
+                        "5개 일치 (1,500,000원) - ", 0L,
+                        "5개 일치, 보너스 볼 일치 (30,000,000원) - ", 0L,
+                        "6개 일치 (2,000,000,000원) - ", 1L
+                )),
+                Arguments.of(new Lottos(List.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 7)) // 2등
+                )), Map.of(
+                        "3개 일치 (5,000원) - ", 0L,
+                        "4개 일치 (50,000원) - ", 0L,
+                        "5개 일치 (1,500,000원) - ", 0L,
+                        "5개 일치, 보너스 볼 일치 (30,000,000원) - ", 1L,
+                        "6개 일치 (2,000,000,000원) - ", 0L
+                )),
+                Arguments.of(new Lottos(List.of(
+                        new Lotto(List.of(1, 2, 3, 4, 5, 8)) // 3등
+                )), Map.of(
+                        "3개 일치 (5,000원) - ", 0L,
+                        "4개 일치 (50,000원) - ", 0L,
+                        "5개 일치 (1,500,000원) - ", 1L,
+                        "5개 일치, 보너스 볼 일치 (30,000,000원) - ", 0L,
+                        "6개 일치 (2,000,000,000원) - ", 0L
+                )),
+                Arguments.of(new Lottos(List.of(
+                        new Lotto(List.of(1, 2, 3, 4, 8, 9)) // 4등
+                )), Map.of(
+                        "3개 일치 (5,000원) - ", 0L,
+                        "4개 일치 (50,000원) - ", 1L,
+                        "5개 일치 (1,500,000원) - ", 0L,
+                        "5개 일치, 보너스 볼 일치 (30,000,000원) - ", 0L,
+                        "6개 일치 (2,000,000,000원) - ", 0L
+                )),
+                Arguments.of(new Lottos(List.of(
+                        new Lotto(List.of(1, 2, 3, 8, 9, 10)) // 5등
+                )), Map.of(
+                        "3개 일치 (5,000원) - ", 1L,
+                        "4개 일치 (50,000원) - ", 0L,
+                        "5개 일치 (1,500,000원) - ", 0L,
+                        "5개 일치, 보너스 볼 일치 (30,000,000원) - ", 0L,
+                        "6개 일치 (2,000,000,000원) - ", 0L
+                ))
+        );
+}
+
+
+}
\ No newline at end of file