diff --git a/README.md b/README.md
index 0ef22f5718..cbabd2a9b6 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,79 @@
 # kotlin-lotto
 
+# 🚀 4단계 - 로또(수동)
+
+## 기능 요구사항
+- 현재 로또 생성기는 자동 생성 기능만 제공한다. 사용자가 수동으로 추첨 번호를 입력할 수 있도록 해야 한다.
+- 입력한 금액, 자동 생성 숫자, 수동 생성 번호를 입력하도록 해야 한다.
+
+## 실행 결과
+```
+구입금액을 입력해 주세요.
+14000
+
+수동으로 구매할 로또 수를 입력해 주세요.
+3
+
+수동으로 구매할 번호를 입력해 주세요.
+8, 21, 23, 41, 42, 43
+3, 5, 11, 16, 32, 38
+7, 11, 16, 35, 36, 44
+
+수동으로 3장, 자동으로 11개를 구매했습니다.
+[8, 21, 23, 41, 42, 43]
+[3, 5, 11, 16, 32, 38]
+[7, 11, 16, 35, 36, 44]
+[1, 8, 11, 31, 41, 42]
+[13, 14, 16, 38, 42, 45]
+[7, 11, 30, 40, 42, 43]
+[2, 13, 22, 32, 38, 45]
+[23, 25, 33, 36, 39, 41]
+[1, 3, 5, 14, 22, 45]
+[5, 9, 38, 41, 43, 44]
+[2, 8, 9, 18, 19, 21]
+[13, 14, 18, 21, 23, 35]
+[17, 21, 29, 37, 42, 45]
+[3, 8, 27, 30, 35, 44]
+
+지난 주 당첨 번호를 입력해 주세요.
+1, 2, 3, 4, 5, 6
+보너스 볼을 입력해 주세요.
+7
+
+당첨 통계
+---------
+3개 일치 (5000원)- 1개
+4개 일치 (50000원)- 0개
+5개 일치 (1500000원)- 0개
+5개 일치, 보너스 볼 일치(30000000원) - 0개
+6개 일치 (2000000000원)- 0개
+총 수익률은 0.35입니다.(기준이 1이기 때문에 결과적으로 손해라는 의미임)
+```
+
+## 프로그래밍 요구 사항
+- 모든 원시값과 문자열을 포장한다.
+- 예외 처리를 통해 에러가 발생하지 않도록 한다.
+- 모든 기능을 TDD로 구현해 단위 테스트가 존재해야 한다. 단, UI(System.out, System.in) 로직은 제외
+- Enum 클래스를 적용해 프로그래밍을 구현한다.
+- 일급 컬렉션을 쓴다.
+- indent(인덴트, 들여쓰기) depth를 2를 넘지 않도록 구현한다. 1까지만 허용한다.
+- 예를 들어 while문 안에 if문이 있으면 들여쓰기는 2이다.
+- 함수(또는 메서드)가 한 가지 일만 잘 하도록 구현한다.
+- 기능을 구현하기 전에 README.md 파일에 구현할 기능 목록을 정리해 추가한다.
+- git의 commit 단위는 앞 단계에서 README.md 파일에 정리한 기능 목록 단위로 추가한다.
+
+## 힌트
+- 모든 원시값과 문자열을 포장한다.
+- 로또 숫자 하나는 Int다. 이 숫자 하나를 추상화한 LottoNumber를 추가해 구현한다.
+- 예외 처리를 통해 에러가 발생하지 않도록 한다.
+- 참고로 코틀린에서는 아래와 같이 예외 처리를 한다. 장기적으로는 아래와 같이 예외 처리하는 걸 연습해 본다.
+- 논리적인 오류일 때만 예외를 던진다.
+- 논리적인 오류가 아니면 예외를 던지지 말고 null을 반환한다.
+- 실패하는 경우가 복잡해서 null로 처리할 수 없으면 sealed class를 반환한다.
+- 일반적인 코틀린 코드에서 try-catch를 사용하지 않는다.
+
+--- 
+
 # 🚀 3단계 - 로또(2등)
 
 ## 기능 요구사항
diff --git a/src/main/kotlin/lotto/README.md b/src/main/kotlin/lotto/README.md
index 8fd8e215cd..33cfac6d72 100644
--- a/src/main/kotlin/lotto/README.md
+++ b/src/main/kotlin/lotto/README.md
@@ -1,5 +1,18 @@
 # TODO
 
+## 구현할 '로또(수동)' 기능 목록
+- [x] 정수값 포장 클래스 생성
+- [x] 실수값 포장 클래스 생성
+- [x] 입력 문자열 포장 클래스 생성
+- [x] 수동으로 구매할 로또 수 입력 기능
+- [x] 수동으로 구매할 로또 번호 입력 기능
+- [x] 수동 로또 생성 기능
+- [x] 수동 로또, 자동 로또 출력 기능
+- [x] 지불한 금액 클래스 생성
+- [x] 로또 번호 클래스 생성
+- [x] 입력 문자열 클래스 생성
+- [x] 예외 케이스 검토하여 처리
+
 ## 구현할 '로또(2등)' 기능 목록
 - [x] 보너스 볼 입력 기능
 - [x] 당첨 통계에 2등 결과 추가
diff --git a/src/main/kotlin/lotto/application/Application.kt b/src/main/kotlin/lotto/application/Application.kt
index 7ff75d68ed..9520ed1f59 100644
--- a/src/main/kotlin/lotto/application/Application.kt
+++ b/src/main/kotlin/lotto/application/Application.kt
@@ -1,9 +1,10 @@
 package lotto.application
 
+import lotto.domain.Lotto
 import lotto.domain.LottoGenerator
+import lotto.domain.LottoNumber
 import lotto.domain.LottoResultService
 import lotto.domain.LottoShop
-import lotto.domain.LuckyNumbers
 import lotto.util.RandomNumberGenerator
 import lotto.view.InputView
 import lotto.view.ResultView
@@ -11,17 +12,24 @@ import lotto.view.ResultView
 class Application {
     private val inputView = InputView()
     private val resultView = ResultView()
-    private val lottoShop = LottoShop(LottoGenerator(RandomNumberGenerator()))
+    private val lottoGenerator = LottoGenerator(RandomNumberGenerator())
 
     fun run() {
         val inputPayment = inputView.inputPayment()
-        val lottoList = lottoShop.buyLotto(inputPayment)
-        resultView.printLotto(lottoList)
+        val manualLottoCount = inputView.inputManualLottoCount()
+        val manualNumberList = inputView.inputManualLottoNumbers(manualLottoCount)
 
+        val lottoShop = LottoShop(lottoGenerator, inputPayment)
+
+        val manualLottoList = lottoShop.buyManualLotto(manualNumberList)
+        val autoLottoList = lottoShop.buyAutoLotto()
+        resultView.printLottoList(manualLottoList, autoLottoList)
+
+        val lottoList = manualLottoList + autoLottoList
         val inputLuckyNumbers = inputView.inputLuckyNumbers()
         val inputBonusNumber = inputView.inputBonusNumber()
 
-        val lottoResultService = LottoResultService(LuckyNumbers(inputLuckyNumbers, inputBonusNumber))
+        val lottoResultService = LottoResultService(Lotto(inputLuckyNumbers.integerNumberList.map { LottoNumber(it) }), LottoNumber(inputBonusNumber))
         val statistics = lottoResultService.inquireStatistics(inputPayment, lottoList)
         resultView.printLottoStatistics(statistics)
     }
diff --git a/src/main/kotlin/lotto/common/IntegerNumberList.kt b/src/main/kotlin/lotto/common/IntegerNumberList.kt
new file mode 100644
index 0000000000..6b4b00c753
--- /dev/null
+++ b/src/main/kotlin/lotto/common/IntegerNumberList.kt
@@ -0,0 +1,5 @@
+package lotto.common
+
+class IntegerNumberList(
+    val integerNumberList: List<Int>
+)
diff --git a/src/main/kotlin/lotto/common/NumberString.kt b/src/main/kotlin/lotto/common/NumberString.kt
new file mode 100644
index 0000000000..45f54cc0b7
--- /dev/null
+++ b/src/main/kotlin/lotto/common/NumberString.kt
@@ -0,0 +1,18 @@
+package lotto.common
+
+class NumberString(
+    private val string: String
+) {
+    init {
+        require(string.isNotBlank()) { "값이 비어있습니다." }
+        require(isNumber()) { "숫자가 아닙니다. (입력값:$string)" }
+    }
+
+    private fun isNumber(): Boolean {
+        return string.toCharArray().all { it in '0'..'9' }
+    }
+
+    fun toIntegerNumber(): Int {
+        return string.toInt()
+    }
+}
diff --git a/src/main/kotlin/lotto/common/NumberStringList.kt b/src/main/kotlin/lotto/common/NumberStringList.kt
new file mode 100644
index 0000000000..2a5e8f1751
--- /dev/null
+++ b/src/main/kotlin/lotto/common/NumberStringList.kt
@@ -0,0 +1,11 @@
+package lotto.common
+
+class NumberStringList(
+    string: String
+) {
+    val list = string.split(",").map { NumberString(it.trim()) }
+
+    fun toIntegerNumberList(): List<Int> {
+        return list.map { it.toIntegerNumber() }
+    }
+}
diff --git a/src/main/kotlin/lotto/domain/Lotto.kt b/src/main/kotlin/lotto/domain/Lotto.kt
index 3490cb738d..4ccef854fc 100644
--- a/src/main/kotlin/lotto/domain/Lotto.kt
+++ b/src/main/kotlin/lotto/domain/Lotto.kt
@@ -1,10 +1,20 @@
 package lotto.domain
 
 class Lotto(
-    val numbers: List<Int>
+    val lottoNumbers: List<LottoNumber>
 ) {
     init {
-        require(numbers.size == LOTTO_NUMBERS_SIZE) { "로또 번호는 ${LOTTO_NUMBERS_SIZE}개가 필요합니다." }
+        require(lottoNumbers.size == LOTTO_NUMBERS_SIZE) { "로또 번호는 ${LOTTO_NUMBERS_SIZE}개가 필요합니다." }
+        require(lottoNumbers.toSet().size == LOTTO_NUMBERS_SIZE) { "번호에 중복이 있습니다." }
+    }
+
+    fun countHitNumbers(luckyLotto: Lotto): Int {
+        val count = lottoNumbers.count { luckyLotto.lottoNumbers.contains(it) }
+        return count
+    }
+
+    fun hasBonusNumber(bonusNumber: LottoNumber): Boolean {
+        return lottoNumbers.contains(bonusNumber)
     }
 
     companion object {
diff --git a/src/main/kotlin/lotto/domain/LottoGenerator.kt b/src/main/kotlin/lotto/domain/LottoGenerator.kt
index 02ca2248b7..578b0679e3 100644
--- a/src/main/kotlin/lotto/domain/LottoGenerator.kt
+++ b/src/main/kotlin/lotto/domain/LottoGenerator.kt
@@ -1,5 +1,6 @@
 package lotto.domain
 
+import lotto.common.IntegerNumberList
 import lotto.util.NumberGenerator
 
 class LottoGenerator(
@@ -9,7 +10,15 @@ class LottoGenerator(
         return List(size) { Lotto(randomNumber()) }
     }
 
-    private fun randomNumber(): List<Int> {
+    private fun randomNumber(): List<LottoNumber> {
         return numberGenerator.generate(Lotto.LOTTO_START_NUMBER, Lotto.LOTTO_END_NUMBER, Lotto.LOTTO_NUMBERS_SIZE)
+            .map { LottoNumber(it) }
+    }
+
+    fun generate(numberList: List<IntegerNumberList>): List<Lotto> {
+        return numberList.map {
+            val lottoNumberList = it.integerNumberList.map { number -> LottoNumber(number) }
+            Lotto(lottoNumberList)
+        }
     }
 }
diff --git a/src/main/kotlin/lotto/domain/LottoNumber.kt b/src/main/kotlin/lotto/domain/LottoNumber.kt
new file mode 100644
index 0000000000..3a6cd962b7
--- /dev/null
+++ b/src/main/kotlin/lotto/domain/LottoNumber.kt
@@ -0,0 +1,19 @@
+package lotto.domain
+
+data class LottoNumber(
+    val number: Int
+) {
+
+    init {
+        require(number in LOTTO_MIN_NUMBER..LOTTO_MAX_NUMBER) { "로또 번호는 ${LOTTO_MIN_NUMBER}와 $LOTTO_MAX_NUMBER 사이 값 이여야 합니다." }
+    }
+
+    companion object {
+        const val LOTTO_MIN_NUMBER = 1
+        const val LOTTO_MAX_NUMBER = 45
+    }
+
+    override fun toString(): String {
+        return "$number"
+    }
+}
diff --git a/src/main/kotlin/lotto/domain/LottoRank.kt b/src/main/kotlin/lotto/domain/LottoRank.kt
index f0be7906b7..5c632eadb1 100644
--- a/src/main/kotlin/lotto/domain/LottoRank.kt
+++ b/src/main/kotlin/lotto/domain/LottoRank.kt
@@ -2,30 +2,30 @@ package lotto.domain
 
 enum class LottoRank(
     val hitCount: Int,
-    val hasBonusNumber: Boolean,
-    val prizeMoney: Int
+    val prizeMoney: Money,
+    val hasBonusNumber: Boolean = false
 ) {
-    FIRST(6, false, 2000000000),
-    SECOND(5, true, 30000000),
-    THIRD(5, false, 1500000),
-    FOURTH(4, false, 50000),
-    FIFTH(3, false, 5000),
-    MISS(0, false, 0);
+    FIRST(hitCount = 6, prizeMoney = Money(2000000000)),
+    SECOND(hitCount = 5, prizeMoney = Money(30000000), hasBonusNumber = true),
+    THIRD(hitCount = 5, prizeMoney = Money(1500000)),
+    FOURTH(hitCount = 4, prizeMoney = Money(50000)),
+    FIFTH(hitCount = 3, prizeMoney = Money(5000)),
+    MISS(hitCount = 0, prizeMoney = Money(0));
 
-    companion object {
-        fun from(hitCount: Int, hasBonusNumber: Boolean): LottoRank {
-            return values().find { it.hitCount == hitCount && isHitBonusNumber(it, hasBonusNumber) } ?: return MISS
+    private fun isHitBonusNumber(it: LottoRank, hasBonusNumber: Boolean): Boolean {
+        if (it.hasBonusNumber) {
+            return hasBonusNumber
         }
+        return true
+    }
 
-        private fun isHitBonusNumber(it: LottoRank, hasBonusNumber: Boolean): Boolean {
-            if (it.hasBonusNumber) {
-                return hasBonusNumber
-            }
-            return true
+    companion object {
+        fun from(hitCount: Int, hasBonusNumber: Boolean): LottoRank {
+            return values().find { it.hitCount == hitCount && it.isHitBonusNumber(it, hasBonusNumber) } ?: return MISS
         }
 
         fun winRanks(): List<LottoRank> {
-            return values().filter { it.prizeMoney > 0 }.reversed()
+            return values().filter { it.prizeMoney.amount > 0 }.reversed()
         }
     }
 }
diff --git a/src/main/kotlin/lotto/domain/LottoResultService.kt b/src/main/kotlin/lotto/domain/LottoResultService.kt
index 5e390438ff..737e41e058 100644
--- a/src/main/kotlin/lotto/domain/LottoResultService.kt
+++ b/src/main/kotlin/lotto/domain/LottoResultService.kt
@@ -1,12 +1,26 @@
 package lotto.domain
 
 class LottoResultService(
-    private val luckyNumbers: LuckyNumbers,
+    private val luckyLotto: Lotto,
+    private val bonusNumber: LottoNumber
 ) {
-    fun inquireStatistics(payment: Int, lottoList: List<Lotto>): LottoStatisticsTotal {
-        val lottoWinner = LottoWinner(luckyNumbers)
-        val winLottoList = lottoWinner.findWinLottoList(lottoList)
+    fun inquireStatistics(payment: Payment, lottoList: List<Lotto>): LottoStatisticsTotal {
+        val winLottoList = findWinLottoList(lottoList)
         val lottoStatisticsService = LottoStatisticsService(payment, winLottoList)
         return lottoStatisticsService.statistics()
     }
+
+    private fun findWinLottoList(lottoList: List<Lotto>): List<LottoRank> {
+        return lottoList
+            .map { rank(it, bonusNumber) }
+            .filter { hasPrize(it) }
+    }
+
+    private fun rank(lotto: Lotto, bonusNumber: LottoNumber): LottoRank {
+        val hitCount = lotto.countHitNumbers(luckyLotto)
+        val hasBonusNumber = lotto.hasBonusNumber(bonusNumber)
+        return LottoRank.from(hitCount, hasBonusNumber)
+    }
+
+    private fun hasPrize(lottoRank: LottoRank) = lottoRank.prizeMoney.isPositive()
 }
diff --git a/src/main/kotlin/lotto/domain/LottoShop.kt b/src/main/kotlin/lotto/domain/LottoShop.kt
index 550fb1302d..1d3b747979 100644
--- a/src/main/kotlin/lotto/domain/LottoShop.kt
+++ b/src/main/kotlin/lotto/domain/LottoShop.kt
@@ -1,15 +1,33 @@
 package lotto.domain
 
+import lotto.common.IntegerNumberList
+
 class LottoShop(
-    private val lottoGenerator: LottoGenerator
+    private val lottoGenerator: LottoGenerator,
+    private var payment: Payment
 ) {
-    fun buyLotto(inputPayment: Int): List<Lotto> {
-        val lottoCount = calculateLottoCount(inputPayment)
-        return lottoGenerator.generate(lottoCount)
+    fun buyAutoLotto(): List<Lotto> {
+        val totalLottoCount = calculateLottoCount(payment)
+        return lottoGenerator.generate(totalLottoCount)
+    }
+
+    fun buyManualLotto(manualNumberList: List<IntegerNumberList>): List<Lotto> {
+        val totalLottoCount = calculateLottoCount(payment)
+        val manualLottoCount = manualNumberList.size
+
+        require(manualLottoCount <= totalLottoCount) { "수동 로또 개수가 지불 금액보다 많아 로또를 구입할 수 없습니다." }
+
+        val change = payment.charge(manualLottoCount * LOTTO_PRICE)
+        updatePayment(change)
+        return lottoGenerator.generate(manualNumberList)
+    }
+
+    private fun calculateLottoCount(payment: Payment): Int {
+        return payment.amount / LOTTO_PRICE
     }
 
-    private fun calculateLottoCount(payment: Int): Int {
-        return payment / LOTTO_PRICE
+    private fun updatePayment(newPayment: Payment) {
+        this.payment = newPayment
     }
 
     companion object {
diff --git a/src/main/kotlin/lotto/domain/LottoStatistics.kt b/src/main/kotlin/lotto/domain/LottoStatistics.kt
index f0172ef29c..faf3faa3b3 100644
--- a/src/main/kotlin/lotto/domain/LottoStatistics.kt
+++ b/src/main/kotlin/lotto/domain/LottoStatistics.kt
@@ -5,11 +5,10 @@ import lotto.util.NumberUtil
 class LottoStatistics(
     private val winLottoList: List<LottoRank>
 ) {
-    private val prizeList: List<Int> = winLottoList.map { it.prizeMoney }
-    private val totalPrize: Int = prizeList.sum()
+    private val totalPrize: Int = winLottoList.sumOf { it.prizeMoney.amount }
 
-    fun earningRate(inputPayment: Int): Double {
-        val earningRate = totalPrize.toDouble() / inputPayment.toDouble()
+    fun earningRate(inputPayment: Payment): Double {
+        val earningRate = totalPrize.toDouble() / inputPayment.amount.toDouble()
         return NumberUtil.floor(earningRate, EARNING_RATE_DECIMAL_PLACE)
     }
 
@@ -25,6 +24,6 @@ class LottoStatistics(
     }
 
     companion object {
-        private const val EARNING_RATE_DECIMAL_PLACE = 2
+        private const val EARNING_RATE_DECIMAL_PLACE = 2.0
     }
 }
diff --git a/src/main/kotlin/lotto/domain/LottoStatisticsService.kt b/src/main/kotlin/lotto/domain/LottoStatisticsService.kt
index acc58d1051..f6f5dbb6a1 100644
--- a/src/main/kotlin/lotto/domain/LottoStatisticsService.kt
+++ b/src/main/kotlin/lotto/domain/LottoStatisticsService.kt
@@ -1,7 +1,7 @@
 package lotto.domain
 
 class LottoStatisticsService(
-    private val payment: Int,
+    private val payment: Payment,
     private val winLottoList: List<LottoRank>
 ) {
     fun statistics(): LottoStatisticsTotal {
diff --git a/src/main/kotlin/lotto/domain/LottoWinner.kt b/src/main/kotlin/lotto/domain/LottoWinner.kt
deleted file mode 100644
index f8379ff532..0000000000
--- a/src/main/kotlin/lotto/domain/LottoWinner.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package lotto.domain
-
-class LottoWinner(
-    private val luckyNumbers: LuckyNumbers
-) {
-    fun findWinLottoList(lottoList: List<Lotto>): List<LottoRank> {
-        return lottoList
-            .map { luckyNumbers.rank(it.numbers) }
-            .filter { hasPrize(it) }
-    }
-
-    private fun hasPrize(lottoRank: LottoRank) = lottoRank.prizeMoney > 0
-}
diff --git a/src/main/kotlin/lotto/domain/LuckyNumbers.kt b/src/main/kotlin/lotto/domain/LuckyNumbers.kt
deleted file mode 100644
index 384d90683d..0000000000
--- a/src/main/kotlin/lotto/domain/LuckyNumbers.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-package lotto.domain
-
-class LuckyNumbers(
-    private val luckyNumbers: List<Int>,
-    private val bonusNumber: Int
-) {
-    init {
-        require(luckyNumbers.size == LUCKY_NUMBER_SIZE) { "당첨 번호는 ${LUCKY_NUMBER_SIZE}개가 필요합니다." }
-        require(luckyNumbers.toSet().size == LUCKY_NUMBER_SIZE) { "당첨 번호에 중복이 있습니다." }
-        require(!luckyNumbers.contains(bonusNumber)) { "보너스볼은 당첨번호와 중복될 수 없습니다." }
-    }
-
-    fun rank(numbers: List<Int>): LottoRank {
-        val hitCount = countHitNumbers(numbers)
-        val hasBonusNumber = containsBonusNumber(numbers)
-        return LottoRank.from(hitCount, hasBonusNumber)
-    }
-
-    private fun countHitNumbers(numbers: List<Int>): Int {
-        return numbers.count { number -> luckyNumbers.contains(number) }
-    }
-
-    private fun containsBonusNumber(numbers: List<Int>): Boolean {
-        return numbers.contains(bonusNumber)
-    }
-
-    companion object {
-        const val LUCKY_NUMBER_SIZE = 6
-    }
-}
diff --git a/src/main/kotlin/lotto/domain/Money.kt b/src/main/kotlin/lotto/domain/Money.kt
new file mode 100644
index 0000000000..dea49b576f
--- /dev/null
+++ b/src/main/kotlin/lotto/domain/Money.kt
@@ -0,0 +1,13 @@
+package lotto.domain
+
+data class Money(
+    val amount: Int
+) {
+    fun isPositive(): Boolean {
+        return amount > 0
+    }
+
+    override fun toString(): String {
+        return "$amount"
+    }
+}
diff --git a/src/main/kotlin/lotto/domain/Payment.kt b/src/main/kotlin/lotto/domain/Payment.kt
new file mode 100644
index 0000000000..fd86ab0255
--- /dev/null
+++ b/src/main/kotlin/lotto/domain/Payment.kt
@@ -0,0 +1,14 @@
+package lotto.domain
+
+data class Payment(
+    var amount: Int
+) {
+    init {
+        require(amount >= 0) { "지불액은 음수가 될 수 없습니다." }
+    }
+
+    fun charge(charge: Int): Payment {
+        require(amount >= charge) { "잔액 부족으로 금액을 차감할 수 없습니다." }
+        return Payment(amount.minus(charge))
+    }
+}
diff --git a/src/main/kotlin/lotto/util/NumberUtil.kt b/src/main/kotlin/lotto/util/NumberUtil.kt
index 77a445ef60..9c2bd66be7 100644
--- a/src/main/kotlin/lotto/util/NumberUtil.kt
+++ b/src/main/kotlin/lotto/util/NumberUtil.kt
@@ -1,15 +1,14 @@
 package lotto.util
 
-import kotlin.math.floor
 import kotlin.math.pow
 
 object NumberUtil {
-    fun floor(number: Double, decimalPlace: Int): Double {
-        if (decimalPlace == -1) {
+    fun floor(number: Double, decimalPlace: Double): Double {
+        if (decimalPlace < 0) {
             return number
         }
-        val pow = 10.0.pow(decimalPlace.toDouble())
-        val floor = floor(number * pow)
+        val pow = 10.0.pow(decimalPlace)
+        val floor = kotlin.math.floor(number * pow)
         return floor / pow
     }
 }
diff --git a/src/main/kotlin/lotto/util/RandomNumberGenerator.kt b/src/main/kotlin/lotto/util/RandomNumberGenerator.kt
index fb80a9364e..3818b02baf 100644
--- a/src/main/kotlin/lotto/util/RandomNumberGenerator.kt
+++ b/src/main/kotlin/lotto/util/RandomNumberGenerator.kt
@@ -1,9 +1,10 @@
 package lotto.util
 
-class RandomNumberGenerator: NumberGenerator {
+class RandomNumberGenerator : NumberGenerator {
     override fun generate(start: Int, end: Int, size: Int): List<Int> {
         val range = start..end
         val shuffled = range.shuffled()
-        return shuffled.subList(0, size)
+        val subList = shuffled.subList(0, size)
+        return subList.map { it }
     }
 }
diff --git a/src/main/kotlin/lotto/util/StringValidator.kt b/src/main/kotlin/lotto/util/StringValidator.kt
deleted file mode 100644
index cd1e8221fe..0000000000
--- a/src/main/kotlin/lotto/util/StringValidator.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package lotto.util
-
-object StringValidator {
-    fun validateNumber(string: String) {
-        val isNumeric = string.toCharArray().all { it in '0'..'9' }
-        if (!isNumeric) {
-            throw IllegalArgumentException("숫자가 아닙니다. (입력값:$string)")
-        }
-    }
-
-    fun validateNotBlank(string: String) {
-        if (string.isBlank()) {
-            throw IllegalArgumentException("값이 비어있습니다.")
-        }
-    }
-}
diff --git a/src/main/kotlin/lotto/view/InputView.kt b/src/main/kotlin/lotto/view/InputView.kt
index 1053b55a6f..c173d0f256 100644
--- a/src/main/kotlin/lotto/view/InputView.kt
+++ b/src/main/kotlin/lotto/view/InputView.kt
@@ -1,50 +1,53 @@
 package lotto.view
 
-import lotto.util.StringValidator
+import lotto.common.IntegerNumberList
+import lotto.common.NumberString
+import lotto.common.NumberStringList
+import lotto.domain.Payment
 
 class InputView {
 
-    fun inputPayment(): Int {
+    fun inputPayment(): Payment {
         println(INPUT_PAYMENT_GUIDE)
-        val payment = readln()
-        validatePaymentInput(payment)
-        return payment.toInt()
+        val payment = NumberString(readln())
+        return Payment(payment.toIntegerNumber())
     }
 
-    private fun validatePaymentInput(payment: String) {
-        StringValidator.validateNotBlank(payment)
-        StringValidator.validateNumber(payment)
+    fun inputManualLottoCount(): Int {
+        println(INPUT_MANUAL_LOTTO_COUNT_GUIDE)
+        return inputNumber()
     }
 
-    fun inputLuckyNumbers(): List<Int> {
-        println(INPUT_LUCKY_NUMBERS_GUIDE)
-        val luckyNumberString = readln()
-        val luckyNumbers = splitNumbers(luckyNumberString)
-        validateLuckyNumbersInput(luckyNumbers)
-        return convert(luckyNumbers)
+    fun inputManualLottoNumbers(count: Int): List<IntegerNumberList> {
+        println(INPUT_MANUAL_LOTTO_NUMBERS_GUIDE)
+        return List(count) {
+            inputNumberList()
+        }
     }
 
-    private fun splitNumbers(input: String) = input.split(",").map { it.trim() }
-
-    private fun validateLuckyNumbersInput(split: List<String>) {
-        split.forEach {
-            StringValidator.validateNotBlank(it)
-            StringValidator.validateNumber(it)
-        }
+    fun inputLuckyNumbers(): IntegerNumberList {
+        println(INPUT_LUCKY_NUMBERS_GUIDE)
+        return inputNumberList()
     }
 
-    private fun convert(split: List<String>): List<Int> {
-        return split.map { it.toInt() }
+    private fun inputNumberList(): IntegerNumberList {
+        val numberList = NumberStringList(readln()).toIntegerNumberList()
+        return IntegerNumberList(numberList)
     }
 
     fun inputBonusNumber(): Int {
         println(INPUT_BONUS_BALL)
-        val bonusBallNumberString = readln()
-        return bonusBallNumberString.toInt()
+        return inputNumber()
+    }
+
+    private fun inputNumber(): Int {
+        return NumberString(readln()).toIntegerNumber()
     }
 
     private companion object {
         const val INPUT_PAYMENT_GUIDE = "# 구입금액을 입력해주세요."
+        const val INPUT_MANUAL_LOTTO_COUNT_GUIDE = "# 수동으로 구매할 로또 수를 입력해 주세요."
+        const val INPUT_MANUAL_LOTTO_NUMBERS_GUIDE = "# 수동으로 구매할 번호를 입력해 주세요."
         const val INPUT_LUCKY_NUMBERS_GUIDE = "# 지난 주 당첨 번호를 입력해 주세요."
         const val INPUT_BONUS_BALL = "# 보너스 볼을 입력해 주세요."
     }
diff --git a/src/main/kotlin/lotto/view/ResultView.kt b/src/main/kotlin/lotto/view/ResultView.kt
index d38089efaa..ce1dc5c555 100644
--- a/src/main/kotlin/lotto/view/ResultView.kt
+++ b/src/main/kotlin/lotto/view/ResultView.kt
@@ -7,14 +7,21 @@ import lotto.domain.LottoStatisticsTotal
 
 class ResultView {
 
-    fun printLotto(lottoList: List<Lotto>) {
-        println("${lottoList.size}개를 구매했습니다.")
-        lottoList.forEach {
-            println(it.numbers)
+    fun printLottoList(manualLottoList: List<Lotto>, autoLottoList: List<Lotto>) {
+        println("수동으로 ${manualLottoList.size}개, 자동으로 ${autoLottoList.size}개를 구매했습니다.")
+        manualLottoList.forEach {
+            printLotto(it)
+        }
+        autoLottoList.forEach {
+            printLotto(it)
         }
         emptyLine()
     }
 
+    private fun printLotto(lotto: Lotto) {
+        println(lotto.lottoNumbers)
+    }
+
     fun printLottoStatistics(statisticsResult: LottoStatisticsTotal) {
         emptyLine()
         println(STATISTICS_GUIDE)
@@ -41,7 +48,7 @@ class ResultView {
 
     private fun printEarningRate(earningRate: Double) {
         print("총 수익률은 ${earningRate}입니다. ")
-        if (earningRate > 1) {
+        if (earningRate >= 1.0) {
             println("(기준이 1이기 때문에 이익입니다.)")
             return
         }
diff --git a/src/main/kotlin/stringCalculator/StringAddCalculator.kt b/src/main/kotlin/stringCalculator/StringAddCalculator.kt
index 00554ff064..48286c9c95 100644
--- a/src/main/kotlin/stringCalculator/StringAddCalculator.kt
+++ b/src/main/kotlin/stringCalculator/StringAddCalculator.kt
@@ -23,7 +23,8 @@ class StringAddCalculator {
         return split(numberString, delimiter)
     }
 
-    private fun split(string: String, delimiter: Regex = DEFAULT_DELIMITER_REGEX): List<String> = string.split(delimiter)
+    private fun split(string: String, delimiter: Regex = DEFAULT_DELIMITER_REGEX): List<String> =
+        string.split(delimiter)
 
     private fun split(string: String, delimiter: String): List<String> {
         if (delimiter.isEmpty()) {
diff --git a/src/test/kotlin/lotto/common/NumberStringListTest.kt b/src/test/kotlin/lotto/common/NumberStringListTest.kt
new file mode 100644
index 0000000000..74c446d2fd
--- /dev/null
+++ b/src/test/kotlin/lotto/common/NumberStringListTest.kt
@@ -0,0 +1,38 @@
+package lotto.common
+
+import io.kotest.assertions.throwables.shouldThrowExactly
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class NumberStringListTest : StringSpec({
+
+    "숫자 아닐때 에러 발생 테스트" {
+        val exception = shouldThrowExactly<IllegalArgumentException> {
+            NumberStringList("1,a")
+        }
+        exception.message shouldBe "숫자가 아닙니다. (입력값:a)"
+    }
+
+    "빈 문자열 일 때 에러 테스트" {
+        val exception = shouldThrowExactly<IllegalArgumentException> {
+            NumberStringList("1,")
+        }
+        exception.message shouldBe "값이 비어있습니다."
+    }
+
+    "공백 문자열 일 때 에러 테스트" {
+        val exception = shouldThrowExactly<IllegalArgumentException> {
+            NumberStringList("1,   ")
+        }
+        exception.message shouldBe "값이 비어있습니다."
+    }
+
+    "숫자 리스트 변환 테스트" {
+        // given
+        val numberStringList = NumberStringList("1,2,3,4,5")
+        // when
+        val numberList = numberStringList.toIntegerNumberList()
+        // then
+        numberList shouldBe listOf(1, 2, 3, 4, 5)
+    }
+})
diff --git a/src/test/kotlin/lotto/util/StringValidatorTest.kt b/src/test/kotlin/lotto/common/NumberStringTest.kt
similarity index 73%
rename from src/test/kotlin/lotto/util/StringValidatorTest.kt
rename to src/test/kotlin/lotto/common/NumberStringTest.kt
index 45130c6e26..ea121ec8bb 100644
--- a/src/test/kotlin/lotto/util/StringValidatorTest.kt
+++ b/src/test/kotlin/lotto/common/NumberStringTest.kt
@@ -1,27 +1,28 @@
-package lotto.util
+package lotto.common
 
 import io.kotest.assertions.throwables.shouldThrowExactly
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.shouldBe
 
-class StringValidatorTest : StringSpec({
+class NumberStringTest : StringSpec({
+
     "숫자 아닐때 에러 발생 테스트" {
         val exception = shouldThrowExactly<IllegalArgumentException> {
-            StringValidator.validateNumber("1!")
+            NumberString("1!")
         }
         exception.message shouldBe "숫자가 아닙니다. (입력값:1!)"
     }
 
     "빈 문자열 일 때 에러 테스트" {
         val exception = shouldThrowExactly<IllegalArgumentException> {
-            StringValidator.validateNotBlank("")
+            NumberString("")
         }
         exception.message shouldBe "값이 비어있습니다."
     }
 
-    "공백 문자열 에러 테스트" {
+    "공백 문자열 일 때 에러 테스트" {
         val exception = shouldThrowExactly<IllegalArgumentException> {
-            StringValidator.validateNotBlank("  ")
+            NumberString("   ")
         }
         exception.message shouldBe "값이 비어있습니다."
     }
diff --git a/src/test/kotlin/lotto/domain/LottoShopTest.kt b/src/test/kotlin/lotto/domain/LottoShopTest.kt
index e7547dfbf0..ca474cdf1e 100644
--- a/src/test/kotlin/lotto/domain/LottoShopTest.kt
+++ b/src/test/kotlin/lotto/domain/LottoShopTest.kt
@@ -3,24 +3,50 @@ package lotto.domain
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.data.forAll
 import io.kotest.data.row
+import io.kotest.matchers.equality.shouldBeEqualToComparingFields
 import io.kotest.matchers.shouldBe
+import lotto.common.IntegerNumberList
 import lotto.util.RandomNumberGenerator
 
 class LottoShopTest : StringSpec({
 
     val lottoShop = LottoShop(LottoGenerator(RandomNumberGenerator()))
 
-    "로또 구매 테스트" {
+    "로또 구매 개수 검증 테스트" {
         forAll(
             // given
-            row("0원을 내면 0개를 반환한다.", 0, 0),
-            row("5000원을 내면 5개를 반환한다.", 5000, 5),
-            row("5500원을 내면 5개를 반환한다.", 5500, 5)
+            row("0원을 내면 0개를 반환한다.", Payment(0), 0),
+            row("5000원을 내면 5개를 반환한다.", Payment(5000), 5),
+            row("5500원을 내면 5개를 반환한다.", Payment(5500), 5)
         ) { title, payment, expectedSize ->
             // when
-            val actual = lottoShop.buyLotto(payment)
+            val actual = lottoShop.buyAutoLotto(payment)
             // then
             actual.size shouldBe expectedSize
         }
     }
+
+    "수동 로또 구매 테스트" {
+        val manualNumberList = IntegerNumberList(
+            listOf(
+                1,
+                2,
+                3,
+                4,
+                5,
+                6
+            )
+        )
+        val result = lottoShop.buyManualLotto(Payment(1000), listOf(manualNumberList))
+        result[0] shouldBeEqualToComparingFields Lotto(
+            listOf(
+                LottoNumber(1),
+                LottoNumber(2),
+                LottoNumber(3),
+                LottoNumber(4),
+                LottoNumber(5),
+                LottoNumber(6)
+            )
+        )
+    }
 })
diff --git a/src/test/kotlin/lotto/domain/LottoStatisticsServiceTest.kt b/src/test/kotlin/lotto/domain/LottoStatisticsServiceTest.kt
index 2415d14d82..baea82e0a1 100644
--- a/src/test/kotlin/lotto/domain/LottoStatisticsServiceTest.kt
+++ b/src/test/kotlin/lotto/domain/LottoStatisticsServiceTest.kt
@@ -10,7 +10,7 @@ class LottoStatisticsServiceTest : StringSpec({
 
     "당첨자 통계 통합 결과 테스트" {
         // given
-        val payment = 15000
+        val payment = Payment(15000)
         forAll(
             row(
                 LottoRank.FOURTH,
diff --git a/src/test/kotlin/lotto/domain/LottoStatisticsTest.kt b/src/test/kotlin/lotto/domain/LottoStatisticsTest.kt
index caef33336c..5b837b7d9c 100644
--- a/src/test/kotlin/lotto/domain/LottoStatisticsTest.kt
+++ b/src/test/kotlin/lotto/domain/LottoStatisticsTest.kt
@@ -8,9 +8,9 @@ import io.kotest.matchers.shouldBe
 class LottoStatisticsTest : StringSpec({
     "로또 수익률 계산 테스트" {
         forAll(
-            row(listOf(LottoRank.FOURTH, LottoRank.FIFTH), 100000, 0.55),
-            row(listOf(LottoRank.FIFTH), 5000, 1.0),
-            row(listOf(LottoRank.FOURTH), 5000, 10),
+            row(listOf(LottoRank.FOURTH, LottoRank.FIFTH), Payment(100000), 0.55),
+            row(listOf(LottoRank.FIFTH), Payment(5000), 1.0),
+            row(listOf(LottoRank.FOURTH), Payment(5000), 10.0),
         ) { prizeList, payment, expectedEarningRate ->
             // given
             val lottoStatistics = LottoStatistics(prizeList)
diff --git a/src/test/kotlin/lotto/domain/LottoTest.kt b/src/test/kotlin/lotto/domain/LottoTest.kt
index 0b14972c5e..f7289d29b8 100644
--- a/src/test/kotlin/lotto/domain/LottoTest.kt
+++ b/src/test/kotlin/lotto/domain/LottoTest.kt
@@ -7,10 +7,96 @@ import io.kotest.matchers.shouldBe
 class LottoTest : StringSpec({
 
     "로또 번호가 6개를 넘으면 에러 발생 테스트" {
-        val numbers = listOf(1, 2, 3, 4, 5, 6, 7)
+        val numbers = listOf(
+            LottoNumber(1),
+            LottoNumber(2),
+            LottoNumber(3),
+            LottoNumber(4),
+            LottoNumber(5),
+            LottoNumber(6),
+            LottoNumber(7)
+        )
         val exception = shouldThrowExactly<IllegalArgumentException> {
             Lotto(numbers)
         }
         exception.message shouldBe "로또 번호는 6개가 필요합니다."
     }
+
+    "로또 번호 중복 에러 테스트" {
+        val numbers = listOf(
+            LottoNumber(1),
+            LottoNumber(2),
+            LottoNumber(3),
+            LottoNumber(4),
+            LottoNumber(5),
+            LottoNumber(1)
+        )
+        val exception = shouldThrowExactly<IllegalArgumentException> {
+            Lotto(numbers)
+        }
+        exception.message shouldBe "번호에 중복이 있습니다."
+    }
+
+    "당첨 번호 개수 카운트 테스트" {
+        // given
+        val numbers = listOf(
+            LottoNumber(1),
+            LottoNumber(2),
+            LottoNumber(3),
+            LottoNumber(4),
+            LottoNumber(5),
+            LottoNumber(6)
+        )
+        val lotto = Lotto(numbers)
+
+        val luckyNumbers = listOf(
+            LottoNumber(2),
+            LottoNumber(4),
+            LottoNumber(6),
+            LottoNumber(8),
+            LottoNumber(10),
+            LottoNumber(12)
+        )
+        val luckyLotto = Lotto(luckyNumbers)
+        // when
+        val actual = lotto.countHitNumbers(luckyLotto)
+        // then
+        actual shouldBe 3
+    }
+
+    "보너스 번호 포함되면 containsBonusNumber에서 true를 반환" {
+        // given
+        val numbers = listOf(
+            LottoNumber(1),
+            LottoNumber(2),
+            LottoNumber(3),
+            LottoNumber(4),
+            LottoNumber(5),
+            LottoNumber(6)
+        )
+        val lotto = Lotto(numbers)
+        val bonusNumber = LottoNumber(1)
+        // when
+        val actual = lotto.hasBonusNumber(bonusNumber)
+        // then
+        actual shouldBe true
+    }
+
+    "보너스 번호 포함 안되면 containsBonusNumber에서 false를 반환" {
+        // given
+        val numbers = listOf(
+            LottoNumber(1),
+            LottoNumber(2),
+            LottoNumber(3),
+            LottoNumber(4),
+            LottoNumber(5),
+            LottoNumber(6)
+        )
+        val lotto = Lotto(numbers)
+        val bonusNumber = LottoNumber(7)
+        // when
+        val actual = lotto.hasBonusNumber(bonusNumber)
+        // then
+        actual shouldBe false
+    }
 })
diff --git a/src/test/kotlin/lotto/domain/LottoWinnerTest.kt b/src/test/kotlin/lotto/domain/LottoWinnerTest.kt
deleted file mode 100644
index 5d831b3461..0000000000
--- a/src/test/kotlin/lotto/domain/LottoWinnerTest.kt
+++ /dev/null
@@ -1,25 +0,0 @@
-package lotto.domain
-
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.collections.shouldContainInOrder
-import io.kotest.matchers.shouldBe
-
-class LottoWinnerTest : StringSpec({
-
-    "당첨 로또 선택 테스트" {
-        // given
-        val luckyNumbers = listOf(1, 3, 5, 7, 9, 11)
-        val bonusNumber = 13
-        val lottoWinner = LottoWinner(LuckyNumbers(luckyNumbers, bonusNumber))
-
-        val fourthWinLotto = Lotto(listOf(5, 7, 9, 11, 12, 13))
-        val secondWinLotto = Lotto(listOf(3, 5, 7, 9, 11, 13))
-        val thirdWinLotto = Lotto(listOf(3, 5, 7, 9, 11, 15))
-        val notWintLotto = Lotto(listOf(2, 4, 6, 8, 10, 13))
-        // when
-        val result = lottoWinner.findWinLottoList(listOf(fourthWinLotto, notWintLotto, secondWinLotto, thirdWinLotto))
-        // then
-        result.size shouldBe 3
-        result shouldContainInOrder listOf(LottoRank.FOURTH, LottoRank.SECOND, LottoRank.THIRD)
-    }
-})
diff --git a/src/test/kotlin/lotto/domain/LuckyNumbersTest.kt b/src/test/kotlin/lotto/domain/LuckyNumbersTest.kt
deleted file mode 100644
index aabdad0046..0000000000
--- a/src/test/kotlin/lotto/domain/LuckyNumbersTest.kt
+++ /dev/null
@@ -1,52 +0,0 @@
-package lotto.domain
-
-import io.kotest.assertions.throwables.shouldThrowExactly
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.data.forAll
-import io.kotest.data.row
-import io.kotest.matchers.shouldBe
-
-class LuckyNumbersTest : StringSpec({
-    "당첨 번호가 6개를 넘으면 에러 발생 테스트" {
-        val numbers = listOf(1, 2, 3, 4, 5, 6, 7)
-        val exception = shouldThrowExactly<IllegalArgumentException> {
-            LuckyNumbers(luckyNumbers = numbers, bonusNumber = 10)
-        }
-        exception.message shouldBe "당첨 번호는 6개가 필요합니다."
-    }
-
-    "당첨 번호가 중복이면 에러 발생 테스트" {
-        val numbers = listOf(1, 2, 3, 4, 6, 6)
-        val exception = shouldThrowExactly<IllegalArgumentException> {
-            LuckyNumbers(luckyNumbers = numbers, bonusNumber = 10)
-        }
-        exception.message shouldBe "당첨 번호에 중복이 있습니다."
-    }
-
-    "보너스볼 중복 에러 테스트" {
-        val numbers = listOf(1, 2, 3, 4, 5, 6)
-        val exception = shouldThrowExactly<IllegalArgumentException> {
-            LuckyNumbers(luckyNumbers = numbers, bonusNumber = 6)
-        }
-        exception.message shouldBe "보너스볼은 당첨번호와 중복될 수 없습니다."
-    }
-
-    "로또 Hit Count 계산 테스트" {
-        forAll(
-            // given
-            row("0개 일치하는 로또", LuckyNumbers(luckyNumbers = listOf(1, 3, 5, 7, 9, 11), bonusNumber = 13), listOf(2, 4, 6, 8, 10, 12), LottoRank.MISS),
-            row("3개 일치하는 로또", LuckyNumbers(luckyNumbers = listOf(1, 3, 5, 7, 9, 11), bonusNumber = 13), listOf(7, 8, 9, 10, 11, 12), LottoRank.FIFTH),
-            row(
-                "5개 일치+보너스번호 일치하는 로또",
-                LuckyNumbers(luckyNumbers = listOf(1, 3, 5, 7, 9, 11), bonusNumber = 13),
-                listOf(1, 3, 5, 7, 9, 13),
-                LottoRank.SECOND
-            )
-        ) { title, luckyNumbers, lottoNumbers, expectedRank ->
-            // when
-            val actual = luckyNumbers.rank(lottoNumbers)
-            // then
-            actual shouldBe expectedRank
-        }
-    }
-})
diff --git a/src/test/kotlin/lotto/domain/MoneyTest.kt b/src/test/kotlin/lotto/domain/MoneyTest.kt
new file mode 100644
index 0000000000..3605234f0e
--- /dev/null
+++ b/src/test/kotlin/lotto/domain/MoneyTest.kt
@@ -0,0 +1,24 @@
+package lotto.domain
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class MoneyTest : StringSpec({
+    "양수값을 가졌을때 isPositive 에서 true를 반환한다." {
+        // given
+        val integer = Money(1)
+        // when
+        val actual = integer.isPositive()
+        // then
+        actual shouldBe true
+    }
+
+    "음수값을 가졌을때 isPositive 에서 false를 반환한다." {
+        // given
+        val integer = Money(-1)
+        // when
+        val actual = integer.isPositive()
+        // then
+        actual shouldBe false
+    }
+})
diff --git a/src/test/kotlin/lotto/domain/PaymentTest.kt b/src/test/kotlin/lotto/domain/PaymentTest.kt
new file mode 100644
index 0000000000..c953b5283a
--- /dev/null
+++ b/src/test/kotlin/lotto/domain/PaymentTest.kt
@@ -0,0 +1,34 @@
+package lotto.domain
+
+import io.kotest.assertions.throwables.shouldThrowExactly
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class PaymentTest : StringSpec({
+    "숫자 아닐때 에러 발생 테스트" {
+        val exception = shouldThrowExactly<IllegalArgumentException> {
+            Payment(-1)
+        }
+        exception.message shouldBe "지불액은 음수가 될 수 없습니다."
+    }
+
+    "지불금 차감 테스트" {
+        // given
+        val payment = Payment(1000)
+        // when
+        payment.charge(100)
+        // then
+        payment.amount shouldBe 900
+    }
+
+    "잔액 부족으로 지불금 차감 에러 테스트" {
+        // given
+        val payment = Payment(1000)
+        // when
+        val exception = shouldThrowExactly<IllegalArgumentException> {
+            payment.charge(1100)
+        }
+        // then
+        exception.message shouldBe "잔액 부족으로 금액을 차감할 수 없습니다."
+    }
+})
diff --git a/src/test/kotlin/lotto/util/NumberUtilTest.kt b/src/test/kotlin/lotto/util/NumberUtilTest.kt
index 2eadd4a249..5e6558654c 100644
--- a/src/test/kotlin/lotto/util/NumberUtilTest.kt
+++ b/src/test/kotlin/lotto/util/NumberUtilTest.kt
@@ -10,9 +10,9 @@ class NumberUtilTest : StringSpec({
     "소숫점 지정 자리수 이하 버림 테스트" {
         forAll(
             // given
-            row(1.2345, 0, 1.0),
-            row(1.2345, 3, 1.234),
-            row(1.2345, -1, 1.2345)
+            row(1.2345, 0.0, 1.0),
+            row(1.2345, 3.0, 1.234),
+            row(1.2345, -1.0, 1.2345)
         ) { number, decimalPlace, expectedResult ->
             // when
             val actualResult = NumberUtil.floor(number, decimalPlace)
diff --git a/src/test/kotlin/lotto/util/NumberGeneratorTest.kt b/src/test/kotlin/lotto/util/RandomNumberGeneratorTest.kt
similarity index 92%
rename from src/test/kotlin/lotto/util/NumberGeneratorTest.kt
rename to src/test/kotlin/lotto/util/RandomNumberGeneratorTest.kt
index 2decea957d..665c4f3e38 100644
--- a/src/test/kotlin/lotto/util/NumberGeneratorTest.kt
+++ b/src/test/kotlin/lotto/util/RandomNumberGeneratorTest.kt
@@ -4,7 +4,7 @@ import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.ints.shouldBeInRange
 
-class NumberGeneratorTest : StringSpec({
+class RandomNumberGeneratorTest : StringSpec({
 
     val numberGenerator = RandomNumberGenerator()