diff --git a/README.md b/README.md
index bfe63c4bc..a7573d364 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,9 @@
 - 로또 1장의 가격은 1,000원이다.
 - 2등을 위해 추가 번호를 하나 더 추첨한다.
 - 당첨 통계에 2등도 추가해야 한다.
-
+- 현재 로또 생성기는 자동 생성 기능만 제공한다. 사용자가 수동으로 추첨 번호를 입력할 수 있도록 해야 한다.
+- 입력한 금액, 자동 생성 숫자, 수동 생성 번호를 입력하도록 해야 한다.
+- 
 ## 기능 설계
 - [x] 로또 번호는 1부터 45사이 값이 아니면 에러가 발생한다
 - [x] 로또 번호는 value class로 관리된다
@@ -13,9 +15,9 @@
 - [x] 비용을 지불해 한번에 여러장 로또를 구입할 수 있다
   - [x] 로또 구입 비용이 1,000원 미만일 경우 에러가 발생한다
   - [x] 로또 구입 비용이 1,000원 단위가 아닐 경우 에러가 발생한다
-  - [x] 로또 구입 비용에 대해 몇 장의 로또가 구입 됐는지 확인활 수 있다
-- [x] 로또 번호가 1부터 45사이의 숫자가 아니면 에러가 발생한다
-- [x] 로또 번호를 6개로 지정할 경우가 아니면 에러가 발생한다 (예를 들어 5개 또는 7개)
+  - [x] 로또 구입 비용에 대해 몇 장의 로또가 구입될 수 있는지 확인활 수 있다
+- [x] 로또 번호를 수동으로 부여할 수 있다
+- [x] 수동 로또를 여러개 구입할 수 있다
 - [x] 로또 번호를 자동으로 부여한다
   - [x] 로또 번호는 1부터 45사이의 중복되지 않는 숫자 6개로 이루어져야한다
 - [x] 로또 당첨 번호를 입력할 수 있다
diff --git a/src/main/kotlin/lotto/application/LottoApplication.kt b/src/main/kotlin/lotto/application/LottoApplication.kt
index baa98f27d..3d60941df 100644
--- a/src/main/kotlin/lotto/application/LottoApplication.kt
+++ b/src/main/kotlin/lotto/application/LottoApplication.kt
@@ -3,7 +3,10 @@ package lotto.application
 import lotto.controller.LottoController
 
 fun main() {
-    val purchasedLottoTickets = LottoController.purchaseLotto()
+    val maxPurchaseLottoCount = LottoController.getMaxPurchaseLottoCountFromPayment()
+    val manualLottoTickets = LottoController.purchaseManualLotto(maxPurchaseLottoCount)
+    val totalLottoTickets = LottoController.createAutoLotto(maxPurchaseLottoCount, manualLottoTickets)
     val lottoWinnerNumbers = LottoController.createWinningLottoNumbers()
-    LottoController.resultPayout(purchasedLottoTickets = purchasedLottoTickets, lottoWinnerNumbers = lottoWinnerNumbers)
+
+    LottoController.resultPayout(lottoTickets = totalLottoTickets, lottoWinnerNumbers = lottoWinnerNumbers)
 }
diff --git a/src/main/kotlin/lotto/controller/LottoController.kt b/src/main/kotlin/lotto/controller/LottoController.kt
index c47243157..3523e5562 100644
--- a/src/main/kotlin/lotto/controller/LottoController.kt
+++ b/src/main/kotlin/lotto/controller/LottoController.kt
@@ -1,40 +1,59 @@
 package lotto.controller
 
-import lotto.domain.LottoNumber
-import lotto.domain.LottoNumbers
-import lotto.domain.LottoTicketIssuer
+import lotto.domain.AutoLottoIssuer
+import lotto.domain.LottoNumberGenerator
+import lotto.domain.LottoPurchaseCalculator
+import lotto.domain.LottoTickets
 import lotto.domain.LottoWinnerNumbers
-import lotto.domain.PurchasedLottoTickets
-import lotto.domain.generateLottoNumbers
 import lotto.view.LottoPayoutView
-import lotto.view.PurchaseLottoResultView
+import lotto.view.ManualLottoView
 import lotto.view.PurchaseLottoView
 import lotto.view.WinnerLottoNumberView
 
 object LottoController {
-    fun purchaseLotto(): PurchasedLottoTickets {
+    fun getMaxPurchaseLottoCountFromPayment(): Int {
         val amountPaid = PurchaseLottoView.inputPurchaseCost()
+        return LottoPurchaseCalculator.getMaxPurchasedLottoTicketCount(amountPaid)
+    }
+
+    fun purchaseManualLotto(maxPurchaseLottoCount: Int): LottoTickets {
+        val manualLottoCount = ManualLottoView.inputManualLottoCount(maxPurchaseLottoCount)
+        return ManualLottoView.repeatInputManualLottoNumbers(manualLottoCount)
+    }
 
-        val purchasedLottoTickets =
-            LottoTicketIssuer.issueTickets(amountPaid = amountPaid, generateLottoNumbers = { generateLottoNumbers() })
+    fun createAutoLotto(
+        maxPurchaseLottoCount: Int,
+        manualLottoTickets: LottoTickets,
+    ): LottoTickets {
+        val autoLottoCount = maxPurchaseLottoCount - manualLottoTickets.lottoTickets.size
 
-        PurchaseLottoResultView.displayPurchaseLottoResults(purchasedLottoTickets = purchasedLottoTickets)
+        val autoLottoTickets =
+            AutoLottoIssuer.issueAutoLottoTickets(autoLottoCount) {
+                LottoNumberGenerator.generateAutoLottoNumbers()
+            }
 
-        return purchasedLottoTickets
+        PurchaseLottoView.displayPurchasedLottosView(
+            manualLottoTickets = manualLottoTickets,
+            autoLottoTickets = autoLottoTickets,
+        )
+
+        val combinedManualLottoAndAutoLotto = manualLottoTickets.lottoTickets.plus(autoLottoTickets.lottoTickets)
+
+        return LottoTickets(combinedManualLottoAndAutoLotto)
     }
 
     fun createWinningLottoNumbers(): LottoWinnerNumbers {
         val inputLottoNumbers = WinnerLottoNumberView.inputWinningLottoNumbers()
-        val lottoNumbers = LottoNumbers(inputLottoNumbers.map { LottoNumber.of(it) }.toSet())
         val inputBonusNumber = WinnerLottoNumberView.inputBonusNumber()
-        return LottoWinnerNumbers(lottoNumbers = lottoNumbers, bonusNumber = LottoNumber.of(inputBonusNumber))
+
+        return LottoWinnerNumbers(lottoNumbers = inputLottoNumbers, bonusNumber = inputBonusNumber)
     }
 
     fun resultPayout(
-        purchasedLottoTickets: PurchasedLottoTickets,
+        lottoTickets: LottoTickets,
         lottoWinnerNumbers: LottoWinnerNumbers,
     ) {
-        val purchasedLottoResults = lottoWinnerNumbers.resultLottoPayout(purchasedLottoTickets)
+        val purchasedLottoResults = lottoWinnerNumbers.resultLottoPayout(lottoTickets)
         return LottoPayoutView.displayWinningStatistics(purchasedLottoResults = purchasedLottoResults)
     }
 }
diff --git a/src/main/kotlin/lotto/domain/AutoLottoIssuer.kt b/src/main/kotlin/lotto/domain/AutoLottoIssuer.kt
new file mode 100644
index 000000000..6cb688deb
--- /dev/null
+++ b/src/main/kotlin/lotto/domain/AutoLottoIssuer.kt
@@ -0,0 +1,14 @@
+package lotto.domain
+
+object AutoLottoIssuer {
+    fun issueAutoLottoTickets(
+        autoLottoCount: Int,
+        generateLottoNumbers: () -> LottoNumbers,
+    ): LottoTickets {
+        val autoLottoTickets = mutableListOf<LottoTicket.AutoLottoTicket>()
+
+        repeat(autoLottoCount) { autoLottoTickets.add(LottoTicket.AutoLottoTicket { generateLottoNumbers() }) }
+
+        return LottoTickets(autoLottoTickets)
+    }
+}
diff --git a/src/main/kotlin/lotto/domain/LottoNumberGenerator.kt b/src/main/kotlin/lotto/domain/LottoNumberGenerator.kt
index 4ea5be979..428171fa7 100644
--- a/src/main/kotlin/lotto/domain/LottoNumberGenerator.kt
+++ b/src/main/kotlin/lotto/domain/LottoNumberGenerator.kt
@@ -1,10 +1,13 @@
 package lotto.domain
 
-import lotto.domain.LottoNumber.Companion.LOTTO_NUMBER_MAX_VALUE
-import lotto.domain.LottoNumber.Companion.LOTTO_NUMBER_MIN_VALUE
-import lotto.domain.LottoNumbers.Companion.LOTTO_NUMBER_COUNT
+object LottoNumberGenerator {
+    fun generateAutoLottoNumbers(): LottoNumbers {
+        val randomNumbers = generatorRandomNumber()
+        return LottoNumbers(randomNumbers.map { LottoNumber.of(it) }.toSet())
+    }
 
-fun generateLottoNumbers(): Set<Int> {
-    return (LOTTO_NUMBER_MIN_VALUE..LOTTO_NUMBER_MAX_VALUE)
-        .toSet().shuffled().take(LOTTO_NUMBER_COUNT).sorted().toSet()
+    fun generatorRandomNumber(): List<Int> {
+        return (LottoNumber.LOTTO_NUMBER_MIN_VALUE..LottoNumber.LOTTO_NUMBER_MAX_VALUE)
+            .shuffled().take(LottoNumbers.LOTTO_NUMBER_COUNT).sorted()
+    }
 }
diff --git a/src/main/kotlin/lotto/domain/LottoPurchaseCalculator.kt b/src/main/kotlin/lotto/domain/LottoPurchaseCalculator.kt
new file mode 100644
index 000000000..714ce1363
--- /dev/null
+++ b/src/main/kotlin/lotto/domain/LottoPurchaseCalculator.kt
@@ -0,0 +1,18 @@
+package lotto.domain
+
+object LottoPurchaseCalculator {
+    fun getMaxPurchasedLottoTicketCount(amountPaid: Int): Int {
+        checkAmountPaid(amountPaid)
+        return amountPaid / DEFAULT_LOTTO_PRICE
+    }
+
+    private fun checkAmountPaid(amountPaid: Int) {
+        require(amountPaid >= DEFAULT_LOTTO_PRICE) { INVALID_MIN_COST_LOTTO_PAID_MESSAGE }
+        require(amountPaid % DEFAULT_LOTTO_PRICE == CHECK_SURPLUS) { INVALID_THOUSAND_UNIT_LOTTO_PAID_MESSAGE }
+    }
+
+    const val DEFAULT_LOTTO_PRICE: Int = 1000
+    private const val CHECK_SURPLUS: Int = 0
+    private const val INVALID_MIN_COST_LOTTO_PAID_MESSAGE: String = "로또 구입 비용은 최소 1,000원 이상 이어야 합니다"
+    private const val INVALID_THOUSAND_UNIT_LOTTO_PAID_MESSAGE: String = "로또 구입 비용은 1,000원 단위로 지불해야 합니다"
+}
diff --git a/src/main/kotlin/lotto/domain/LottoTicket.kt b/src/main/kotlin/lotto/domain/LottoTicket.kt
index e18592273..722213bb6 100644
--- a/src/main/kotlin/lotto/domain/LottoTicket.kt
+++ b/src/main/kotlin/lotto/domain/LottoTicket.kt
@@ -1,11 +1,17 @@
 package lotto.domain
 
-data class LottoTicket(private val generateLottoNumbers: () -> Set<Int>) {
-    val lottoNumbers = LottoNumbers(generateLottoNumbers().map { LottoNumber.of(it) }.toSet())
+sealed class LottoTicket {
+    abstract val lottoNumbers: LottoNumbers
 
     fun checkLottoWinnerRank(lottoWinnerNumbers: LottoWinnerNumbers): LottoWinnerRank {
         val matchCount = lottoNumbers.checkLottoNumbersMatch(lottoWinnerNumbers.lottoNumbers)
         val bonusCheck = lottoNumbers.contains(lottoWinnerNumbers.bonusNumber)
         return LottoWinnerRank.getRankByMatches(matchCount = matchCount, bonusCheck = bonusCheck)
     }
+
+    class ManualLottoTicket(override val lottoNumbers: LottoNumbers) : LottoTicket()
+
+    class AutoLottoTicket(generateLottoNumbers: () -> LottoNumbers) : LottoTicket() {
+        override val lottoNumbers: LottoNumbers = generateLottoNumbers()
+    }
 }
diff --git a/src/main/kotlin/lotto/domain/LottoTicketIssuer.kt b/src/main/kotlin/lotto/domain/LottoTicketIssuer.kt
deleted file mode 100644
index 9613880c7..000000000
--- a/src/main/kotlin/lotto/domain/LottoTicketIssuer.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package lotto.domain
-
-object LottoTicketIssuer {
-    fun issueTickets(
-        amountPaid: Int,
-        generateLottoNumbers: () -> Set<Int>,
-    ): PurchasedLottoTickets {
-        checkAmountPaid(amountPaid)
-        return PurchasedLottoTickets(
-            purchasedCount = (amountPaid / DEFAULT_LOTTO_PRICE),
-            generateLottoNumbers = generateLottoNumbers,
-        )
-    }
-
-    private fun checkAmountPaid(amountPaid: Int) {
-        require(amountPaid >= DEFAULT_LOTTO_PRICE) { INVALID_MIN_COST_LOTTO_PAID_MESSAGE }
-        require(amountPaid % DEFAULT_LOTTO_PRICE == CHECK_SURPLUS) { INVALID_THOUSAND_UNIT_LOTTO_PAID_MESSAGE }
-    }
-
-    const val DEFAULT_LOTTO_PRICE: Int = 1000
-    private const val CHECK_SURPLUS: Int = 0
-    const val INVALID_MIN_COST_LOTTO_PAID_MESSAGE: String = "로또 구입 비용은 최소 1,000원 이상 이어야 합니다"
-    const val INVALID_THOUSAND_UNIT_LOTTO_PAID_MESSAGE: String = "로또 구입 비용은 1,000원 단위로 지불해야 합니다"
-}
diff --git a/src/main/kotlin/lotto/domain/LottoTickets.kt b/src/main/kotlin/lotto/domain/LottoTickets.kt
new file mode 100644
index 000000000..aa5927903
--- /dev/null
+++ b/src/main/kotlin/lotto/domain/LottoTickets.kt
@@ -0,0 +1,3 @@
+package lotto.domain
+
+data class LottoTickets(val lottoTickets: List<LottoTicket>)
diff --git a/src/main/kotlin/lotto/domain/LottoWinnerNumbers.kt b/src/main/kotlin/lotto/domain/LottoWinnerNumbers.kt
index 91c8bc9b7..387928fa3 100644
--- a/src/main/kotlin/lotto/domain/LottoWinnerNumbers.kt
+++ b/src/main/kotlin/lotto/domain/LottoWinnerNumbers.kt
@@ -5,15 +5,15 @@ data class LottoWinnerNumbers(val lottoNumbers: LottoNumbers, val bonusNumber: L
         require(!lottoNumbers.contains(bonusNumber)) { INVALID_WINNER_NUMBERS_MESSAGE }
     }
 
-    fun resultLottoPayout(purchasedLottoTickets: PurchasedLottoTickets): PurchasedLottoResults {
+    fun resultLottoPayout(lottoTickets: LottoTickets): PurchasedLottoResults {
         val rankCounts: Map<LottoWinnerRank, Int> =
-            purchasedLottoTickets.purchasedLottoTickets
+            lottoTickets.lottoTickets
                 .map { lottoTicket -> lottoTicket.checkLottoWinnerRank(this) }
                 .groupingBy { it }
                 .eachCount()
 
         return PurchasedLottoResults(
-            purchasedCount = purchasedLottoTickets.purchasedCount,
+            purchasedCount = lottoTickets.lottoTickets.size,
             firstRankCount = rankCounts[LottoWinnerRank.FIRST] ?: 0,
             secondRankCount = rankCounts[LottoWinnerRank.SECOND] ?: 0,
             thirdRankCount = rankCounts[LottoWinnerRank.THIRD] ?: 0,
diff --git a/src/main/kotlin/lotto/domain/PurchasedLottoResults.kt b/src/main/kotlin/lotto/domain/PurchasedLottoResults.kt
index e1e60d493..8440b0a80 100644
--- a/src/main/kotlin/lotto/domain/PurchasedLottoResults.kt
+++ b/src/main/kotlin/lotto/domain/PurchasedLottoResults.kt
@@ -1,8 +1,6 @@
 package lotto.domain
 
-import lotto.domain.LottoTicketIssuer.DEFAULT_LOTTO_PRICE
-import lotto.domain.PurchasedLottoTickets.Companion.INVALID_PURCHASED_COUNT_MESSAGE
-import lotto.domain.PurchasedLottoTickets.Companion.PURCHASED_COUNT_MIN_VALUE
+import lotto.domain.LottoPurchaseCalculator.DEFAULT_LOTTO_PRICE
 
 data class PurchasedLottoResults(
     val purchasedCount: Int,
@@ -38,6 +36,8 @@ data class PurchasedLottoResults(
 
     companion object {
         const val LOTTO_MATCH_COUNT_MIN_VALUE: Int = 0
+        const val PURCHASED_COUNT_MIN_VALUE: Int = 1
+        const val INVALID_PURCHASED_COUNT_MESSAGE: String = "구입한 로또 개수가 올바르지 않습니다"
         const val INVALID_LOTTO_MATCH_COUNT_MESSAGE: String = "로또 당첨 번호 매치 결과는 0 이상 이어야합니다"
         const val INVALID_PURCHASED_COUNT_LOTTO_MATCH_COUNT_MESSAGE: String = "당첨된 내역의 합이 구매한 개수보다 많을 수 없습니다"
     }
diff --git a/src/main/kotlin/lotto/domain/PurchasedLottoTickets.kt b/src/main/kotlin/lotto/domain/PurchasedLottoTickets.kt
deleted file mode 100644
index b8e3f5c62..000000000
--- a/src/main/kotlin/lotto/domain/PurchasedLottoTickets.kt
+++ /dev/null
@@ -1,18 +0,0 @@
-package lotto.domain
-
-data class PurchasedLottoTickets(val purchasedCount: Int, private val generateLottoNumbers: () -> Set<Int>) {
-    val purchasedLottoTickets: List<LottoTicket>
-
-    init {
-        require(purchasedCount >= PURCHASED_COUNT_MIN_VALUE) { INVALID_PURCHASED_COUNT_MESSAGE }
-        purchasedLottoTickets =
-            List(purchasedCount) {
-                LottoTicket(generateLottoNumbers = generateLottoNumbers)
-            }
-    }
-
-    companion object {
-        const val PURCHASED_COUNT_MIN_VALUE: Int = 1
-        const val INVALID_PURCHASED_COUNT_MESSAGE: String = "최소한 로또 1장 이상 구입해야 합니다"
-    }
-}
diff --git a/src/main/kotlin/lotto/view/ManualLottoView.kt b/src/main/kotlin/lotto/view/ManualLottoView.kt
new file mode 100644
index 000000000..611d2be2e
--- /dev/null
+++ b/src/main/kotlin/lotto/view/ManualLottoView.kt
@@ -0,0 +1,39 @@
+package lotto.view
+
+import lotto.domain.LottoNumbers
+import lotto.domain.LottoTicket.ManualLottoTicket
+import lotto.domain.LottoTickets
+import lotto.view.util.splitInputNumbersCommand
+
+object ManualLottoView {
+    fun inputManualLottoCount(maxPurchaseLottoCount: Int): Int {
+        println("\n수동으로 구매할 로또 수를 입력해 주세요.")
+        val inputManualLottoCountCommand: String? = readlnOrNull()
+        requireNotNull(inputManualLottoCountCommand) { "입력된 수동 로또 개수가 없습니다." }
+
+        val inputManualLottoCount = inputManualLottoCountCommand.toIntOrNull()
+        requireNotNull(inputManualLottoCount) { "구입금액이 올바르게 입력되지 않았습니다." }
+        require(inputManualLottoCount >= 0) { "수동 로또 개수는 0개부터 입력 가능합니다." }
+        require(inputManualLottoCount <= maxPurchaseLottoCount) { "구입 가능한 수동 로또 개수를 초과했습니다." }
+
+        return inputManualLottoCount
+    }
+
+    fun repeatInputManualLottoNumbers(manualLottoCount: Int): LottoTickets {
+        println("\n수동으로 구매할 번호를 입력해 주세요.")
+
+        val lottoNumbersList = List(manualLottoCount) { inputManualLottoNumbers() }
+
+        val lottoTickets = lottoNumbersList.map { ManualLottoTicket(it) }
+
+        return LottoTickets(lottoTickets)
+    }
+
+    private fun inputManualLottoNumbers(): LottoNumbers {
+        val inputManualNumbersCommand: String? = readlnOrNull()
+
+        requireNotNull(inputManualNumbersCommand) { "입력된 수동 번호가 없습니다." }
+
+        return splitInputNumbersCommand(inputManualNumbersCommand)
+    }
+}
diff --git a/src/main/kotlin/lotto/view/PurchaseLottoResultView.kt b/src/main/kotlin/lotto/view/PurchaseLottoResultView.kt
deleted file mode 100644
index ac88f716d..000000000
--- a/src/main/kotlin/lotto/view/PurchaseLottoResultView.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package lotto.view
-
-import lotto.domain.PurchasedLottoTickets
-
-object PurchaseLottoResultView {
-    fun displayPurchaseLottoResults(purchasedLottoTickets: PurchasedLottoTickets) {
-        println("${purchasedLottoTickets.purchasedCount}개를 구매했습니다.")
-        purchasedLottoTickets.purchasedLottoTickets.forEach {
-                lottoTicket ->
-            println(lottoTicket.lottoNumbers.getNumbers().joinToString(","))
-        }
-    }
-}
diff --git a/src/main/kotlin/lotto/view/PurchaseLottoView.kt b/src/main/kotlin/lotto/view/PurchaseLottoView.kt
index f3c10d897..65a5006e4 100644
--- a/src/main/kotlin/lotto/view/PurchaseLottoView.kt
+++ b/src/main/kotlin/lotto/view/PurchaseLottoView.kt
@@ -1,11 +1,26 @@
 package lotto.view
 
+import lotto.domain.LottoTickets
+
 object PurchaseLottoView {
     fun inputPurchaseCost(): Int {
         println("구입금액을 입력해 주세요.")
         val inputCost: String? = readlnOrNull()
         requireNotNull(inputCost) { "구입금액이 입력되지 않았습니다" }
         requireNotNull(inputCost.toIntOrNull()) { "구입금액이 올바르게 입력되지 않았습니다" }
+
         return inputCost.toInt()
     }
+
+    fun displayPurchasedLottosView(
+        manualLottoTickets: LottoTickets,
+        autoLottoTickets: LottoTickets,
+    ) {
+        val manualLottoCount = manualLottoTickets.lottoTickets.size
+        val autoLottoCount = autoLottoTickets.lottoTickets.size
+        println("\n수동으로 ${manualLottoCount}장, 자동으로 ${autoLottoCount}개를 구매했습니다.")
+
+        manualLottoTickets.lottoTickets.forEach { println(it.lottoNumbers.getNumbers()) }
+        autoLottoTickets.lottoTickets.forEach { println(it.lottoNumbers.getNumbers()) }
+    }
 }
diff --git a/src/main/kotlin/lotto/view/WinnerLottoNumberView.kt b/src/main/kotlin/lotto/view/WinnerLottoNumberView.kt
index 0902ce041..2265279c6 100644
--- a/src/main/kotlin/lotto/view/WinnerLottoNumberView.kt
+++ b/src/main/kotlin/lotto/view/WinnerLottoNumberView.kt
@@ -1,56 +1,28 @@
 package lotto.view
 
+import lotto.domain.LottoNumber
+import lotto.domain.LottoNumbers
+import lotto.view.util.splitInputNumbersCommand
+
 object WinnerLottoNumberView {
-    fun inputWinningLottoNumbers(): Set<Int> {
+    fun inputWinningLottoNumbers(): LottoNumbers {
         println("\n지난 주 당첨 번호를 입력해 주세요.")
         val inputWinnerNumbersCommand: String? = readlnOrNull()
         requireNotNull(inputWinnerNumbersCommand) { INVALID_NULL_OR_BLANK_WINNER_NUMBERS_MESSAGE }
 
-        val splitInputWinnerNumbers = splitInputWinnerNumbersCommand(inputWinnerNumbersCommand)
-        require(splitInputWinnerNumbers.size == 6) { INVALID_WINNER_NUMBERS_COUNT_MESSAGE }
-        return splitInputWinnerNumbers
+        return splitInputNumbersCommand(inputWinnerNumbersCommand)
     }
 
-    fun inputBonusNumber(): Int {
+    fun inputBonusNumber(): LottoNumber {
         println("보너스 볼을 입력해 주세요.")
         val inputBonusNumberCommand: String? = readlnOrNull()
         requireNotNull(inputBonusNumberCommand) { INVALID_NULL_OR_BLANK_BONUS_NUMBERS_MESSAGE }
         val inputBonusNumber = inputBonusNumberCommand.toIntOrNull()
         requireNotNull(inputBonusNumber) { INVALID_BONUS_NUMBERS_MESSAGE }
-        return inputBonusNumber
-    }
-
-    private fun splitInputWinnerNumbersCommand(inputWinnerNumbersCommand: String): Set<Int> {
-        require(inputWinnerNumbersCommand.isNotBlank()) { INVALID_BLANK_WINNER_NUMBERS_MESSAGE }
-        require(inputWinnerNumbersCommand.contains(WINNER_NUMBERS_DELIMITER)) {
-            INVALID_DELIMITER_WINNER_NUMBERS_MESSAGE
-        }
-
-        return inputWinnerNumbersCommand.split(WINNER_NUMBERS_DELIMITER)
-            .map { inputWinnerNumber -> lottoNumberStringToInt(numberString = inputWinnerNumber.trim()) }
-            .toSet()
-    }
-
-    private fun lottoNumberStringToInt(numberString: String): Int {
-        val lottoNumberOrNull = numberString.toIntOrNull()
-
-        requireNotNull(lottoNumberOrNull) { INVALID_WINNER_NUMBERS_TO_INT_MESSAGE }
-        require((LOTTO_NUMBER_MIN_VALUE..LOTTO_NUMBER_MAX_VALUE).toSet().contains(lottoNumberOrNull)) {
-            INVALID_WINNER_NUMBERS_LOTTO_RANGE_MESSAGE
-        }
-
-        return lottoNumberOrNull
+        return LottoNumber.of(inputBonusNumber)
     }
 
-    const val INVALID_NULL_OR_BLANK_WINNER_NUMBERS_MESSAGE: String = "입력된 로또 당첨 번호가 없습니다"
-    const val INVALID_NULL_OR_BLANK_BONUS_NUMBERS_MESSAGE: String = "입력된 보너스 번호가 없습니다"
-    const val INVALID_BONUS_NUMBERS_MESSAGE: String = "입력된 보너스 번호가 올바르지 않습니다"
-    const val INVALID_BLANK_WINNER_NUMBERS_MESSAGE: String = "입력된 로또 당첨 번호가 공백입니다"
-    const val INVALID_DELIMITER_WINNER_NUMBERS_MESSAGE: String = "로또 당첨 번호 구분자가 올바르지 않습니다"
-    const val WINNER_NUMBERS_DELIMITER: String = ","
-    const val INVALID_WINNER_NUMBERS_TO_INT_MESSAGE: String = "로또 당첨 번호가 숫자로 입력되지 않았습니다"
-    const val INVALID_WINNER_NUMBERS_LOTTO_RANGE_MESSAGE: String = "로또 당첨 번호가 1~45 사이의 숫자가 아닙니다"
-    const val LOTTO_NUMBER_MIN_VALUE: Int = 1
-    const val LOTTO_NUMBER_MAX_VALUE: Int = 45
-    const val INVALID_WINNER_NUMBERS_COUNT_MESSAGE: String = "로또 당첨 번호가 중복되지 않은 6개로 입력되지 않았습니다"
+    private const val INVALID_NULL_OR_BLANK_WINNER_NUMBERS_MESSAGE: String = "입력된 로또 당첨 번호가 없습니다"
+    private const val INVALID_NULL_OR_BLANK_BONUS_NUMBERS_MESSAGE: String = "입력된 보너스 번호가 없습니다"
+    private const val INVALID_BONUS_NUMBERS_MESSAGE: String = "입력된 보너스 번호가 올바르지 않습니다"
 }
diff --git a/src/main/kotlin/lotto/view/util/SplitInputNumbersCommand.kt b/src/main/kotlin/lotto/view/util/SplitInputNumbersCommand.kt
new file mode 100644
index 000000000..466e8deb8
--- /dev/null
+++ b/src/main/kotlin/lotto/view/util/SplitInputNumbersCommand.kt
@@ -0,0 +1,29 @@
+package lotto.view.util
+
+import lotto.domain.LottoNumber
+import lotto.domain.LottoNumbers
+
+fun splitInputNumbersCommand(inputNumbersCommand: String): LottoNumbers {
+    require(inputNumbersCommand.isNotBlank()) { INVALID_BLANK_NUMBERS_MESSAGE }
+    require(inputNumbersCommand.contains(NUMBERS_DELIMITER)) {
+        INVALID_DELIMITER_NUMBERS_MESSAGE
+    }
+
+    val lottoNumbers =
+        inputNumbersCommand.split(NUMBERS_DELIMITER)
+            .map { lottoNumberStringToInt(numberString = it.trim()) }
+            .toSet()
+
+    return LottoNumbers(lottoNumbers)
+}
+
+private fun lottoNumberStringToInt(numberString: String): LottoNumber {
+    val lottoNumberOrNull = numberString.toIntOrNull()
+    requireNotNull(lottoNumberOrNull) { INVALID_NUMBERS_TO_INT_MESSAGE }
+    return LottoNumber.of(lottoNumberOrNull)
+}
+
+const val INVALID_BLANK_NUMBERS_MESSAGE: String = "입력된 로또 번호가 공백입니다"
+const val INVALID_DELIMITER_NUMBERS_MESSAGE: String = "로또 번호 구분자가 올바르지 않습니다"
+const val NUMBERS_DELIMITER: String = ","
+const val INVALID_NUMBERS_TO_INT_MESSAGE: String = "로또 번호가 숫자로 입력되지 않았습니다"
diff --git a/src/test/kotlin/lotto/domain/AutoLottoIssuerTest.kt b/src/test/kotlin/lotto/domain/AutoLottoIssuerTest.kt
new file mode 100644
index 000000000..8e0768aa2
--- /dev/null
+++ b/src/test/kotlin/lotto/domain/AutoLottoIssuerTest.kt
@@ -0,0 +1,14 @@
+package lotto.domain
+
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.equals.shouldBeEqual
+import lotto.util.createLottoNumbers
+import org.junit.jupiter.api.Test
+
+class AutoLottoIssuerTest {
+    @Test
+    fun `정해진 개수 만큼 자동 로또를 생성 할 수 있다`() {
+        val lottoTickets = AutoLottoIssuer.issueAutoLottoTickets(3) { createLottoNumbers(1, 2, 3, 4, 5, 6) }
+        lottoTickets.lottoTickets.shouldHaveSize(3)
+    }
+}
diff --git a/src/test/kotlin/lotto/domain/LottoNumberGeneratorTest.kt b/src/test/kotlin/lotto/domain/LottoNumberGeneratorTest.kt
index 5062f8dac..cff7ae0e3 100644
--- a/src/test/kotlin/lotto/domain/LottoNumberGeneratorTest.kt
+++ b/src/test/kotlin/lotto/domain/LottoNumberGeneratorTest.kt
@@ -6,6 +6,6 @@ import org.junit.jupiter.api.Test
 class LottoNumberGeneratorTest {
     @Test
     fun `로또 번호 자동 생성은 1부터 45사이의 6개의 숫자로 이루어져야한다`() {
-        (1..45).toSet().containsAll(generateLottoNumbers()) shouldBeEqual true
+        (1..45).toSet().containsAll(LottoNumberGenerator.generatorRandomNumber()) shouldBeEqual true
     }
 }
diff --git a/src/test/kotlin/lotto/domain/LottoPurchaseCalculatorTest.kt b/src/test/kotlin/lotto/domain/LottoPurchaseCalculatorTest.kt
new file mode 100644
index 000000000..f8a60ae03
--- /dev/null
+++ b/src/test/kotlin/lotto/domain/LottoPurchaseCalculatorTest.kt
@@ -0,0 +1,36 @@
+package lotto.domain
+
+import io.kotest.assertions.throwables.shouldThrowWithMessage
+import io.kotest.matchers.equals.shouldBeEqual
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+class LottoPurchaseCalculatorTest {
+    @ParameterizedTest
+    @CsvSource(
+        "1000, 1",
+        "11000, 11",
+        "5000, 5",
+    )
+    fun `로또 구입 비용을 토대로 최대 몇장의 로또를 구입할 수 있는지 계산할 수 있다`(
+        amountPaid: Int,
+        purchasedLottoTicketCount: Int,
+    ) {
+        LottoPurchaseCalculator.getMaxPurchasedLottoTicketCount(amountPaid) shouldBeEqual purchasedLottoTicketCount
+    }
+
+    @Test
+    fun `최소한의 로또 구입 비용을 지불하지 않으면 에러가 발생한다`() {
+        shouldThrowWithMessage<IllegalArgumentException>(message = "로또 구입 비용은 최소 1,000원 이상 이어야 합니다") {
+            LottoPurchaseCalculator.getMaxPurchasedLottoTicketCount(999)
+        }
+    }
+
+    @Test
+    fun `로또 구입 비용이 1,000원 단위가 아닐 시 에러가 발생한다`() {
+        shouldThrowWithMessage<IllegalArgumentException>(message = "로또 구입 비용은 1,000원 단위로 지불해야 합니다") {
+            LottoPurchaseCalculator.getMaxPurchasedLottoTicketCount(1500)
+        }
+    }
+}
diff --git a/src/test/kotlin/lotto/domain/LottoTicketIssuerTest.kt b/src/test/kotlin/lotto/domain/LottoTicketIssuerTest.kt
deleted file mode 100644
index c8ae7a46d..000000000
--- a/src/test/kotlin/lotto/domain/LottoTicketIssuerTest.kt
+++ /dev/null
@@ -1,39 +0,0 @@
-package lotto.domain
-
-import io.kotest.assertions.throwables.shouldThrowWithMessage
-import io.kotest.matchers.shouldBe
-import lotto.domain.LottoTicketIssuer.INVALID_MIN_COST_LOTTO_PAID_MESSAGE
-import lotto.domain.LottoTicketIssuer.INVALID_THOUSAND_UNIT_LOTTO_PAID_MESSAGE
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.CsvSource
-import org.junit.jupiter.params.provider.ValueSource
-
-class LottoTicketIssuerTest {
-    @ParameterizedTest
-    @ValueSource(ints = [500, 999])
-    fun `로또 구입 비용이 1,000원 미만일 경우 에러가 발생한다`(amountPaid: Int) {
-        shouldThrowWithMessage<IllegalArgumentException>(message = INVALID_MIN_COST_LOTTO_PAID_MESSAGE) {
-            LottoTicketIssuer.issueTickets(amountPaid = amountPaid, generateLottoNumbers = { setOf(1, 2, 3, 4, 5, 6) })
-        }
-    }
-
-    @ParameterizedTest
-    @ValueSource(ints = [1500, 22200, 10500, 2100005])
-    fun `로또 구입 비용이 1,000원 단위가 아닐 경우 에러가 발생한다`(amountPaid: Int) {
-        shouldThrowWithMessage<IllegalArgumentException>(message = INVALID_THOUSAND_UNIT_LOTTO_PAID_MESSAGE) {
-            LottoTicketIssuer.issueTickets(amountPaid = amountPaid, generateLottoNumbers = { setOf(1, 2, 3, 4, 5, 6) })
-        }
-    }
-
-    @ParameterizedTest
-    @CsvSource("5000, 5", "1000, 1")
-    fun `로또 구입 비용에 대해 몇 장의 로또가 구입됐는지 확인활 수 있다`(
-        amountPaid: Int,
-        expectedTicketCount: Int,
-    ) {
-        val purchasedLottoTickets =
-            LottoTicketIssuer.issueTickets(amountPaid = amountPaid, generateLottoNumbers = { setOf(1, 2, 3, 4, 5, 6) })
-        purchasedLottoTickets.purchasedCount shouldBe expectedTicketCount
-        purchasedLottoTickets.purchasedLottoTickets.size shouldBe expectedTicketCount
-    }
-}
diff --git a/src/test/kotlin/lotto/domain/LottoTicketTest.kt b/src/test/kotlin/lotto/domain/LottoTicketTest.kt
index 14df047d6..8136c37a6 100644
--- a/src/test/kotlin/lotto/domain/LottoTicketTest.kt
+++ b/src/test/kotlin/lotto/domain/LottoTicketTest.kt
@@ -1,8 +1,9 @@
 package lotto.domain
 
-import io.kotest.assertions.throwables.shouldThrowWithMessage
-import lotto.domain.LottoNumber.Companion.INVALID_LOTTO_NUMBER_MESSAGE
-import lotto.domain.LottoNumbers.Companion.INVALID_LOTTO_NUMBER_COUNT_MESSAGE
+import io.kotest.matchers.equals.shouldBeEqual
+import lotto.domain.LottoTicket.AutoLottoTicket
+import lotto.domain.LottoTicket.ManualLottoTicket
+import lotto.util.createLottoNumbers
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
@@ -11,35 +12,58 @@ import java.util.stream.Stream
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class LottoTicketTest {
-    @MethodSource("7개 이상, 또는 6개 미만의 숫자 제공")
+    @MethodSource("구매한 로또의 번호, 당첨 번호, 매칭 결과 제공")
     @ParameterizedTest
-    fun `로또 번호는 숫자 6개가 아니면 에러가 발생한다`(numberSet: Set<Int>) {
-        shouldThrowWithMessage<IllegalArgumentException>(message = INVALID_LOTTO_NUMBER_COUNT_MESSAGE) {
-            LottoTicket(generateLottoNumbers = { numberSet })
-        }
+    fun `당첨 번호를 토대로 몇 등 인지 확인 할 수 있다`(
+        lottoTicket: LottoTicket,
+        lottoWinnerNumbers: LottoWinnerNumbers,
+        lottoWinnerRank: LottoWinnerRank,
+    ) {
+        lottoTicket.checkLottoWinnerRank(lottoWinnerNumbers) shouldBeEqual lottoWinnerRank
     }
 
-    fun `7개 이상, 또는 6개 미만의 숫자 제공`(): Stream<Arguments> {
+    fun `구매한 로또의 번호, 당첨 번호, 매칭 결과 제공`(): Stream<Arguments> {
         return Stream.of(
-            Arguments.of(setOf(5, 11, 15, 16, 17, 18, 19)),
-            Arguments.of(setOf(4, 5, 6, 7)),
-            Arguments.of(setOf(15, 16, 17, 18, 19)),
-        )
-    }
-
-    @MethodSource("1미만 46 이상의 숫자가 있는 로또 번호 제공")
-    @ParameterizedTest
-    fun `로또 번호는 1부터 45사이의 숫자가 아니면 에러가 발생한다`(numberSet: Set<Int>) {
-        shouldThrowWithMessage<IllegalArgumentException>(message = INVALID_LOTTO_NUMBER_MESSAGE) {
-            LottoTicket(generateLottoNumbers = { numberSet })
-        }
-    }
-
-    fun `1미만 46 이상의 숫자가 있는 로또 번호 제공`(): Stream<Arguments> {
-        return Stream.of(
-            Arguments.of(setOf(0, 11, 15, 1, 2, 3)),
-            Arguments.of(setOf(14, 15, 46, 7, 4, 5)),
-            Arguments.of(setOf(15, 16, 17, 18, -3, 1)),
+            Arguments.of(
+                ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 5, 6)),
+                LottoWinnerNumbers(createLottoNumbers(1, 2, 3, 4, 5, 6), LottoNumber.of(7)),
+                LottoWinnerRank.FIRST,
+            ),
+            Arguments.of(
+                ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 5, 6)),
+                LottoWinnerNumbers(createLottoNumbers(1, 2, 3, 4, 5, 7), LottoNumber.of(6)),
+                LottoWinnerRank.SECOND,
+            ),
+            Arguments.of(
+                AutoLottoTicket { createLottoNumbers(1, 2, 3, 4, 5, 6) },
+                LottoWinnerNumbers(createLottoNumbers(1, 2, 3, 4, 5, 8), LottoNumber.of(7)),
+                LottoWinnerRank.THIRD,
+            ),
+            Arguments.of(
+                ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 5, 6)),
+                LottoWinnerNumbers(createLottoNumbers(1, 2, 3, 4, 8, 9), LottoNumber.of(7)),
+                LottoWinnerRank.FOURTH,
+            ),
+            Arguments.of(
+                AutoLottoTicket { createLottoNumbers(1, 2, 3, 4, 5, 6) },
+                LottoWinnerNumbers(createLottoNumbers(1, 2, 3, 8, 9, 10), LottoNumber.of(7)),
+                LottoWinnerRank.FIFTH,
+            ),
+            Arguments.of(
+                ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 5, 6)),
+                LottoWinnerNumbers(createLottoNumbers(1, 2, 8, 9, 10, 11), LottoNumber.of(7)),
+                LottoWinnerRank.MISS,
+            ),
+            Arguments.of(
+                AutoLottoTicket { createLottoNumbers(1, 2, 3, 4, 5, 6) },
+                LottoWinnerNumbers(createLottoNumbers(1, 8, 9, 10, 11, 12), LottoNumber.of(7)),
+                LottoWinnerRank.MISS,
+            ),
+            Arguments.of(
+                ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 5, 6)),
+                LottoWinnerNumbers(createLottoNumbers(8, 9, 10, 11, 12, 13), LottoNumber.of(7)),
+                LottoWinnerRank.MISS,
+            ),
         )
     }
 }
diff --git a/src/test/kotlin/lotto/domain/LottoWinnerNumbersTest.kt b/src/test/kotlin/lotto/domain/LottoWinnerNumbersTest.kt
index 73c37c6af..40cfb20d4 100644
--- a/src/test/kotlin/lotto/domain/LottoWinnerNumbersTest.kt
+++ b/src/test/kotlin/lotto/domain/LottoWinnerNumbersTest.kt
@@ -4,6 +4,7 @@ import io.kotest.assertions.throwables.shouldThrowWithMessage
 import io.kotest.matchers.equals.shouldBeEqual
 import lotto.domain.LottoNumber.Companion.INVALID_LOTTO_NUMBER_MESSAGE
 import lotto.domain.LottoNumbers.Companion.INVALID_LOTTO_NUMBER_COUNT_MESSAGE
+import lotto.domain.LottoTicket.ManualLottoTicket
 import lotto.domain.LottoWinnerNumbers.Companion.INVALID_WINNER_NUMBERS_MESSAGE
 import lotto.util.createLottoNumbers
 import org.junit.jupiter.api.Test
@@ -36,13 +37,12 @@ class LottoWinnerNumbersTest {
         }
     }
 
-    @MethodSource("구매한 로또의 번호 및 당첨 번호, 매칭 결과 및 수익률 제공")
+    @MethodSource("당첨 로또 번호, 보너스 번호, 구매한 로또 티켓, 매칭 결과 및 수익률 제공")
     @ParameterizedTest
-    fun `구매한 로또 번호가 당첨 번호와 몇개가 일치하는지와 수익률 등 결과 확인 (3개부터)`(
-        purchasedCount: Int,
-        lottoNumbers: Set<Int>,
-        winnerNumbers: Set<Int>,
+    fun `구매한 로또 번호가 당첨 번호와 몇개가 일치하는지와 수익률 등 결과 확인`(
+        winnerNumbers: LottoNumbers,
         bonusNumber: Int,
+        purchasedLottoTickets: LottoTickets,
         firstRankCount: Int,
         secondRankCount: Int,
         thirdRankCount: Int,
@@ -50,15 +50,7 @@ class LottoWinnerNumbersTest {
         fifthRankCount: Int,
         profitMargin: Double,
     ) {
-        val purchasedLottoTickets =
-            PurchasedLottoTickets(purchasedCount = purchasedCount, generateLottoNumbers = { lottoNumbers })
-
-        val lottoWinnerNumbers =
-            LottoWinnerNumbers(
-                lottoNumbers = LottoNumbers(winnerNumbers.map { LottoNumber.of(it) }.toSet()),
-                bonusNumber = LottoNumber.of(bonusNumber),
-            )
-
+        val lottoWinnerNumbers = LottoWinnerNumbers(winnerNumbers, LottoNumber.of(bonusNumber))
         val purchasedLottoResults = lottoWinnerNumbers.resultLottoPayout(purchasedLottoTickets)
 
         purchasedLottoResults.firstRankCount shouldBeEqual firstRankCount
@@ -69,16 +61,96 @@ class LottoWinnerNumbersTest {
         purchasedLottoResults.getProfitMargin() shouldBeEqual profitMargin
     }
 
-    fun `구매한 로또의 번호 및 당첨 번호, 매칭 결과 및 수익률 제공`(): Stream<Arguments> {
+    fun `당첨 로또 번호, 보너스 번호, 구매한 로또 티켓, 매칭 결과 및 수익률 제공`(): Stream<Arguments> {
         return Stream.of(
-            Arguments.of(5, setOf(1, 2, 3, 4, 5, 6), setOf(11, 15, 16, 17, 18, 19), 3, 0, 0, 0, 0, 0, 0.0),
-            Arguments.of(25, setOf(1, 2, 3, 4, 5, 6), setOf(4, 15, 16, 17, 18, 19), 7, 0, 0, 0, 0, 0, 0.0),
-            Arguments.of(35, setOf(1, 2, 3, 4, 5, 6), setOf(4, 5, 16, 17, 18, 19), 20, 0, 0, 0, 0, 0, 0.0),
-            Arguments.of(5, setOf(1, 2, 3, 4, 5, 6), setOf(4, 5, 6, 7, 8, 9), 21, 0, 0, 0, 0, 5, 5.0),
-            Arguments.of(8, setOf(11, 12, 13, 14, 15, 16), setOf(13, 14, 15, 16, 17, 18), 22, 0, 0, 0, 8, 0, 50.0),
-            Arguments.of(3, setOf(21, 22, 23, 24, 25, 26), setOf(21, 22, 23, 24, 25, 1), 2, 0, 0, 3, 0, 0, 1500.0),
-            Arguments.of(3, setOf(21, 22, 23, 24, 25, 26), setOf(21, 22, 23, 24, 25, 1), 26, 0, 3, 0, 0, 0, 30000.0),
-            Arguments.of(1, setOf(31, 32, 33, 34, 35, 41), setOf(31, 32, 33, 34, 35, 41), 9, 1, 0, 0, 0, 0, 2000000.0),
+            Arguments.of(
+                createLottoNumbers(1, 2, 3, 4, 5, 6),
+                7,
+                LottoTickets(listOf(ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 5, 6)))),
+                1,
+                0,
+                0,
+                0,
+                0,
+                2000000.0,
+            ),
+            Arguments.of(
+                createLottoNumbers(1, 2, 3, 4, 5, 6),
+                7,
+                LottoTickets(listOf(ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 5, 7)))),
+                0,
+                1,
+                0,
+                0,
+                0,
+                30000.0,
+            ),
+            Arguments.of(
+                createLottoNumbers(1, 2, 3, 4, 5, 6),
+                7,
+                LottoTickets(listOf(ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 5, 8)))),
+                0,
+                0,
+                1,
+                0,
+                0,
+                1500.0,
+            ),
+            Arguments.of(
+                createLottoNumbers(1, 2, 3, 4, 5, 6),
+                7,
+                LottoTickets(listOf(ManualLottoTicket(createLottoNumbers(1, 2, 3, 4, 8, 9)))),
+                0,
+                0,
+                0,
+                1,
+                0,
+                50.0,
+            ),
+            Arguments.of(
+                createLottoNumbers(1, 2, 3, 4, 5, 6),
+                7,
+                LottoTickets(listOf(ManualLottoTicket(createLottoNumbers(1, 2, 3, 8, 9, 10)))),
+                0,
+                0,
+                0,
+                0,
+                1,
+                5.0,
+            ),
+            Arguments.of(
+                createLottoNumbers(1, 2, 3, 4, 5, 6),
+                7,
+                LottoTickets(listOf(ManualLottoTicket(createLottoNumbers(1, 2, 8, 9, 10, 11)))),
+                0,
+                0,
+                0,
+                0,
+                0,
+                0.0,
+            ),
+            Arguments.of(
+                createLottoNumbers(1, 2, 3, 4, 5, 6),
+                7,
+                LottoTickets(listOf(ManualLottoTicket(createLottoNumbers(1, 8, 9, 10, 11, 12)))),
+                0,
+                0,
+                0,
+                0,
+                0,
+                0.0,
+            ),
+            Arguments.of(
+                createLottoNumbers(1, 2, 3, 4, 5, 6),
+                7,
+                LottoTickets(listOf(ManualLottoTicket(createLottoNumbers(8, 9, 10, 11, 12, 13)))),
+                0,
+                0,
+                0,
+                0,
+                0,
+                0.0,
+            ),
         )
     }
 }
diff --git a/src/test/kotlin/lotto/domain/PurchasedLottoResultsTest.kt b/src/test/kotlin/lotto/domain/PurchasedLottoResultsTest.kt
index 1777be765..ddaebe7ed 100644
--- a/src/test/kotlin/lotto/domain/PurchasedLottoResultsTest.kt
+++ b/src/test/kotlin/lotto/domain/PurchasedLottoResultsTest.kt
@@ -3,7 +3,6 @@ package lotto.domain
 import io.kotest.assertions.throwables.shouldThrowWithMessage
 import lotto.domain.PurchasedLottoResults.Companion.INVALID_LOTTO_MATCH_COUNT_MESSAGE
 import lotto.domain.PurchasedLottoResults.Companion.INVALID_PURCHASED_COUNT_LOTTO_MATCH_COUNT_MESSAGE
-import lotto.domain.PurchasedLottoTickets.Companion.INVALID_PURCHASED_COUNT_MESSAGE
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.params.ParameterizedTest
@@ -13,7 +12,7 @@ import org.junit.jupiter.params.provider.CsvSource
 class PurchasedLottoResultsTest {
     @Test
     fun `로또 구매 개수가 1개 미만 일 경우 에러가 발생한다`() {
-        shouldThrowWithMessage<IllegalArgumentException>(message = INVALID_PURCHASED_COUNT_MESSAGE) {
+        shouldThrowWithMessage<IllegalArgumentException>(message = "구입한 로또 개수가 올바르지 않습니다") {
             PurchasedLottoResults(
                 purchasedCount = 0,
                 firstRankCount = 0,
diff --git a/src/test/kotlin/lotto/domain/PurchasedLottoTicketsTest.kt b/src/test/kotlin/lotto/domain/PurchasedLottoTicketsTest.kt
deleted file mode 100644
index 130b2f986..000000000
--- a/src/test/kotlin/lotto/domain/PurchasedLottoTicketsTest.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package lotto.domain
-
-import io.kotest.assertions.throwables.shouldThrowWithMessage
-import lotto.domain.PurchasedLottoTickets.Companion.INVALID_PURCHASED_COUNT_MESSAGE
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.ValueSource
-
-class PurchasedLottoTicketsTest {
-    @ParameterizedTest
-    @ValueSource(ints = [0, -1, -100])
-    fun `구매한 로또 티켓 개수가 1개 미만일 경우 에러가 발생한다 `(purchasedCount: Int) {
-        shouldThrowWithMessage<IllegalArgumentException>(message = INVALID_PURCHASED_COUNT_MESSAGE) {
-            PurchasedLottoTickets(purchasedCount = purchasedCount, generateLottoNumbers = { setOf(1, 2, 3, 4, 5, 6) })
-        }
-    }
-}