diff --git a/README.md b/README.md
new file mode 100644
index 00000000..e5b08ef0
--- /dev/null
+++ b/README.md
@@ -0,0 +1,48 @@
+## 🔨 구현 기능 목록
+
+### 입력
+
+- 구입 금액 입력
+    - 한 장당 1000원
+    - 1000원으로 나누어 떨어지지 않으면 예외 처리
+- 수동으로 구매할 로또 수 입력
+  - 숫자 외의 입력은 모두 예외처리
+- 수동으로 구매할 로또 번호 입력
+  - 번호는 쉼표(,)로 구분
+  - 숫자와 쉼표(,) 외의 입력은 모두 예외 처리
+  - 6개가 되지 않는다면 예외 처리
+- 당첨 번호 입력
+  - 번호는 쉼표(,)로 구분
+  - 숫자와 쉼표(,) 외의 입력은 모두 예외 처리
+  - 6개가 되지 않는다면 예외 처리
+- 보너스 번호 입력
+  - 숫자 외의 입력은 모두 예외처리
+
+
+### 출력
+
+
+- 수동 로또와 자동 로또 발행
+    - 오름차순으로 정렬해서 보여줌
+    - 중복되지 않는 6개 숫자
+- 당첨 내역 출력
+    - `3개 일치 (5000원) - n개`
+    - `4개 일치 (50000원) - n개`
+    - `5개 일치 (1500000원) - n개`
+    - `5개 일치, 보너스 볼 일치 (30000000원) - n개`
+    - `6개 일치 (2000000000원) - n개`
+- 수익률 출력
+    - `총 수익률은 n입니다.`
+    - 소숫점 둘째자리 밑으론 버림
+- 예외 상황시 에러 문구 출력
+    - `[ERROR] error message`
+
+### 게임 진행
+
+- 구입 금액을 입력
+- 수동으로 구매할 로또 수 입력
+- 수동 로또 번호 입력
+- 로또 번호 1~45 사이의 중복되지 않는 정수로 6개 무작위 추첨해서 구입한 개수(수동 로또 개수 제외) 만큼 자동 로또 발행
+- 당첨 번호와 보너스 번호를 입력받음
+- 일치하는 내역과 총 수익률을 출력
+- 예외가 발생할 경우 예외 문구 출력
\ No newline at end of file
diff --git a/src/main/java/Application.java b/src/main/java/Application.java
new file mode 100644
index 00000000..bf82be8e
--- /dev/null
+++ b/src/main/java/Application.java
@@ -0,0 +1,11 @@
+import controller.LottoController;
+
+import java.io.IOException;
+
+public class Application {
+
+    public static void main(String [] args) throws IOException {
+        LottoController lottoController  = new LottoController();
+        lottoController.startLottoGame();
+    }
+}
diff --git a/src/main/java/controller/LottoController.java b/src/main/java/controller/LottoController.java
new file mode 100644
index 00000000..b7b9ee73
--- /dev/null
+++ b/src/main/java/controller/LottoController.java
@@ -0,0 +1,145 @@
+package controller;
+
+import model.*;
+import view.InputView;
+import view.OutputView;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+public class LottoController {
+    private InputView inputView = new InputView();
+    private OutputView outputView = new OutputView();
+    private LottoList lottoList;
+
+    public LottoController() {
+    }
+    public void startLottoGame() {
+        UserCount userMoney = receiveMoneyInput();
+        ManualCount manualCount = manualLottoCount();
+        if(manualCount.getManualCount() == 0){
+            displayLottoTickets(userMoney, null);
+        }
+        else{
+            displayLottoTickets(userMoney, manualLottoNumbers(manualCount.getManualCount()));
+        }
+        Lotto winningNumbers = getWinningNumbers();
+        BonusNumber bonusNum = receiveBonusNumberInput();
+        validateDuplicate(winningNumbers, bonusNum);
+
+        List<Integer> matchCounts = calculateMatches(lottoList, winningNumbers, bonusNum);
+        double winRate = calculateWinningRate(matchCounts, userMoney);
+        outputView.printResults(matchCounts, Math.floor(winRate*100)/100 );
+    }
+    private ManualCount manualLottoCount(){
+        return new ManualCount(inputView.inputManualLottoCount());
+    }
+    private List<Lotto> manualLottoNumbers(int count){
+        List<String> manualLottoNums = inputView.manualLottos(count);
+        List<Lotto> manualLottos = new ArrayList<>();
+
+        for (String manualLotto : manualLottoNums) {
+            Lotto lotto = new Lotto();
+            manualLottos.add(lotto.convertToList(manualLotto));
+        }
+        return manualLottos;
+    }
+
+    private BonusNumber receiveBonusNumberInput() {
+        return new BonusNumber(inputView.inputBonusNumber());
+    }
+
+    private void validateDuplicate(Lotto winningLotto, BonusNumber bonusNumber){
+        winningLotto.validateDuplicateWithBonus(bonusNumber.getBonusNumber());
+    }
+
+    private UserCount receiveMoneyInput() {
+        return new UserCount(inputView.inputPrice());
+    }
+
+    private void displayLottoTickets(UserCount count, List<Lotto> lottos){
+        int autoCount = 0;
+        int manualCount = 0;
+        if(lottos == null){
+            autoCount = count.getCount();
+            manualCount = 0;
+        }
+        else{
+            autoCount = count.getCount() - lottos.size();
+            manualCount = lottos.size();
+        }
+        outputView.printTicketCount(autoCount, manualCount);
+        lottoList = generateLottoList(autoCount, lottos);
+        outputView.printLottoNumbers(lottoList);
+    }
+    LottoList generateLottoList(int count, List<Lotto> lottos){
+        lottoList = new LottoList();
+
+        if(lottos != null){
+            for (Lotto lotto : lottos) {
+                lottoList.setLottoList(lotto);
+            }
+        }
+        for(int i=0; i<count; i++){
+            lottoList.setLottoList(generateLotto());
+        }
+        return lottoList;
+    }
+    private Lotto generateLotto(){
+        List<Integer> numbers = new ArrayList<>();
+        AutoLotto autoLotto = new AutoLotto();
+        numbers = autoLotto.getAutoLotto();
+        return new Lotto(numbers);
+    }
+
+    private Lotto getWinningNumbers(){
+        String winnerNumbersStr = inputView.inputWinnerNumber();
+        Lotto winningLotto = new Lotto();
+        return winningLotto.convertToList(winnerNumbersStr);
+    }
+
+
+    private List<Integer> calculateMatches(LottoList ticketList, Lotto winningNumbers, BonusNumber bonusNum) {
+        List<Integer> matchCounts = new ArrayList<>(Arrays.asList(0, 0, 0, 0, 0));
+
+        for (Lotto ticket : ticketList.getLottoList()) {
+            int countMatches = ticket.calculateMatches(winningNumbers);
+            updateMatchCounts(matchCounts, countMatches, bonusNum);
+        }
+
+        return matchCounts;
+    }
+
+
+    private void updateMatchCounts(List<Integer> matchCounts, int countMatches, BonusNumber bonusNum) {
+        Predicate<Integer> isBonusMatch = num -> num == 5 && bonusNum.getBonusNumber() > 0;
+
+        if (countMatches == 3) {
+            matchCounts.set(0, matchCounts.get(0) + 1);
+        } else if (countMatches == 4) {
+            matchCounts.set(1, matchCounts.get(1) + 1);
+        } else if (countMatches == 5) {
+            if (isBonusMatch.test(countMatches)) {
+                matchCounts.set(3, matchCounts.get(3) + 1);
+            } else {
+                matchCounts.set(2, matchCounts.get(2) + 1);
+            }
+        } else if (countMatches == 6) {
+            matchCounts.set(4, matchCounts.get(4) + 1);
+        }
+
+    }
+    double calculateWinningRate(List<Integer> matchCounts, UserCount count) {
+        int totalWinnings = matchCounts.get(0) * 5000 +
+                matchCounts.get(1) * 50000 +
+                matchCounts.get(2) * 1500000 +
+                matchCounts.get(3) * 30000000 +
+                matchCounts.get(4) * 2000000000;
+
+        double winningRate = (double) totalWinnings / (double) count.getPrice();
+        return Math.floor(winningRate * 100) / 100;
+    }
+
+}
diff --git a/src/main/java/model/AutoLotto.java b/src/main/java/model/AutoLotto.java
new file mode 100644
index 00000000..d7f65064
--- /dev/null
+++ b/src/main/java/model/AutoLotto.java
@@ -0,0 +1,36 @@
+package model;
+
+import java.util.*;
+
+public class AutoLotto {
+    private static final int MIN_LOTTO_NUMBER = 1;
+    private static final int MAX_LOTTO_NUMBER = 45;
+    private static final int CNT_LOTTO_NUMBER = 6;
+
+    private static List<Integer> lottoNums = new ArrayList<>();
+    public AutoLotto(){
+        createAutoLotto();
+    }
+    public void createAutoLotto(){
+
+        List<Integer> numbers = new ArrayList<>();
+        for (int i = MIN_LOTTO_NUMBER; i <= MAX_LOTTO_NUMBER; i++) {
+            numbers.add(i);
+        }
+        Collections.shuffle(numbers);
+        lottoNums = new ArrayList<>();
+        for (int i = 0; i < CNT_LOTTO_NUMBER; i++) {
+            int uniqueNumber = numbers.get(i);
+            while (lottoNums.contains(uniqueNumber)) {
+                Collections.shuffle(numbers);
+                uniqueNumber = numbers.get(i);
+            }
+            lottoNums.add(uniqueNumber);
+        }
+        Collections.sort(lottoNums);
+    }
+    public List<Integer> getAutoLotto(){
+        return lottoNums;
+    }
+
+}
diff --git a/src/main/java/model/BonusNumber.java b/src/main/java/model/BonusNumber.java
new file mode 100644
index 00000000..8bbea538
--- /dev/null
+++ b/src/main/java/model/BonusNumber.java
@@ -0,0 +1,23 @@
+package model;
+
+public class BonusNumber {
+
+    private int bonusNumber;
+
+    public BonusNumber(String bonusNumber){
+        this.bonusNumber = convertStringToInt(bonusNumber)
+        ;
+    }
+
+    public int convertStringToInt(String bonusNumber){
+        try {
+            return Integer.parseInt(bonusNumber);
+        } catch (NumberFormatException e) {
+            System.err.println("[ERROR] 숫자로만 입력해주세요.");
+            throw e;
+        }
+    }
+    public int getBonusNumber(){
+        return bonusNumber;
+    }
+}
diff --git a/src/main/java/model/Lotto.java b/src/main/java/model/Lotto.java
new file mode 100644
index 00000000..cc4ac863
--- /dev/null
+++ b/src/main/java/model/Lotto.java
@@ -0,0 +1,78 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Lotto {
+    private static final int BONUS_NUMBER_INDEX = 6;
+    private List<Integer> numbers;
+
+    public Lotto(List<Integer> numbers) {
+        this.numbers = numbers;
+    }
+    public Lotto(){
+    }
+    public Lotto convertToList(String lottoNumbersStr) {
+        String[] str = lottoNumbersStr.split(",\\s*");
+        List<Integer> lottoList = new ArrayList<>();
+        for (String s : str) {
+            lottoList.add(convertStringToInt(s));
+        }
+
+        Lotto lotto = new Lotto(lottoList);
+        validate(lotto.getNumbers());
+        return lotto;
+    }
+    private int convertStringToInt(String price){
+        try {
+            return Integer.parseInt(price);
+        } catch (NumberFormatException e) {
+            System.err.println("[ERROR] 숫자로만 입력해주세요.");
+            throw e;
+        }
+    }
+    private void validate(List<Integer> numbers){
+        validateSize(numbers);
+        validateRange(numbers);
+        validateDuplicate(numbers);
+    }
+    void validateSize(List<Integer> numbers){
+        if(numbers.size() != 6){
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 6개 입력해야 합니다.");
+        }
+    }
+    void validateRange(List<Integer> numbers){
+        for(int num : numbers){
+            if(num<=0||num>45){
+                throw new IllegalArgumentException("[ERROR] 로또 번호는 1부터 45 사이의 숫자로 입력해야 합니다.");
+            }
+        }
+    }
+    void validateDuplicate(List<Integer> numbers){
+        List<Integer> tmp = numbers;
+        if(tmp.stream().distinct().count()!=numbers.size()){
+            throw new IllegalArgumentException("[ERROR] 로또 번호에 중복된 숫자가 있습니다.");
+        }
+
+    }
+    public List<Integer>getNumbers(){
+        return numbers;
+    }
+
+    public int calculateMatches(Lotto winningLotto) {
+        int cnt = 0;
+        List<Integer> winningLottoList = winningLotto.getNumbers();
+        for (Integer integer : winningLottoList) {
+            if(numbers.contains(integer)){
+                cnt ++;
+            }
+        }
+        return cnt;
+    }
+
+    public void validateDuplicateWithBonus(int bonusNumber) {
+        if (numbers.contains(bonusNumber)) {
+            throw new IllegalArgumentException("[ERROR] 보너스 번호는 당첨 번호와 중복되어서는 안 됩니다.");
+        }
+    }
+}
diff --git a/src/main/java/model/LottoList.java b/src/main/java/model/LottoList.java
new file mode 100644
index 00000000..ce3ef403
--- /dev/null
+++ b/src/main/java/model/LottoList.java
@@ -0,0 +1,18 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LottoList {
+    List<Lotto> lottoList = new ArrayList<>();
+    private int totalPrice;
+    public LottoList(){
+
+    }
+    public void setLottoList(Lotto lotto){
+        lottoList.add(lotto);
+    }
+    public List<Lotto> getLottoList(){
+        return lottoList;
+    }
+}
diff --git a/src/main/java/model/ManualCount.java b/src/main/java/model/ManualCount.java
new file mode 100644
index 00000000..c97da843
--- /dev/null
+++ b/src/main/java/model/ManualCount.java
@@ -0,0 +1,25 @@
+package model;
+
+public class ManualCount {
+    private int manualCount;
+
+    public ManualCount(){
+
+    }
+    public ManualCount(String manualCount){
+        this.manualCount = convertStringToInt(manualCount)
+        ;
+    }
+
+    public int convertStringToInt(String manualCount){
+        try {
+            return Integer.parseInt(manualCount);
+        } catch (NumberFormatException e) {
+            System.err.println("[ERROR] 숫자로만 입력해주세요.");
+            throw e;
+        }
+    }
+    public int getManualCount(){
+        return manualCount;
+    }
+}
diff --git a/src/main/java/model/UserCount.java b/src/main/java/model/UserCount.java
new file mode 100644
index 00000000..1f366a13
--- /dev/null
+++ b/src/main/java/model/UserCount.java
@@ -0,0 +1,50 @@
+package model;
+
+public class UserCount {
+
+    private static final int LOTTO_UNIT = 1000;
+
+    private int count;
+    private int price;
+
+    public UserCount(){
+    }
+    public UserCount(String price){
+        int priceNum = convertStringToInt(price);
+        validate(priceNum);
+        this.price = priceNum;
+        this.count = calculateCount(priceNum);
+    }
+    public int calculateCount(int price){
+        return price/1000;
+    }
+    public int getCount(){
+        return count;
+    }
+    public int getPrice(){
+        return price;
+    }
+    public int convertStringToInt(String price){
+        try {
+            return Integer.parseInt(price);
+        } catch (NumberFormatException e) {
+            System.err.println("[ERROR] 숫자로만 입력해주세요.");
+            throw e;
+        }
+    }
+
+    public void validate(int priceNum){
+        validateRange(priceNum);
+        validateUnit(priceNum);
+    }
+    public void validateRange(int priceNum){
+        if(priceNum<=0){
+            throw new IllegalArgumentException("[ERROR] 0원 이하는 구매가 불가능합니다");
+        }
+    }
+    public void validateUnit(int priceNum){
+        if(priceNum % LOTTO_UNIT != 0){
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 1000원 단위로 입력되어야 합니다.");
+        }
+    }
+}
diff --git a/src/main/java/model/WinningType.java b/src/main/java/model/WinningType.java
new file mode 100644
index 00000000..2212a341
--- /dev/null
+++ b/src/main/java/model/WinningType.java
@@ -0,0 +1,23 @@
+package model;
+
+public enum WinningType {
+    FIFTH(3, 5000, "3개 일치 (5000원)- "),
+    FOURTH(4, 50000, "4개 일치 (50000원)- "),
+    THIRD(5, 150000, "5개 일치 (1500000원)- "),
+    SECOND(5, 30000000, "5개 일치, 보너스 볼 일치(30000000원)- "),
+    FIRTH(6, 2000000000, "6개 일치 (2000000000원)- ");
+
+    private static final int WINNING_MIN_COUNT = 3;
+    private static final String ERROR_MESSAGE = "[ERROR]";
+
+    private String message;
+
+    WinningType(int countOfCorrect, int reward, String message) {
+        this.message = message;
+    }
+
+    public String getMessage(){
+        return message;
+    }
+
+}
diff --git a/src/main/java/view/InputView.java b/src/main/java/view/InputView.java
new file mode 100644
index 00000000..fdae7afc
--- /dev/null
+++ b/src/main/java/view/InputView.java
@@ -0,0 +1,52 @@
+package view;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+
+    private final static String INPUT_PRICE = "구입금액을 입력해 주세요.";
+    private final static String MANUAL_BUY_LOTTO = "수동으로 구매할 로또 수를 입력해 주세요.";
+    private final static String INPUT_MANUAL_LOTTO_NUMBERS = "수동으로 구매할 번호를 입력해 주세요.";
+    private final static String INPUT_WINNER_NUMBER = "지난 주 당첨 번호를 입력해 주세요.";
+    private final static String INPUT_BONUS_NUMBER = "보너스 볼을 입력해 주세요.";
+
+
+    private static final Scanner scanner = new Scanner(System.in);
+
+
+    public String inputPrice(){
+        System.out.println(INPUT_PRICE);
+        return scanner.nextLine();
+    }
+
+    public String inputManualLottoCount(){
+        System.out.println();
+        System.out.println(MANUAL_BUY_LOTTO);
+        return scanner.nextLine();
+    }
+
+    public List<String> manualLottos(int cnt){
+        System.out.println();
+        System.out.println(INPUT_MANUAL_LOTTO_NUMBERS);
+        List<String> manualLottoNums = new ArrayList<>();
+        for (int i = 0; i < cnt; i++) {
+            manualLottoNums.add(scanner.nextLine());
+        }
+        return manualLottoNums;
+    }
+
+    public String inputWinnerNumber(){
+        System.out.println();
+        System.out.println(INPUT_WINNER_NUMBER);
+        return scanner.nextLine();
+    }
+
+    public String inputBonusNumber(){
+
+        System.out.println();
+        System.out.println(INPUT_BONUS_NUMBER);
+        return scanner.nextLine();
+    }
+}
diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java
new file mode 100644
index 00000000..3bd253d7
--- /dev/null
+++ b/src/main/java/view/OutputView.java
@@ -0,0 +1,58 @@
+package view;
+
+import model.Lotto;
+import model.LottoList;
+import model.WinningType;
+
+import java.util.List;
+
+public class OutputView {
+
+    private final static String BUY_MESSAGE = "수동으로 %d장, 자동으로 %d개를 구매했습니다.";
+    private final static String COUNT_SUFFIX = "개";
+
+
+    public void printTicketCount (int autoCount, int manualCount){
+        System.out.println();
+        String message = String.format(BUY_MESSAGE, manualCount, autoCount);
+        System.out.println(message);    }
+    public void printLottoNumbers(LottoList lottoList) {
+        List<Lotto> lottos = lottoList.getLottoList();
+        for (Lotto lotto : lottos) {
+            System.out.println(lotto.getNumbers());
+        }
+    }
+
+    public void printResults(List<Integer> matchCounts, double rate) {
+        printResultHeader();
+        printMatchCounts(matchCounts);
+        printWinningRate(rate);
+    }
+
+    private void printResultHeader() {
+        System.out.println();
+        System.out.println("당첨 통계");
+        System.out.println("---------");
+    }
+
+    private void printMatchCounts(List<Integer> matchCounts) {
+        WinningType[] winningTypes = WinningType.values();
+
+        for (int i = 0; i < matchCounts.size(); i++) {
+            WinningType type = winningTypes[i];
+            int count = matchCounts.get(i);
+
+            String message = getMessageForWinningType(type, count);
+            System.out.println(message);
+        }
+    }
+    private String getMessageForWinningType(WinningType type, int count) {
+        String message = type.getMessage();
+        return message + count + COUNT_SUFFIX + " - " + count + "개";
+
+    }
+
+    private void printWinningRate(double rate) {
+        System.out.printf("총 수익률은 %.2f 입니다. (기준이 1이기 때문에 결과적으로 손해라는 의미임)%n", rate);
+    }
+}
diff --git a/src/test/java/controller/LottoControllerTest.java b/src/test/java/controller/LottoControllerTest.java
new file mode 100644
index 00000000..d146526b
--- /dev/null
+++ b/src/test/java/controller/LottoControllerTest.java
@@ -0,0 +1,47 @@
+package controller;
+
+import model.Lotto;
+import model.LottoList;
+import model.UserCount;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LottoControllerTest {
+    @Test
+    void testCalculateWinningRate() {
+        // Given
+        LottoController controller = new LottoController();
+        List<Integer> matchCounts = Arrays.asList(1, 0, 0, 0, 0, 0);
+        String price = "14000";
+        double priceNum = 14000.0;
+        UserCount userCount = new UserCount(price);
+
+        // When
+        double winningRate = controller.calculateWinningRate(matchCounts, userCount);
+
+        // Then
+        double expectedRate = (double) (1 * 5000 + 0 * 50000 + 0 * 150000 + 0 * 30000000 + 0 * 2000000000) / priceNum;
+        expectedRate = Math.floor(expectedRate * 100) / 100;
+        System.out.println("dd" + winningRate);
+        assertEquals(expectedRate, winningRate);
+    }
+
+    @Test
+    void testGenerateLottoList() {
+        // Given
+        LottoController controller = new LottoController();
+        int count = 5;
+
+        // When
+        LottoList lottoList = controller.generateLottoList(count, null);
+
+        // Then
+        List<Lotto> lottos = lottoList.getLottoList();
+        assertEquals(count, lottos.size());
+
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/model/BonusNumberTest.java b/src/test/java/model/BonusNumberTest.java
new file mode 100644
index 00000000..a005c39a
--- /dev/null
+++ b/src/test/java/model/BonusNumberTest.java
@@ -0,0 +1,21 @@
+package model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BonusNumberTest {
+    @Test
+    void bonus_ValidInput() {
+        String bonusNumberStr = "10";
+        BonusNumber bonusNumber = new BonusNumber(bonusNumberStr);
+
+        assertEquals(10, bonusNumber.getBonusNumber());
+    }
+
+    @Test
+    void bonus_InvalidInput() {
+        String bonusNumberStr = "ABC";
+        assertThrows(NumberFormatException.class, () -> new BonusNumber(bonusNumberStr));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/model/LottoTest.java b/src/test/java/model/LottoTest.java
new file mode 100644
index 00000000..923b559c
--- /dev/null
+++ b/src/test/java/model/LottoTest.java
@@ -0,0 +1,92 @@
+package model;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LottoTest {
+    @Test
+    void convertToList_ValidInput() {
+        String lottoNumbersStr = "1, 2, 3, 4, 5, 6";
+        Lotto lotto = new Lotto().convertToList(lottoNumbersStr);
+
+        List<Integer> expectedNumbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+        assertEquals(expectedNumbers, lotto.getNumbers());
+    }
+
+    @Test
+    void convertToList_InvalidInput() {
+        String lottoNumbersStr = "1, 2, 3, 4, A, 6";
+        assertThrows(NumberFormatException.class, () -> new Lotto().convertToList(lottoNumbersStr));
+    }
+
+    @Test
+    void validateSize_ValidSize() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+        Lotto lotto = new Lotto(numbers);
+        assertDoesNotThrow(() -> lotto.validateSize(numbers));
+    }
+
+    @Test
+    void validateSize_InvalidSize() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
+        Lotto lotto = new Lotto(numbers);
+        assertThrows(IllegalArgumentException.class, () -> lotto.validateSize(numbers));
+    }
+
+    @Test
+    void validateRange_ValidRange() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+        Lotto lotto = new Lotto(numbers);
+        assertDoesNotThrow(() -> lotto.validateRange(numbers));
+    }
+
+    @Test
+    void validateRange_InvalidRange() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 50, 6);
+        Lotto lotto = new Lotto(numbers);
+        assertThrows(IllegalArgumentException.class, () -> lotto.validateRange(numbers));
+    }
+
+    @Test
+    void validateDuplicate_NoDuplicates() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+        Lotto lotto = new Lotto(numbers);
+        assertDoesNotThrow(() -> lotto.validateDuplicate(numbers));
+    }
+
+    @Test
+    void validateDuplicate_DuplicateNumbers() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 4, 6);
+        Lotto lotto = new Lotto(numbers);
+        assertThrows(IllegalArgumentException.class, () -> lotto.validateDuplicate(numbers));
+    }
+
+    @Test
+    void calculateMatches_WithWinningLotto() {
+        List<Integer> myNumbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+        Lotto myLotto = new Lotto(myNumbers);
+
+        List<Integer> winningNumbers = Arrays.asList(1, 3, 5, 7, 9, 11);
+        Lotto winningLotto = new Lotto(winningNumbers);
+
+        assertEquals(3, myLotto.calculateMatches(winningLotto));
+    }
+
+    @Test
+    void validateDuplicateWithBonus_ValidBonusNumber() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+        Lotto lotto = new Lotto(numbers);
+        assertDoesNotThrow(() -> lotto.validateDuplicateWithBonus(7));
+    }
+
+    @Test
+    void validateDuplicateWithBonus_InvalidBonusNumber() {
+        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
+        Lotto lotto = new Lotto(numbers);
+        assertThrows(IllegalArgumentException.class, () -> lotto.validateDuplicateWithBonus(6));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/model/ManualCountTest.java b/src/test/java/model/ManualCountTest.java
new file mode 100644
index 00000000..7a82b1b8
--- /dev/null
+++ b/src/test/java/model/ManualCountTest.java
@@ -0,0 +1,43 @@
+package model;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ManualCountTest {
+
+    @Test
+    void validManualCount() {
+        String manualCountStr = "5";
+        ManualCount manualCount = new ManualCount(manualCountStr);
+
+        assertEquals(5, manualCount.getManualCount());
+    }
+
+    @Test
+    void invalidInput() {
+        String manualCountStr = "abc";
+        assertThrows(NumberFormatException.class, () -> new ManualCount(manualCountStr));
+    }
+
+    @Test
+    void getManualCount() {
+        String manualCountStr = "10";
+        ManualCount manualCount = new ManualCount(manualCountStr);
+
+        assertEquals(10, manualCount.getManualCount());
+    }
+
+    @Test
+    void convertStringToInt_ValidInput() {
+        ManualCount manualCount = new ManualCount();
+        assertEquals(15, manualCount.convertStringToInt("15"));
+    }
+
+    @Test
+    void convertStringToInt_InvalidInput() {
+        ManualCount manualCount = new ManualCount();
+        assertThrows(NumberFormatException.class, () -> manualCount.convertStringToInt("abc"));
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/model/UserCountTest.java b/src/test/java/model/UserCountTest.java
new file mode 100644
index 00000000..4a50deec
--- /dev/null
+++ b/src/test/java/model/UserCountTest.java
@@ -0,0 +1,81 @@
+package model;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserCountTest {
+
+    @Test
+    void validPrice() {
+        String priceStr = "3000";
+        UserCount userCount = new UserCount(priceStr);
+
+        assertEquals(3000, userCount.getPrice());
+        assertEquals(3, userCount.getCount());
+    }
+
+    @Test
+    void invalidZeroPrice() {
+        String priceStr = "0";
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> new UserCount(priceStr));
+        assertEquals("[ERROR] 0원 이하는 구매가 불가능합니다", exception.getMessage());
+    }
+
+    @Test
+    void invalidNegativePrice() {
+        String priceStr = "-5000";
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> new UserCount(priceStr));
+        assertEquals("[ERROR] 0원 이하는 구매가 불가능합니다", exception.getMessage());
+    }
+
+    @Test
+    void invalidNonMultipleOf1000() {
+        String priceStr = "2500";
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> new UserCount(priceStr));
+        assertEquals("[ERROR] 구입 금액은 1000원 단위로 입력되어야 합니다.", exception.getMessage());
+    }
+
+    @Test
+    void calculateCount_ValidPrice() {
+        UserCount userCount = new UserCount("4000");
+        assertEquals(4, userCount.getCount());
+    }
+
+    @Test
+    void convertStringToInt_ValidInput() {
+        UserCount userCount = new UserCount();
+        assertEquals(5000, userCount.convertStringToInt("5000"));
+    }
+
+    @Test
+    void convertStringToInt_InvalidInput() {
+        UserCount userCount = new UserCount();
+        assertThrows(NumberFormatException.class, () -> userCount.convertStringToInt("abc"));
+    }
+
+    @Test
+    void validateRange_ValidPrice() {
+        UserCount userCount = new UserCount();
+        assertDoesNotThrow(() -> userCount.validateRange(2000));
+    }
+
+    @Test
+    void validateRange_InvalidZeroPrice() {
+        UserCount userCount = new UserCount();
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> userCount.validateRange(0));
+        assertEquals("[ERROR] 0원 이하는 구매가 불가능합니다", exception.getMessage());
+    }
+
+    @Test
+    void validateUnit_ValidPrice() {
+        UserCount userCount = new UserCount();
+        assertDoesNotThrow(() -> userCount.validateUnit(3000));
+    }
+
+    @Test
+    void validateUnit_InvalidNonMultipleOf1000() {
+        UserCount userCount = new UserCount();
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> userCount.validateUnit(2500));
+        assertEquals("[ERROR] 구입 금액은 1000원 단위로 입력되어야 합니다.", exception.getMessage());
+    }
+}