From dc0a080e7aed3190c5009ddf7afa07036720fa78 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 14:46:08 +0900
Subject: [PATCH 01/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep3]=20=ED=98=84=EC=9E=AC=20=EC=B9=B4=EB=93=9C=EC=9D=98=20?=
 =?UTF-8?q?=ED=95=A9=EC=9D=B4=2021=EC=9D=B4=20=EB=84=98=EC=A7=80=20?=
 =?UTF-8?q?=EC=95=8A=EB=8A=94=20=EA=B2=BD=EC=9A=B0=20y=20=EB=A5=BC=20?=
 =?UTF-8?q?=EC=84=A0=ED=83=9D=ED=96=88=EC=9D=84=20=EB=95=8C=20=EC=B9=B4?=
 =?UTF-8?q?=EB=93=9C=EB=A5=BC=20=EB=BD=91=EB=8F=84=EB=A1=9D=20=EB=A1=9C?=
 =?UTF-8?q?=EC=A7=81=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Dealer.kt | 2 +-
 src/main/kotlin/blackjack/domain/Player.kt | 7 ++-----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/Dealer.kt b/src/main/kotlin/blackjack/domain/Dealer.kt
index f46cbcb20..a3270c337 100644
--- a/src/main/kotlin/blackjack/domain/Dealer.kt
+++ b/src/main/kotlin/blackjack/domain/Dealer.kt
@@ -14,7 +14,7 @@ class Dealer(
     }
 
     fun drawOneMoreCardIfNeeded(onDrawCard: () -> Unit) {
-        addCardIfAvailable(requireCard = { drawCard() }, onDrawCard = onDrawCard)
+        addCardIfAvailable(requireCard = drawCard, onDrawCard = onDrawCard)
     }
 
     override fun isAddCardEnabled(): Boolean {
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 251acfb3f..065f44fb4 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -4,22 +4,19 @@ class Player(
     val name: String,
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
-    private lateinit var currentCard: Card
-
     fun play(
         isDrawCard: (String) -> Boolean,
         onDrawCard: () -> Unit,
         onExitPlay: () -> Unit,
     ) {
         while (isDrawCard(name)) {
-            currentCard = drawCard()
-            val isCardAdded = addCardIfAvailable(requireCard = { currentCard }, onDrawCard = onDrawCard)
+            val isCardAdded = addCardIfAvailable(requireCard = drawCard, onDrawCard = onDrawCard)
             if (isCardAdded.not()) break
         }
         onExitPlay()
     }
 
     override fun isAddCardEnabled(): Boolean {
-        return currentCard.isOverMaxSum(cardsSum).not()
+        return cardsSum <= 21
     }
 }

From 0f27917299cf7ff0d45aff8208aab4082fb68c8b Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 14:48:46 +0900
Subject: [PATCH 02/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep3]=20=EB=A7=A4=EC=A7=81=EB=84=98=EB=B2=84=20const=20=EB=A1=9C?=
 =?UTF-8?q?=20=EB=8C=80=EC=B2=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Dealer.kt                 | 3 ++-
 src/main/kotlin/blackjack/domain/Player.kt                 | 2 +-
 src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt | 4 ++--
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/Dealer.kt b/src/main/kotlin/blackjack/domain/Dealer.kt
index a3270c337..0d036e225 100644
--- a/src/main/kotlin/blackjack/domain/Dealer.kt
+++ b/src/main/kotlin/blackjack/domain/Dealer.kt
@@ -18,7 +18,7 @@ class Dealer(
     }
 
     override fun isAddCardEnabled(): Boolean {
-        return cardsSum <= 16
+        return cardsSum <= DEALER_DRAW_ONE_MORE_CARD_THRESHOLD
     }
 
     fun getCardForInitialDisplay(): Card {
@@ -28,5 +28,6 @@ class Dealer(
 
     companion object {
         private const val DEALER_CARD_COUNT = 2
+        private const val DEALER_DRAW_ONE_MORE_CARD_THRESHOLD = 16
     }
 }
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 065f44fb4..47c45d362 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -17,6 +17,6 @@ class Player(
     }
 
     override fun isAddCardEnabled(): Boolean {
-        return cardsSum <= 21
+        return cardsSum <= Card.MAX_SUM
     }
 }
diff --git a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
index 90b08aae2..7b5056357 100644
--- a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
+++ b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
@@ -6,8 +6,8 @@ class PlayerResultCalculator {
         playerScore: Int,
     ): PlayerResult {
         return when {
-            dealerScore > 21 -> PlayerResult.WIN
-            playerScore > 21 -> PlayerResult.LOSE
+            dealerScore > Card.MAX_SUM -> PlayerResult.WIN
+            playerScore > Card.MAX_SUM -> PlayerResult.LOSE
             playerScore > dealerScore -> PlayerResult.WIN
             else -> PlayerResult.LOSE
         }

From daa723b47416ed2d08599a5bf36fdd1e1fc3f51f Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 14:55:18 +0900
Subject: [PATCH 03/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep3]=20PlayerResult=20->=20GameResult=20=EB=A1=9C=20=EB=B3=80?=
 =?UTF-8?q?=EC=88=98=EB=AA=85=20=EB=B3=80=EA=B2=BD,=20GameResult=20?=
 =?UTF-8?q?=EC=97=90=20=EB=8C=80=ED=95=9C=20=EC=B9=B4=EC=9A=B4=ED=8A=B8?=
 =?UTF-8?q?=EB=A5=BC=20PlayerToResultMap=EC=97=90=20=EB=A9=94=EC=8B=9C?=
 =?UTF-8?q?=EC=A7=80=EB=A1=9C=20=EC=9A=94=EC=B2=AD=ED=95=98=EB=8F=84?=
 =?UTF-8?q?=EB=A1=9D=20=ED=95=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../domain/BlackJackResultManager.kt          | 25 +++++++++++++------
 .../domain/PlayerResultCalculator.kt          | 10 ++++----
 src/main/kotlin/blackjack/view/ResultView.kt  |  4 +--
 ...torTest.kt => GameResultCalculatorTest.kt} | 10 ++++----
 4 files changed, 29 insertions(+), 20 deletions(-)
 rename src/test/kotlin/blackjack/domain/{PlayerResultCalculatorTest.kt => GameResultCalculatorTest.kt} (80%)

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index d9485b7e3..d7eff8fbb 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -12,22 +12,31 @@ class BlackJackResultManager(
                 playerResultCalculator.calculate(dealerScore, player.cardsSum)
             }
 
-        val dealerWinCount = playersWinLose.count { it.value == PlayerResult.LOSE }
-        val dealerLoseCount = playersWinLose.count { it.value == PlayerResult.WIN }
-        return BlackJackResult(dealerWinCount, dealerLoseCount, PlayerToResultMap(playersWinLose))
+        return BlackJackResult(PlayerToResultMap(playersWinLose))
     }
 }
 
 data class BlackJackResult(
-    val dealerWinCount: Int,
-    val dealerLoseCount: Int,
     val playerToResultMap: PlayerToResultMap,
-)
+) {
+    val dealerWinCount: Int
+        get() = playerToResultMap.getPlayerLoseCounts()
+    val dealerLoseCount: Int
+        get() = playerToResultMap.getPlayerWinningCounts()
+}
 
 @JvmInline
-value class PlayerToResultMap(val value: Map<Player, PlayerResult>)
+value class PlayerToResultMap(val value: Map<Player, GameResult>) {
+    fun getPlayerWinningCounts(): Int {
+        return value.count { it.value == GameResult.WIN }
+    }
+
+    fun getPlayerLoseCounts(): Int {
+        return value.count { it.value == GameResult.LOSE }
+    }
+}
 
-enum class PlayerResult {
+enum class GameResult {
     WIN,
     LOSE,
 }
diff --git a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
index 7b5056357..05440b968 100644
--- a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
+++ b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
@@ -4,12 +4,12 @@ class PlayerResultCalculator {
     fun calculate(
         dealerScore: Int,
         playerScore: Int,
-    ): PlayerResult {
+    ): GameResult {
         return when {
-            dealerScore > Card.MAX_SUM -> PlayerResult.WIN
-            playerScore > Card.MAX_SUM -> PlayerResult.LOSE
-            playerScore > dealerScore -> PlayerResult.WIN
-            else -> PlayerResult.LOSE
+            dealerScore > Card.MAX_SUM -> GameResult.WIN
+            playerScore > Card.MAX_SUM -> GameResult.LOSE
+            playerScore > dealerScore -> GameResult.WIN
+            else -> GameResult.LOSE
         }
     }
 }
diff --git a/src/main/kotlin/blackjack/view/ResultView.kt b/src/main/kotlin/blackjack/view/ResultView.kt
index 2036071d7..b54494c5a 100644
--- a/src/main/kotlin/blackjack/view/ResultView.kt
+++ b/src/main/kotlin/blackjack/view/ResultView.kt
@@ -4,7 +4,7 @@ import blackjack.domain.BlackJackResult
 import blackjack.domain.Card
 import blackjack.domain.Dealer
 import blackjack.domain.Player
-import blackjack.domain.PlayerResult
+import blackjack.domain.GameResult
 
 object ResultView {
     fun printPlayerInitMessage(names: List<String>) {
@@ -45,7 +45,7 @@ object ResultView {
         println("\n### 최종 승패")
         println("딜러 ${result.dealerWinCount}승 ${result.dealerLoseCount}패")
         result.playerToResultMap.value.forEach { (player, result) ->
-            val winOrLose = if (result == PlayerResult.WIN) "승" else "패"
+            val winOrLose = if (result == GameResult.WIN) "승" else "패"
             println("${player.name} : $winOrLose")
         }
     }
diff --git a/src/test/kotlin/blackjack/domain/PlayerResultCalculatorTest.kt b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
similarity index 80%
rename from src/test/kotlin/blackjack/domain/PlayerResultCalculatorTest.kt
rename to src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
index 096787863..4b01de9b3 100644
--- a/src/test/kotlin/blackjack/domain/PlayerResultCalculatorTest.kt
+++ b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
@@ -3,30 +3,30 @@ package blackjack.domain
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
-class PlayerResultCalculatorTest {
+class GameResultCalculatorTest {
     private val calculator = PlayerResultCalculator()
 
     @Test
     fun `{given} 딜러 = Bust 이면 {when & then} 플레이어 승리`() {
         val result = calculator.calculate(dealerScore = 22, playerScore = 20)
-        assertEquals(PlayerResult.WIN, result)
+        assertEquals(GameResult.WIN, result)
     }
 
     @Test
     fun `{given} 플레이어 = Bust 이면 {when & then} 딜러 승리`() {
         val result = calculator.calculate(dealerScore = 20, playerScore = 22)
-        assertEquals(PlayerResult.LOSE, result)
+        assertEquals(GameResult.LOSE, result)
     }
 
     @Test
     fun `{given} 딜러, 플레이어 둘 다 Bust 아닐때 {when} 플레이어 점수 높으면 {then} 플레이어가 승리`() {
         val result = calculator.calculate(dealerScore = 18, playerScore = 19)
-        assertEquals(PlayerResult.WIN, result)
+        assertEquals(GameResult.WIN, result)
     }
 
     @Test
     fun `{given}딜러, 플레이어 둘 다 Bust 아닐때 {when} 딜러 점수 높으면 {then} 딜러가 승리`() {
         val result = calculator.calculate(dealerScore = 19, playerScore = 18)
-        assertEquals(PlayerResult.LOSE, result)
+        assertEquals(GameResult.LOSE, result)
     }
 }

From 4fd69616c4b6ba7793392cf75c265d369a383c04 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 15:10:54 +0900
Subject: [PATCH 04/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep3]=20PlayerResultCalculator=20class=20->=20object=20class=20?=
 =?UTF-8?q?=EB=A1=9C=20=EB=B3=80=EA=B2=BD,=20BlackJackResultManager=20?=
 =?UTF-8?q?=EC=9D=98=20=EC=83=9D=EC=84=B1=EC=9E=90=EB=A1=9C=20=EC=A3=BC?=
 =?UTF-8?q?=EC=9E=85=ED=95=98=EC=A7=80=20=EC=95=8A=EB=8F=84=EB=A1=9D=20?=
 =?UTF-8?q?=EC=88=98=EC=A0=95.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/controller/BlackJackController.kt | 5 +----
 src/main/kotlin/blackjack/domain/BlackJackResultManager.kt  | 3 +--
 src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt  | 2 +-
 3 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/main/kotlin/blackjack/controller/BlackJackController.kt b/src/main/kotlin/blackjack/controller/BlackJackController.kt
index ddd49102c..a516b0479 100644
--- a/src/main/kotlin/blackjack/controller/BlackJackController.kt
+++ b/src/main/kotlin/blackjack/controller/BlackJackController.kt
@@ -1,9 +1,6 @@
 package blackjack.controller
 
-import blackjack.domain.BlackJackResultManager
-import blackjack.domain.CardDeck
-import blackjack.domain.Dealer
-import blackjack.domain.Players
+import blackjack.domain.*
 import blackjack.view.InputView
 import blackjack.view.ResultView
 
diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index d7eff8fbb..75fbe3e38 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -3,13 +3,12 @@ package blackjack.domain
 class BlackJackResultManager(
     private val dealer: Dealer,
     private val players: Players,
-    private val playerResultCalculator: PlayerResultCalculator = PlayerResultCalculator(),
 ) {
     fun getResult(): BlackJackResult {
         val dealerScore = dealer.cardsSum
         val playersWinLose =
             players.value.associateWith { player ->
-                playerResultCalculator.calculate(dealerScore, player.cardsSum)
+                PlayerResultCalculator.calculate(dealerScore, player.cardsSum)
             }
 
         return BlackJackResult(PlayerToResultMap(playersWinLose))
diff --git a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
index 05440b968..452538eba 100644
--- a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
+++ b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
@@ -1,6 +1,6 @@
 package blackjack.domain
 
-class PlayerResultCalculator {
+object PlayerResultCalculator {
     fun calculate(
         dealerScore: Int,
         playerScore: Int,

From 126be39a43a30be344d6759fbf6a6e1991079bb4 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 15:21:59 +0900
Subject: [PATCH 05/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep3]=20=ED=94=84=EB=A1=9C=EA=B7=B8=EB=9E=98=EB=B0=8D=20?=
 =?UTF-8?q?=EC=A0=9C=EC=95=BD=20=EC=A1=B0=EA=B1=B4=EC=9D=84=20=EB=A7=8C?=
 =?UTF-8?q?=EC=A1=B1=ED=95=98=EA=B8=B0=20=EC=9C=84=ED=95=B4=20while=20?=
 =?UTF-8?q?=EB=AC=B8=EC=9D=98=20if=20=EC=A0=9C=EA=B1=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Player.kt | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 47c45d362..8a47efc07 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -9,13 +9,18 @@ class Player(
         onDrawCard: () -> Unit,
         onExitPlay: () -> Unit,
     ) {
-        while (isDrawCard(name)) {
+        var shouldContinue = shouldContinueDrawing(isDrawCard)
+        while (shouldContinue) {
             val isCardAdded = addCardIfAvailable(requireCard = drawCard, onDrawCard = onDrawCard)
-            if (isCardAdded.not()) break
+            shouldContinue = isCardAdded && shouldContinueDrawing(isDrawCard)
         }
         onExitPlay()
     }
 
+    private fun shouldContinueDrawing(isDrawCard: (String) -> Boolean): Boolean {
+        return isDrawCard(name)
+    }
+
     override fun isAddCardEnabled(): Boolean {
         return cardsSum <= Card.MAX_SUM
     }

From ce186a3c422f7e95b16d5340d2937ea5af1169d3 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 15:25:06 +0900
Subject: [PATCH 06/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep3]=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=98=A4=EB=A5=98=20?=
 =?UTF-8?q?=EC=88=98=EC=A0=95,=20Player=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?=
 =?UTF-8?q?=EB=B2=84=EA=B7=B8=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Player.kt                   | 2 +-
 src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt | 2 +-
 src/test/kotlin/blackjack/domain/PlayerTest.kt               | 5 ++---
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 8a47efc07..9fc12faea 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -22,6 +22,6 @@ class Player(
     }
 
     override fun isAddCardEnabled(): Boolean {
-        return cardsSum <= Card.MAX_SUM
+        return cardsSum < Card.MAX_SUM
     }
 }
diff --git a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
index 4b01de9b3..70ce396f4 100644
--- a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
+++ b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
@@ -4,7 +4,7 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
 class GameResultCalculatorTest {
-    private val calculator = PlayerResultCalculator()
+    private val calculator = PlayerResultCalculator
 
     @Test
     fun `{given} 딜러 = Bust 이면 {when & then} 플레이어 승리`() {
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index 0fbefc81f..ebb19df6f 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -6,15 +6,14 @@ import org.junit.jupiter.api.Test
 class PlayerTest {
     @Test
     fun `Player 가 계속해서 Rank SEVEN 만 뽑으면, 최대 3번 뽑을 수 있고 카드 합은 21이다`() {
-        val fakeDeck = Deck { Card(Rank.SEVEN, Suit.HEARTS) } // King 만 리턴한다
+        val fakeDeck = Deck { Card(Rank.SEVEN, Suit.HEARTS) }
         val player = Player("sara", drawCard = { fakeDeck.draw() })
         player.play(
-            // 계속해서 King 만 뽑을때
             isDrawCard = { true },
             onDrawCard = {},
             onExitPlay = {},
         )
-        assertThat(player.cards.value.size).isEqualTo(3) // 최대 3개를 뽑을 수 있다
+        assertThat(player.cards.value.size).isEqualTo(3)
         assertThat(player.cardsSum).isEqualTo(21)
     }
 

From 8b26a9265e9ef7ab4930bdeddc9e47ac47b5f96d Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 15:36:18 +0900
Subject: [PATCH 07/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep3]=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20?=
 =?UTF-8?q?=EC=88=98=EC=A0=95:=20DisplayName=20=EC=82=AC=EC=9A=A9=20?=
 =?UTF-8?q?=ED=95=B4=EB=B3=B4=EA=B8=B0,=20Parameterized=20=ED=85=8C?=
 =?UTF-8?q?=EC=8A=A4=ED=8A=B8=20=EC=A0=81=EC=9A=A9=20=EA=B0=80=EB=8A=A5?=
 =?UTF-8?q?=ED=95=9C=20=EA=B3=B3=EC=97=90=20=EC=A0=81=EC=9A=A9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../kotlin/blackjack/domain/CardDeckTest.kt   |  7 ++-
 src/test/kotlin/blackjack/domain/CardTest.kt  |  8 +++-
 .../kotlin/blackjack/domain/DealerTest.kt     | 10 ++--
 .../domain/GameResultCalculatorTest.kt        | 46 +++++++++----------
 .../kotlin/blackjack/domain/PlayerTest.kt     |  8 +++-
 5 files changed, 45 insertions(+), 34 deletions(-)

diff --git a/src/test/kotlin/blackjack/domain/CardDeckTest.kt b/src/test/kotlin/blackjack/domain/CardDeckTest.kt
index b8078c544..57108bbfc 100644
--- a/src/test/kotlin/blackjack/domain/CardDeckTest.kt
+++ b/src/test/kotlin/blackjack/domain/CardDeckTest.kt
@@ -3,11 +3,13 @@ package blackjack.domain
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNotNull
 import org.junit.jupiter.api.Assertions.assertThrows
+import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 
 class CardDeckTest {
     @Test
-    fun `{given} 초기 Deck 상태 {when} draw() {then} 카드 리스트 사이즈 1 감소`() {
+    @DisplayName("{given} 초기 Deck 상태 {when} draw() {then} 카드 리스트 사이즈 1 감소")
+    fun `should decrease card list size by 1 when draw() is called on an initial deck`() {
         // Given
         val deck = CardDeck()
         val initialSize = Rank.entries.size * Suit.entries.size
@@ -22,7 +24,8 @@ class CardDeckTest {
     }
 
     @Test
-    fun `{given} Empty Deck {when} draw() {then} IllegalStateException 발생`() {
+    @DisplayName("{given} Empty Deck {when} draw() {then} IllegalStateException 발생")
+    fun `should throw IllegalStateException when draw() is called on an empty deck`() {
         // Given
         val deck =
             CardDeck(
diff --git a/src/test/kotlin/blackjack/domain/CardTest.kt b/src/test/kotlin/blackjack/domain/CardTest.kt
index d25a38e3e..b16681331 100644
--- a/src/test/kotlin/blackjack/domain/CardTest.kt
+++ b/src/test/kotlin/blackjack/domain/CardTest.kt
@@ -1,14 +1,17 @@
 package blackjack.domain
 
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 
 class CardTest {
+
     @ParameterizedTest
+    @DisplayName("카드의 합이 21을 넘는지 여부를 확인")
     @MethodSource("provideDataForIsOverMaxSumTest")
-    fun `카드의 합이 21을 넘는지 여부를 확인`(
+    fun `should check if the sum of cards exceeds 21`(
         card: Card,
         currentSum: Int,
         expectedResult: Boolean,
@@ -21,8 +24,9 @@ class CardTest {
     }
 
     @ParameterizedTest
+    @DisplayName("임의의 카드 리스트가 주어졌을 때 카드의 합이 룰과 일치하는지 확인")
     @MethodSource("provideDataForSumValuesTest")
-    fun `임의의 카드 리스트가 주어졌을 때 카드의 합이 룰과 일치하는지 확인`(
+    fun `should verify if the sum of a given card list matches the rule`(
         cards: Cards,
         expectedSum: Int,
     ) {
diff --git a/src/test/kotlin/blackjack/domain/DealerTest.kt b/src/test/kotlin/blackjack/domain/DealerTest.kt
index f50733681..36fc67f59 100644
--- a/src/test/kotlin/blackjack/domain/DealerTest.kt
+++ b/src/test/kotlin/blackjack/domain/DealerTest.kt
@@ -1,11 +1,13 @@
 package blackjack.domain
 
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 
 class DealerTest {
     @Test
-    fun `{given} 플레이어들의 이름 {when} initPlayers {then} 각 플에이어들을 초기화 한다`() {
+    @DisplayName("플레이어들의 이름으로 Player 들을 초기화")
+    fun `should initialize players with given names`() {
         // given
         val playerNames = listOf("Sara", "John", "Levi")
         val dealer = Dealer(drawCard = { Card(Rank.TWO, Suit.HEARTS) })
@@ -24,7 +26,8 @@ class DealerTest {
     }
 
     @Test
-    fun `{given} 딜러의 카드 합이 16 이하일 때 {when & then} 카드를 한개 더 뽑아 총 3장 됨`() {
+    @DisplayName("딜러의 카드 합이 16 이하일 때 한 장 더 뽑기")
+    fun `should draw one more card when dealer's card sum is 16 or less`() {
         // given
         val dealer = Dealer(drawCard = { Card(Rank.TWO, Suit.HEARTS) })
         assertThat(dealer.isAddCardEnabled()).isTrue()
@@ -37,7 +40,8 @@ class DealerTest {
     }
 
     @Test
-    fun `{given} 딜러 생성 {when} getCardForInitialDisplay() {then} 갖고 있는 첫번째 카드를 반환`() {
+    @DisplayName("딜러가 가진 카드 중 하나만 꺼내기")
+    fun `should return the first card when dealer retrieves one card for initial display`() {
         // given
         val firstCard = Card(Rank.TWO, Suit.HEARTS)
         val secondCard = Card(Rank.TWO, Suit.HEARTS)
diff --git a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
index 70ce396f4..eeecb6475 100644
--- a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
+++ b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
@@ -1,32 +1,28 @@
 package blackjack.domain
 
 import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
 
 class GameResultCalculatorTest {
-    private val calculator = PlayerResultCalculator
-
-    @Test
-    fun `{given} 딜러 = Bust 이면 {when & then} 플레이어 승리`() {
-        val result = calculator.calculate(dealerScore = 22, playerScore = 20)
-        assertEquals(GameResult.WIN, result)
-    }
-
-    @Test
-    fun `{given} 플레이어 = Bust 이면 {when & then} 딜러 승리`() {
-        val result = calculator.calculate(dealerScore = 20, playerScore = 22)
-        assertEquals(GameResult.LOSE, result)
-    }
-
-    @Test
-    fun `{given} 딜러, 플레이어 둘 다 Bust 아닐때 {when} 플레이어 점수 높으면 {then} 플레이어가 승리`() {
-        val result = calculator.calculate(dealerScore = 18, playerScore = 19)
-        assertEquals(GameResult.WIN, result)
-    }
-
-    @Test
-    fun `{given}딜러, 플레이어 둘 다 Bust 아닐때 {when} 딜러 점수 높으면 {then} 딜러가 승리`() {
-        val result = calculator.calculate(dealerScore = 19, playerScore = 18)
-        assertEquals(GameResult.LOSE, result)
+    @DisplayName("딜러의 점수와 플레이어의 점수가 주어졌을 때 알맞은 게임 결과를 계산한다")
+    @ParameterizedTest(name = "{index} => dealerScore={0}, playerScore={1}, expectedResult={2}")
+    @CsvSource(
+        "22, 20, WIN",  // Dealer == Bust, Player 승리
+        "20, 22, LOSE", // Player == Bust, Dealer 승리
+        "18, 19, WIN",  // 둘다 Bust 아닐때 Player 점수가 높으면, Player 승리
+        "19, 18, LOSE"  // 둘다 Bust 아닐때 Dealer 점수가 높으면, Dealer 승리
+    )
+    fun `should calculate game result correctly based on dealer and player scores`(
+        dealerScore: Int,
+        playerScore: Int,
+        expectedResult: GameResult
+    ) {
+        val result = PlayerResultCalculator.calculate(
+            dealerScore = dealerScore,
+            playerScore = playerScore
+        )
+        assertEquals(expectedResult, result)
     }
 }
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index ebb19df6f..7df6a8239 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -1,11 +1,14 @@
 package blackjack.domain
 
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 
+
 class PlayerTest {
     @Test
-    fun `Player 가 계속해서 Rank SEVEN 만 뽑으면, 최대 3번 뽑을 수 있고 카드 합은 21이다`() {
+    @DisplayName("Player 가 계속해서 Rank SEVEN 만 뽑으면, 최대 3번 뽑을 수 있고 카드 합은 21이다")
+    fun `player can draw up to 3 cards if all are Rank SEVEN, with a total sum of 21`() {
         val fakeDeck = Deck { Card(Rank.SEVEN, Suit.HEARTS) }
         val player = Player("sara", drawCard = { fakeDeck.draw() })
         player.play(
@@ -18,7 +21,8 @@ class PlayerTest {
     }
 
     @Test
-    fun `Player 가 카드를 뽑지 않는다면 기본으로 주어진 카드만 갖는다`() {
+    @DisplayName("Player 가 카드를 뽑지 않는다면 기본으로 주어진 카드만 갖는다")
+    fun `player keeps the default cards if no additional cards are drawn`() {
         val fakeDeck = Deck { Card(Rank.TWO, Suit.HEARTS) } // 기본으로 주어질 카드
         val player = Player("sara", drawCard = { fakeDeck.draw() })
         player.play(

From ec35146c85eed39b57a6059a6a8dd3caf0d48cfe Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 15:37:38 +0900
Subject: [PATCH 08/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep3]=20ktlintformat?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../controller/BlackJackController.kt         |  5 +++-
 src/main/kotlin/blackjack/view/ResultView.kt  |  2 +-
 src/test/kotlin/blackjack/domain/CardTest.kt  |  1 -
 .../domain/GameResultCalculatorTest.kt        | 23 +++++++++++--------
 .../kotlin/blackjack/domain/PlayerTest.kt     |  1 -
 5 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/src/main/kotlin/blackjack/controller/BlackJackController.kt b/src/main/kotlin/blackjack/controller/BlackJackController.kt
index a516b0479..ddd49102c 100644
--- a/src/main/kotlin/blackjack/controller/BlackJackController.kt
+++ b/src/main/kotlin/blackjack/controller/BlackJackController.kt
@@ -1,6 +1,9 @@
 package blackjack.controller
 
-import blackjack.domain.*
+import blackjack.domain.BlackJackResultManager
+import blackjack.domain.CardDeck
+import blackjack.domain.Dealer
+import blackjack.domain.Players
 import blackjack.view.InputView
 import blackjack.view.ResultView
 
diff --git a/src/main/kotlin/blackjack/view/ResultView.kt b/src/main/kotlin/blackjack/view/ResultView.kt
index b54494c5a..329bfb894 100644
--- a/src/main/kotlin/blackjack/view/ResultView.kt
+++ b/src/main/kotlin/blackjack/view/ResultView.kt
@@ -3,8 +3,8 @@ package blackjack.view
 import blackjack.domain.BlackJackResult
 import blackjack.domain.Card
 import blackjack.domain.Dealer
-import blackjack.domain.Player
 import blackjack.domain.GameResult
+import blackjack.domain.Player
 
 object ResultView {
     fun printPlayerInitMessage(names: List<String>) {
diff --git a/src/test/kotlin/blackjack/domain/CardTest.kt b/src/test/kotlin/blackjack/domain/CardTest.kt
index b16681331..60616e8f0 100644
--- a/src/test/kotlin/blackjack/domain/CardTest.kt
+++ b/src/test/kotlin/blackjack/domain/CardTest.kt
@@ -7,7 +7,6 @@ import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 
 class CardTest {
-
     @ParameterizedTest
     @DisplayName("카드의 합이 21을 넘는지 여부를 확인")
     @MethodSource("provideDataForIsOverMaxSumTest")
diff --git a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
index eeecb6475..665d0333a 100644
--- a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
+++ b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
@@ -9,20 +9,25 @@ class GameResultCalculatorTest {
     @DisplayName("딜러의 점수와 플레이어의 점수가 주어졌을 때 알맞은 게임 결과를 계산한다")
     @ParameterizedTest(name = "{index} => dealerScore={0}, playerScore={1}, expectedResult={2}")
     @CsvSource(
-        "22, 20, WIN",  // Dealer == Bust, Player 승리
-        "20, 22, LOSE", // Player == Bust, Dealer 승리
-        "18, 19, WIN",  // 둘다 Bust 아닐때 Player 점수가 높으면, Player 승리
-        "19, 18, LOSE"  // 둘다 Bust 아닐때 Dealer 점수가 높으면, Dealer 승리
+        // Dealer == Bust, Player 승리
+        "22, 20, WIN",
+        // Player == Bust, Dealer 승리
+        "20, 22, LOSE",
+        // 둘다 Bust 아닐때 Player 점수가 높으면, Player 승리
+        "18, 19, WIN",
+        // 둘다 Bust 아닐때 Dealer 점수가 높으면, Dealer 승리
+        "19, 18, LOSE",
     )
     fun `should calculate game result correctly based on dealer and player scores`(
         dealerScore: Int,
         playerScore: Int,
-        expectedResult: GameResult
+        expectedResult: GameResult,
     ) {
-        val result = PlayerResultCalculator.calculate(
-            dealerScore = dealerScore,
-            playerScore = playerScore
-        )
+        val result =
+            PlayerResultCalculator.calculate(
+                dealerScore = dealerScore,
+                playerScore = playerScore,
+            )
         assertEquals(expectedResult, result)
     }
 }
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index 7df6a8239..001998b0b 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -4,7 +4,6 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 
-
 class PlayerTest {
     @Test
     @DisplayName("Player 가 계속해서 Rank SEVEN 만 뽑으면, 최대 3번 뽑을 수 있고 카드 합은 21이다")

From 38c0b9d34528c3645a39c8ffe2b8f087f1e12984 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 16:54:31 +0900
Subject: [PATCH 09/32] =?UTF-8?q?[step4]=20=ED=94=8C=EB=A0=88=EC=9D=B4?=
 =?UTF-8?q?=EC=96=B4=EB=8A=94=20=EA=B2=8C=EC=9E=84=EC=9D=84=20=EC=8B=9C?=
 =?UTF-8?q?=EC=9E=91=ED=95=A0=20=EB=95=8C=20=EB=B2=A0=ED=8C=85=20=EA=B8=88?=
 =?UTF-8?q?=EC=95=A1=EC=9D=84=20=EC=9E=85=EB=A0=A5=EB=B0=9B=EB=8A=94?=
 =?UTF-8?q?=EB=8B=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../blackjack/controller/BlackJackController.kt     |  1 +
 src/main/kotlin/blackjack/domain/Dealer.kt          | 13 ++++++++++++-
 src/main/kotlin/blackjack/domain/Player.kt          |  3 +++
 src/main/kotlin/blackjack/domain/Players.kt         |  4 ++--
 src/main/kotlin/blackjack/view/InputView.kt         |  9 +++++++++
 5 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/src/main/kotlin/blackjack/controller/BlackJackController.kt b/src/main/kotlin/blackjack/controller/BlackJackController.kt
index ddd49102c..b32c1c169 100644
--- a/src/main/kotlin/blackjack/controller/BlackJackController.kt
+++ b/src/main/kotlin/blackjack/controller/BlackJackController.kt
@@ -22,6 +22,7 @@ object BlackJackController {
         val players =
             dealer.initPlayers(
                 fetchPlayerNames = { InputView.readPlayerNames() },
+                getBettingAmount = { name -> InputView.readBettingAmount(name) },
                 onPlayerInit = { names ->
                     ResultView.printPlayerInitMessage(names)
                     ResultView.printDealerWithCard(dealer.getCardForInitialDisplay())
diff --git a/src/main/kotlin/blackjack/domain/Dealer.kt b/src/main/kotlin/blackjack/domain/Dealer.kt
index 0d036e225..172118e98 100644
--- a/src/main/kotlin/blackjack/domain/Dealer.kt
+++ b/src/main/kotlin/blackjack/domain/Dealer.kt
@@ -1,14 +1,25 @@
 package blackjack.domain
 
+import java.math.BigDecimal
+
 class Dealer(
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
     fun initPlayers(
         fetchPlayerNames: () -> List<String>,
+        getBettingAmount: (String) -> BigDecimal,
         onPlayerInit: (List<String>) -> Unit,
     ): Players {
         val names = fetchPlayerNames()
-        val players = names.map { name -> Player(name = name, drawCard = drawCard) }
+        val players = names.map { name ->
+            val betAmount = getBettingAmount(name)
+            val player = Player(
+                name = name,
+                betAmount = betAmount,
+                drawCard = drawCard,
+            )
+            player
+        }
         onPlayerInit(names)
         return Players(value = players)
     }
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 9fc12faea..0abc6790a 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -1,7 +1,10 @@
 package blackjack.domain
 
+import java.math.BigDecimal
+
 class Player(
     val name: String,
+    val betAmount: BigDecimal,
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
     fun play(
diff --git a/src/main/kotlin/blackjack/domain/Players.kt b/src/main/kotlin/blackjack/domain/Players.kt
index 0929e6fad..2181e772d 100644
--- a/src/main/kotlin/blackjack/domain/Players.kt
+++ b/src/main/kotlin/blackjack/domain/Players.kt
@@ -2,12 +2,12 @@ package blackjack.domain
 
 data class Players(val value: List<Player>) {
     fun onEachPreparePlay(action: (Player) -> Unit): Players {
-        value.forEach { action(it) }
+        onEach(action)
         return this
     }
 
     fun onEachStartPlay(action: (Player) -> Unit): Players {
-        value.forEach { action(it) }
+        onEach(action)
         return this
     }
 
diff --git a/src/main/kotlin/blackjack/view/InputView.kt b/src/main/kotlin/blackjack/view/InputView.kt
index 178ba2149..fedb2af3e 100644
--- a/src/main/kotlin/blackjack/view/InputView.kt
+++ b/src/main/kotlin/blackjack/view/InputView.kt
@@ -1,5 +1,7 @@
 package blackjack.view
 
+import java.math.BigDecimal
+
 object InputView {
     fun readPlayerNames(): List<String> {
         println("\n* 게임에 참여할 사람의 이름을 임력하세요 (쉼표 기준으로 분리)")
@@ -10,6 +12,13 @@ object InputView {
         return names
     }
 
+    fun readBettingAmount(name: String): BigDecimal {
+        println("\n* $name 의 베팅 금액은?")
+        val amount =
+            readlnOrNull()?.trim()?.toBigDecimalOrNull() ?: throw IllegalStateException("Invalid Betting amount")
+        return amount
+    }
+
     fun readIsDrawMore(name: String): Boolean {
         println("\n* $name 는 한 장의 카드를 더 받겠습니까? (예는 y, 아니오는 n)")
         val yesOrNo = readlnOrNull()?.trim() ?: "n"

From 995344bcd91edb46e97e3b49494078baf6bfda53 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 18:53:40 +0900
Subject: [PATCH 10/32] =?UTF-8?q?[step4]=20=EB=B2=A0=ED=8C=85=20=EA=B4=80?=
 =?UTF-8?q?=EB=A0=A8=20=EA=B7=9C=EC=B9=99=EC=9D=84=20=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                                     | 19 +++++++++-
 .../controller/BlackJackController.kt         |  5 ++-
 src/main/kotlin/blackjack/domain/BetMoney.kt  | 22 ++++++++++++
 .../domain/BlackJackResultManager.kt          | 35 +++++++++++++++++++
 src/main/kotlin/blackjack/domain/Card.kt      |  8 -----
 src/main/kotlin/blackjack/domain/Cards.kt     |  4 +++
 src/main/kotlin/blackjack/domain/Dealer.kt    | 33 ++++++++++++-----
 .../kotlin/blackjack/domain/Participant.kt    | 12 +++++--
 src/main/kotlin/blackjack/domain/Player.kt    | 31 ++++++++++++++--
 src/main/kotlin/blackjack/domain/Players.kt   |  6 ++++
 .../kotlin/blackjack/domain/ProfitMoney.kt    | 15 ++++++++
 src/main/kotlin/blackjack/view/ResultView.kt  | 14 ++++----
 src/test/kotlin/blackjack/domain/CardTest.kt  | 15 --------
 13 files changed, 169 insertions(+), 50 deletions(-)
 create mode 100644 src/main/kotlin/blackjack/domain/BetMoney.kt
 create mode 100644 src/main/kotlin/blackjack/domain/ProfitMoney.kt

diff --git a/README.md b/README.md
index a07979f34..1eabc1ef6 100644
--- a/README.md
+++ b/README.md
@@ -19,4 +19,21 @@
 - 기능 요구사항 바탕으로 테스트코드 작성
 - 테스트코드 컴파일 되도록 코드 수정
 - 게임의 주체를 나타내는 Player 객체 정의 
-- 블랙잭 카드를 표현할 수 있는 객체 정의
\ No newline at end of file
+- 블랙잭 카드를 표현할 수 있는 객체 정의
+
+
+- 3단계 목록이 날라갔네 .. 
+
+### 4단계 구현 기능 목록 
+
+- [x] 플레이어는 게임을 시작할 때 베팅 금액을 정해야 한다. 
+- 베팅 관련 규칙 추가 
+  - [x] 카드를 추가로 뽑아 21을 초과할 경우 베팅 금액을 모두 잃게 된다.
+  - [x] 처음 두 장의 카드 합이 21일 경우 블랙잭이 되면 베팅 금액의 1.5 배를 딜러에게 받는다. 
+  - [x] 딜러와 플레이어가 모두 동시에 블랙잭인 경우 플레이어는 베팅한 금액을 돌려받는다.
+  - [x] 딜러가 21을 초과하면 그 시점까지 남아 있던 플레이어들은 가지고 있는 패에 상관 없이 승리해 베팅 금액을 받는다.
+
+### 4단계 프로그래밍 요구사항
+- 모든 엔티티를 작게 유지한다.
+- 3개 이상의 인스턴스 변수를 가진 클래스를 쓰지 않는다.
+- 딜러와 플레이어에서 발생하는 중복 코드를 제거해야 한다.
diff --git a/src/main/kotlin/blackjack/controller/BlackJackController.kt b/src/main/kotlin/blackjack/controller/BlackJackController.kt
index b32c1c169..350b499f5 100644
--- a/src/main/kotlin/blackjack/controller/BlackJackController.kt
+++ b/src/main/kotlin/blackjack/controller/BlackJackController.kt
@@ -60,8 +60,7 @@ object BlackJackController {
         players.onEach { player ->
             ResultView.printFinalScoresForPlayer(player)
         }
-
-        val result = BlackJackResultManager(dealer, players).getResult()
-        ResultView.printFinalWinLose(result)
+        val result = BlackJackResultManager(dealer, players).getResultV2()
+        ResultView.printFinalProfit(result)
     }
 }
diff --git a/src/main/kotlin/blackjack/domain/BetMoney.kt b/src/main/kotlin/blackjack/domain/BetMoney.kt
new file mode 100644
index 000000000..dc61e5c16
--- /dev/null
+++ b/src/main/kotlin/blackjack/domain/BetMoney.kt
@@ -0,0 +1,22 @@
+package blackjack.domain
+
+import java.math.BigDecimal
+
+@JvmInline
+value class BetMoney(private val amount: BigDecimal) {
+    fun getOriginalBetAmount(): BigDecimal {
+        return amount
+    }
+
+    fun getAmountOnBlackJack(): BigDecimal {
+        return amount.multiply((1.5).toBigDecimal())
+    }
+
+    fun getAmountOnBust(): BigDecimal {
+        return -(amount)
+    }
+
+    fun getAmountOnLose(): BigDecimal {
+        return -(amount)
+    }
+}
diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 75fbe3e38..a5b7ef587 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -4,6 +4,7 @@ class BlackJackResultManager(
     private val dealer: Dealer,
     private val players: Players,
 ) {
+    @Deprecated("getResultV2 를 사용하세요")
     fun getResult(): BlackJackResult {
         val dealerScore = dealer.cardsSum
         val playersWinLose =
@@ -13,8 +14,40 @@ class BlackJackResultManager(
 
         return BlackJackResult(PlayerToResultMap(playersWinLose))
     }
+
+    fun getResultV2(): BlackJackResultV2 {
+        val playersToProfits =
+            players.value.associateWith { player ->
+                val result = PlayerResultCalculator.calculate(dealer.cardsSum, player.cardsSum)
+                when {
+                    player.isBlackJackInitially && dealer.isBlackJackInitially.not() -> player.onBlackJackInitially()
+                    player.isBlackJackInitially && dealer.isBlackJackInitially -> player.onPush()
+                    result == GameResult.WIN -> player.onWin()
+                    result == GameResult.LOSE -> player.onLose()
+                    result == GameResult.PUSH -> player.onPush()
+                }
+
+                player.profitMoney
+            }
+
+        val totalBet = players.getTotalBetMoneyFromPlayers()
+        playersToProfits.forEach { (_, profitMoney) ->
+            dealer.adjustProfit(totalBet, profitMoney)
+        }
+        return BlackJackResultV2(dealer.profitMoney, PlayerToProfitMoney(playersToProfits))
+    }
 }
 
+data class BlackJackResultV2(
+    val dealerProfitMoney: ProfitMoney,
+    val playerToProfit: PlayerToProfitMoney,
+)
+
+data class PlayerToProfitMoney(
+    val value: Map<Player, ProfitMoney>,
+)
+
+@Deprecated("deprecated")
 data class BlackJackResult(
     val playerToResultMap: PlayerToResultMap,
 ) {
@@ -24,6 +57,7 @@ data class BlackJackResult(
         get() = playerToResultMap.getPlayerWinningCounts()
 }
 
+@Deprecated("deprecated")
 @JvmInline
 value class PlayerToResultMap(val value: Map<Player, GameResult>) {
     fun getPlayerWinningCounts(): Int {
@@ -38,4 +72,5 @@ value class PlayerToResultMap(val value: Map<Player, GameResult>) {
 enum class GameResult {
     WIN,
     LOSE,
+    PUSH,
 }
diff --git a/src/main/kotlin/blackjack/domain/Card.kt b/src/main/kotlin/blackjack/domain/Card.kt
index 2fcdd9c83..fbcb6880c 100644
--- a/src/main/kotlin/blackjack/domain/Card.kt
+++ b/src/main/kotlin/blackjack/domain/Card.kt
@@ -3,14 +3,6 @@ package blackjack.domain
 data class Card(val rank: Rank, val suit: Suit) {
     private fun isAce() = rank == Rank.ACE
 
-    fun isOverMaxSum(currentCardSum: Int): Boolean {
-        return if (isAce()) {
-            currentCardSum + ACE_VALUE_ONE > MAX_SUM && currentCardSum + this.rank.value > MAX_SUM
-        } else {
-            currentCardSum + this.rank.value > MAX_SUM
-        }
-    }
-
     companion object {
         const val ACE_VALUE_ONE = 1
         const val MAX_SUM = 21
diff --git a/src/main/kotlin/blackjack/domain/Cards.kt b/src/main/kotlin/blackjack/domain/Cards.kt
index 5d37654ec..3c14ea481 100644
--- a/src/main/kotlin/blackjack/domain/Cards.kt
+++ b/src/main/kotlin/blackjack/domain/Cards.kt
@@ -9,6 +9,10 @@ data class Cards(val value: List<Card>) {
         return adjustForAces(nonAcesSum, aceCount)
     }
 
+    fun isBust(): Boolean {
+        return sumValues() > MAX_SUM
+    }
+
     private fun calculateNonAcesAndCountAces(): Pair<Int, Int> {
         var sum = 0
         var aceCount = 0
diff --git a/src/main/kotlin/blackjack/domain/Dealer.kt b/src/main/kotlin/blackjack/domain/Dealer.kt
index 172118e98..de1eaff00 100644
--- a/src/main/kotlin/blackjack/domain/Dealer.kt
+++ b/src/main/kotlin/blackjack/domain/Dealer.kt
@@ -11,15 +11,15 @@ class Dealer(
         onPlayerInit: (List<String>) -> Unit,
     ): Players {
         val names = fetchPlayerNames()
-        val players = names.map { name ->
-            val betAmount = getBettingAmount(name)
-            val player = Player(
-                name = name,
-                betAmount = betAmount,
-                drawCard = drawCard,
-            )
-            player
-        }
+        val nameAndBets = names.associateWith(getBettingAmount)
+        val players =
+            nameAndBets.map { (name, bet) ->
+                Player(
+                    name = name,
+                    betMoney = BetMoney(bet),
+                    drawCard = drawCard,
+                )
+            }
         onPlayerInit(names)
         return Players(value = players)
     }
@@ -37,6 +37,21 @@ class Dealer(
         return cards.value[0]
     }
 
+    fun adjustProfit(
+        totalBet: BigDecimal,
+        profitMoney: ProfitMoney,
+    ) {
+        setDealerProfitMoney(totalBet, profitMoney)
+    }
+
+    private fun setDealerProfitMoney(
+        totalBet: BigDecimal,
+        playerProfit: ProfitMoney,
+    ) {
+        val profit = totalBet - playerProfit.getCurrentProfit()
+        profitMoney.set(profit) // FIXME add 일듯 ?
+    }
+
     companion object {
         private const val DEALER_CARD_COUNT = 2
         private const val DEALER_DRAW_ONE_MORE_CARD_THRESHOLD = 16
diff --git a/src/main/kotlin/blackjack/domain/Participant.kt b/src/main/kotlin/blackjack/domain/Participant.kt
index 28ccc8c98..bb004f727 100644
--- a/src/main/kotlin/blackjack/domain/Participant.kt
+++ b/src/main/kotlin/blackjack/domain/Participant.kt
@@ -2,14 +2,16 @@ package blackjack.domain
 
 abstract class Participant(
     private val drawCard: () -> Card,
-    initialCardCount: Int = 2,
 ) {
     private val _cards = mutableListOf<Card>()
     val cards: Cards = Cards(_cards)
     val cardsSum: Int get() = cards.sumValues()
+    val profitMoney: ProfitMoney = ProfitMoney()
+    val isBlackJackInitially: Boolean
 
     init {
-        repeat(initialCardCount) { addCard(drawCard()) }
+        repeat(INITIAL_CARD_COUNT) { addCard(drawCard()) }
+        isBlackJackInitially = cardsSum == Card.MAX_SUM
     }
 
     private fun addCard(card: Card) {
@@ -28,5 +30,9 @@ abstract class Participant(
         return false
     }
 
-    abstract fun isAddCardEnabled(): Boolean
+    protected abstract fun isAddCardEnabled(): Boolean
+
+    companion object {
+        private const val INITIAL_CARD_COUNT = 2
+    }
 }
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 0abc6790a..45edf30b9 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -1,12 +1,12 @@
 package blackjack.domain
 
-import java.math.BigDecimal
-
 class Player(
     val name: String,
-    val betAmount: BigDecimal,
+    private val betMoney: BetMoney,
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
+    val originalBetAmount get() = betMoney.getOriginalBetAmount()
+
     fun play(
         isDrawCard: (String) -> Boolean,
         onDrawCard: () -> Unit,
@@ -15,11 +15,36 @@ class Player(
         var shouldContinue = shouldContinueDrawing(isDrawCard)
         while (shouldContinue) {
             val isCardAdded = addCardIfAvailable(requireCard = drawCard, onDrawCard = onDrawCard)
+            checkOverCardMaxSum()
             shouldContinue = isCardAdded && shouldContinueDrawing(isDrawCard)
+            println("수익 ${profitMoney.getCurrentProfit()}")
         }
         onExitPlay()
     }
 
+    fun onWin() {
+        profitMoney.set(betMoney.getOriginalBetAmount())
+    }
+
+    fun onBlackJackInitially() {
+        profitMoney.set(betMoney.getAmountOnBlackJack())
+    }
+
+    fun onLose() {
+        profitMoney.set(betMoney.getAmountOnLose())
+    }
+
+    fun onPush() {
+        profitMoney.set(betMoney.getOriginalBetAmount())
+    }
+
+    private fun checkOverCardMaxSum() {
+        if (cards.isBust()) {
+            val profit = betMoney.getAmountOnBust()
+            profitMoney.set(profit)
+        }
+    }
+
     private fun shouldContinueDrawing(isDrawCard: (String) -> Boolean): Boolean {
         return isDrawCard(name)
     }
diff --git a/src/main/kotlin/blackjack/domain/Players.kt b/src/main/kotlin/blackjack/domain/Players.kt
index 2181e772d..dd01cbda3 100644
--- a/src/main/kotlin/blackjack/domain/Players.kt
+++ b/src/main/kotlin/blackjack/domain/Players.kt
@@ -1,5 +1,7 @@
 package blackjack.domain
 
+import java.math.BigDecimal
+
 data class Players(val value: List<Player>) {
     fun onEachPreparePlay(action: (Player) -> Unit): Players {
         onEach(action)
@@ -15,4 +17,8 @@ data class Players(val value: List<Player>) {
         value.forEach { action(it) }
         return this
     }
+
+    fun getTotalBetMoneyFromPlayers(): BigDecimal {
+        return value.sumOf { it.originalBetAmount }
+    }
 }
diff --git a/src/main/kotlin/blackjack/domain/ProfitMoney.kt b/src/main/kotlin/blackjack/domain/ProfitMoney.kt
new file mode 100644
index 000000000..7078da6c6
--- /dev/null
+++ b/src/main/kotlin/blackjack/domain/ProfitMoney.kt
@@ -0,0 +1,15 @@
+package blackjack.domain
+
+import java.math.BigDecimal
+
+class ProfitMoney {
+    private var current: BigDecimal = BigDecimal.ZERO
+
+    fun getCurrentProfit(): BigDecimal {
+        return current
+    }
+
+    fun set(amount: BigDecimal) {
+        current = amount
+    }
+}
diff --git a/src/main/kotlin/blackjack/view/ResultView.kt b/src/main/kotlin/blackjack/view/ResultView.kt
index 329bfb894..465bf615d 100644
--- a/src/main/kotlin/blackjack/view/ResultView.kt
+++ b/src/main/kotlin/blackjack/view/ResultView.kt
@@ -1,9 +1,8 @@
 package blackjack.view
 
-import blackjack.domain.BlackJackResult
+import blackjack.domain.BlackJackResultV2
 import blackjack.domain.Card
 import blackjack.domain.Dealer
-import blackjack.domain.GameResult
 import blackjack.domain.Player
 
 object ResultView {
@@ -41,12 +40,11 @@ object ResultView {
         return "${player.name} 카드: ${player.cards.value.map { "${it.rank.rankName}${it.suit.koreanName}" }}"
     }
 
-    fun printFinalWinLose(result: BlackJackResult) {
-        println("\n### 최종 승패")
-        println("딜러 ${result.dealerWinCount}승 ${result.dealerLoseCount}패")
-        result.playerToResultMap.value.forEach { (player, result) ->
-            val winOrLose = if (result == GameResult.WIN) "승" else "패"
-            println("${player.name} : $winOrLose")
+    fun printFinalProfit(result: BlackJackResultV2) {
+        println("\n### 최종 수익")
+        println("딜러 : ${result.dealerProfitMoney.getCurrentProfit()}")
+        result.playerToProfit.value.forEach { (player, profit) ->
+            println("${player.name} : ${profit.getCurrentProfit()}")
         }
     }
 }
diff --git a/src/test/kotlin/blackjack/domain/CardTest.kt b/src/test/kotlin/blackjack/domain/CardTest.kt
index 60616e8f0..71d6ec62f 100644
--- a/src/test/kotlin/blackjack/domain/CardTest.kt
+++ b/src/test/kotlin/blackjack/domain/CardTest.kt
@@ -7,21 +7,6 @@ import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 
 class CardTest {
-    @ParameterizedTest
-    @DisplayName("카드의 합이 21을 넘는지 여부를 확인")
-    @MethodSource("provideDataForIsOverMaxSumTest")
-    fun `should check if the sum of cards exceeds 21`(
-        card: Card,
-        currentSum: Int,
-        expectedResult: Boolean,
-    ) {
-        // When
-        val result = card.isOverMaxSum(currentSum)
-
-        // Then
-        assertThat(result).isEqualTo(expectedResult)
-    }
-
     @ParameterizedTest
     @DisplayName("임의의 카드 리스트가 주어졌을 때 카드의 합이 룰과 일치하는지 확인")
     @MethodSource("provideDataForSumValuesTest")

From 3e26696009d96f04ad3b34b8b1071ba6b9ba93b6 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:00:53 +0900
Subject: [PATCH 11/32] =?UTF-8?q?[step4]=20Dealer=20=EC=9D=98=20=EB=B2=A0?=
 =?UTF-8?q?=ED=8C=85=20=EA=B8=88=EC=95=A1=20=EC=84=A4=EC=A0=95=20=EB=A1=9C?=
 =?UTF-8?q?=EC=A7=81=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../domain/BlackJackResultManager.kt          |  4 +---
 src/main/kotlin/blackjack/domain/Dealer.kt    | 22 ++++++++-----------
 2 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index a5b7ef587..6edf8c35f 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -29,10 +29,8 @@ class BlackJackResultManager(
 
                 player.profitMoney
             }
-
-        val totalBet = players.getTotalBetMoneyFromPlayers()
         playersToProfits.forEach { (_, profitMoney) ->
-            dealer.adjustProfit(totalBet, profitMoney)
+            dealer.adjustProfit(profitMoney)
         }
         return BlackJackResultV2(dealer.profitMoney, PlayerToProfitMoney(playersToProfits))
     }
diff --git a/src/main/kotlin/blackjack/domain/Dealer.kt b/src/main/kotlin/blackjack/domain/Dealer.kt
index de1eaff00..69d0f1f0a 100644
--- a/src/main/kotlin/blackjack/domain/Dealer.kt
+++ b/src/main/kotlin/blackjack/domain/Dealer.kt
@@ -12,7 +12,7 @@ class Dealer(
     ): Players {
         val names = fetchPlayerNames()
         val nameAndBets = names.associateWith(getBettingAmount)
-        val players =
+        val players = Players(
             nameAndBets.map { (name, bet) ->
                 Player(
                     name = name,
@@ -20,8 +20,10 @@ class Dealer(
                     drawCard = drawCard,
                 )
             }
+        )
         onPlayerInit(names)
-        return Players(value = players)
+        initProfitMoney(players.getTotalBetMoneyFromPlayers())
+        return players
     }
 
     fun drawOneMoreCardIfNeeded(onDrawCard: () -> Unit) {
@@ -37,19 +39,13 @@ class Dealer(
         return cards.value[0]
     }
 
-    fun adjustProfit(
-        totalBet: BigDecimal,
-        profitMoney: ProfitMoney,
-    ) {
-        setDealerProfitMoney(totalBet, profitMoney)
+    fun adjustProfit(playerProfit: ProfitMoney) {
+        val profit = profitMoney.getCurrentProfit() - playerProfit.getCurrentProfit()
+        profitMoney.set(profit)
     }
 
-    private fun setDealerProfitMoney(
-        totalBet: BigDecimal,
-        playerProfit: ProfitMoney,
-    ) {
-        val profit = totalBet - playerProfit.getCurrentProfit()
-        profitMoney.set(profit) // FIXME add 일듯 ?
+    private fun initProfitMoney(totalBet: BigDecimal) {
+        profitMoney.set(totalBet)
     }
 
     companion object {

From 9944f639ab47cbe9629adbd59ba1b2441e6f6729 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:01:23 +0900
Subject: [PATCH 12/32] =?UTF-8?q?[step4]=20=EB=A1=9C=EA=B7=B8=20=EC=82=AD?=
 =?UTF-8?q?=EC=A0=9C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Player.kt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 45edf30b9..5d31fdba4 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -17,7 +17,6 @@ class Player(
             val isCardAdded = addCardIfAvailable(requireCard = drawCard, onDrawCard = onDrawCard)
             checkOverCardMaxSum()
             shouldContinue = isCardAdded && shouldContinueDrawing(isDrawCard)
-            println("수익 ${profitMoney.getCurrentProfit()}")
         }
         onExitPlay()
     }

From 17e1d6b0bc61a27f9c41dfd8ae1edcbaf7cde2d8 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:14:55 +0900
Subject: [PATCH 13/32] =?UTF-8?q?[step4]=20=EA=B3=84=EC=82=B0=EB=A1=9C?=
 =?UTF-8?q?=EC=A7=81=20=EB=B2=84=EA=B7=B8=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../domain/BlackJackResultManager.kt          | 30 +++++++++++++++----
 .../kotlin/blackjack/domain/Participant.kt    |  2 +-
 src/main/kotlin/blackjack/domain/Player.kt    | 16 ++++------
 .../domain/PlayerResultCalculator.kt          |  6 ++--
 4 files changed, 36 insertions(+), 18 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 6edf8c35f..1eb54b04f 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -18,13 +18,14 @@ class BlackJackResultManager(
     fun getResultV2(): BlackJackResultV2 {
         val playersToProfits =
             players.value.associateWith { player ->
-                val result = PlayerResultCalculator.calculate(dealer.cardsSum, player.cardsSum)
+                val result = GameResult.fromScores(dealer.cardsSum, player.cardsSum)
                 when {
                     player.isBlackJackInitially && dealer.isBlackJackInitially.not() -> player.onBlackJackInitially()
                     player.isBlackJackInitially && dealer.isBlackJackInitially -> player.onPush()
-                    result == GameResult.WIN -> player.onWin()
-                    result == GameResult.LOSE -> player.onLose()
-                    result == GameResult.PUSH -> player.onPush()
+                    result.isWin() -> player.onWin()
+                    result.isBust() -> player.onBust()
+                    result.isLose() -> player.onLose()
+                    result.isPush() -> player.onPush()
                 }
 
                 player.profitMoney
@@ -69,6 +70,25 @@ value class PlayerToResultMap(val value: Map<Player, GameResult>) {
 
 enum class GameResult {
     WIN,
+    BUST,
     LOSE,
-    PUSH,
+    PUSH;
+
+    fun isWin() = this == WIN
+    fun isBust() = this == BUST
+    fun isLose() = this == LOSE
+    fun isPush() = this == PUSH
+
+
+    companion object {
+        fun fromScores(dealerScore: Int, playerScore: Int): GameResult {
+            return when {
+                dealerScore > Card.MAX_SUM -> WIN // Dealer bust
+                playerScore > Card.MAX_SUM -> BUST // Player bust
+                dealerScore > playerScore -> LOSE
+                playerScore > dealerScore -> WIN
+                else -> PUSH
+            }
+        }
+    }
 }
diff --git a/src/main/kotlin/blackjack/domain/Participant.kt b/src/main/kotlin/blackjack/domain/Participant.kt
index bb004f727..b23901a28 100644
--- a/src/main/kotlin/blackjack/domain/Participant.kt
+++ b/src/main/kotlin/blackjack/domain/Participant.kt
@@ -30,7 +30,7 @@ abstract class Participant(
         return false
     }
 
-    protected abstract fun isAddCardEnabled(): Boolean
+    abstract fun isAddCardEnabled(): Boolean
 
     companion object {
         private const val INITIAL_CARD_COUNT = 2
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 5d31fdba4..21c8ca344 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -15,18 +15,21 @@ class Player(
         var shouldContinue = shouldContinueDrawing(isDrawCard)
         while (shouldContinue) {
             val isCardAdded = addCardIfAvailable(requireCard = drawCard, onDrawCard = onDrawCard)
-            checkOverCardMaxSum()
             shouldContinue = isCardAdded && shouldContinueDrawing(isDrawCard)
         }
         onExitPlay()
     }
 
+    fun onBlackJackInitially() {
+        profitMoney.set(betMoney.getAmountOnBlackJack())
+    }
+
     fun onWin() {
         profitMoney.set(betMoney.getOriginalBetAmount())
     }
 
-    fun onBlackJackInitially() {
-        profitMoney.set(betMoney.getAmountOnBlackJack())
+    fun onBust() {
+        profitMoney.set(betMoney.getAmountOnBust())
     }
 
     fun onLose() {
@@ -37,13 +40,6 @@ class Player(
         profitMoney.set(betMoney.getOriginalBetAmount())
     }
 
-    private fun checkOverCardMaxSum() {
-        if (cards.isBust()) {
-            val profit = betMoney.getAmountOnBust()
-            profitMoney.set(profit)
-        }
-    }
-
     private fun shouldContinueDrawing(isDrawCard: (String) -> Boolean): Boolean {
         return isDrawCard(name)
     }
diff --git a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
index 452538eba..e1158ac6c 100644
--- a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
+++ b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
@@ -1,5 +1,6 @@
 package blackjack.domain
 
+@Deprecated("deprecated")
 object PlayerResultCalculator {
     fun calculate(
         dealerScore: Int,
@@ -7,9 +8,10 @@ object PlayerResultCalculator {
     ): GameResult {
         return when {
             dealerScore > Card.MAX_SUM -> GameResult.WIN
-            playerScore > Card.MAX_SUM -> GameResult.LOSE
+            playerScore > Card.MAX_SUM -> GameResult.BUST
+            dealerScore > playerScore -> GameResult.LOSE
             playerScore > dealerScore -> GameResult.WIN
-            else -> GameResult.LOSE
+            else -> GameResult.PUSH
         }
     }
 }

From bf2dcc2b9c01be04dd3227b70e35595bff486b2d Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:15:03 +0900
Subject: [PATCH 14/32] =?UTF-8?q?[step4]=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?=
 =?UTF-8?q?=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/test/kotlin/blackjack/domain/CardTest.kt   |  8 --------
 src/test/kotlin/blackjack/domain/DealerTest.kt |  2 ++
 src/test/kotlin/blackjack/domain/PlayerTest.kt | 13 +++++++++++--
 3 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/test/kotlin/blackjack/domain/CardTest.kt b/src/test/kotlin/blackjack/domain/CardTest.kt
index 71d6ec62f..47e6f2348 100644
--- a/src/test/kotlin/blackjack/domain/CardTest.kt
+++ b/src/test/kotlin/blackjack/domain/CardTest.kt
@@ -22,14 +22,6 @@ class CardTest {
     }
 
     companion object {
-        @JvmStatic
-        fun provideDataForIsOverMaxSumTest(): List<Arguments> {
-            return listOf(
-                Arguments.of(Card(Rank.ACE, Suit.HEARTS), 20, false),
-                Arguments.of(Card(Rank.ACE, Suit.HEARTS), 21, true),
-            )
-        }
-
         @JvmStatic
         fun provideDataForSumValuesTest(): List<Arguments> {
             return listOf(
diff --git a/src/test/kotlin/blackjack/domain/DealerTest.kt b/src/test/kotlin/blackjack/domain/DealerTest.kt
index 36fc67f59..00f6a85a0 100644
--- a/src/test/kotlin/blackjack/domain/DealerTest.kt
+++ b/src/test/kotlin/blackjack/domain/DealerTest.kt
@@ -3,6 +3,7 @@ package blackjack.domain
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
+import java.math.BigDecimal
 
 class DealerTest {
     @Test
@@ -16,6 +17,7 @@ class DealerTest {
         val players =
             dealer.initPlayers(
                 fetchPlayerNames = { playerNames },
+                getBettingAmount = { BigDecimal.ZERO },
                 onPlayerInit = {},
             )
 
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index 001998b0b..95f83094e 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -3,13 +3,18 @@ package blackjack.domain
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
+import java.math.BigDecimal
 
 class PlayerTest {
     @Test
     @DisplayName("Player 가 계속해서 Rank SEVEN 만 뽑으면, 최대 3번 뽑을 수 있고 카드 합은 21이다")
     fun `player can draw up to 3 cards if all are Rank SEVEN, with a total sum of 21`() {
         val fakeDeck = Deck { Card(Rank.SEVEN, Suit.HEARTS) }
-        val player = Player("sara", drawCard = { fakeDeck.draw() })
+        val player = Player(
+            name = "sara",
+            betMoney = BetMoney(BigDecimal.ZERO),
+            drawCard = { fakeDeck.draw() }
+        )
         player.play(
             isDrawCard = { true },
             onDrawCard = {},
@@ -23,7 +28,11 @@ class PlayerTest {
     @DisplayName("Player 가 카드를 뽑지 않는다면 기본으로 주어진 카드만 갖는다")
     fun `player keeps the default cards if no additional cards are drawn`() {
         val fakeDeck = Deck { Card(Rank.TWO, Suit.HEARTS) } // 기본으로 주어질 카드
-        val player = Player("sara", drawCard = { fakeDeck.draw() })
+        val player = Player(
+            name = "sara",
+            betMoney = BetMoney(BigDecimal.ZERO),
+            drawCard = { fakeDeck.draw() }
+        )
         player.play(
             // 카드를 추가로 뽑지 않는다
             isDrawCard = { false },

From ae042c192a72bd72a7a75d742d0cf59a2eae1990 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:15:49 +0900
Subject: [PATCH 15/32] [step4] ktlintformat

---
 .../domain/BlackJackResultManager.kt          | 12 +++++++---
 src/main/kotlin/blackjack/domain/Dealer.kt    | 19 ++++++++--------
 .../kotlin/blackjack/domain/PlayerTest.kt     | 22 ++++++++++---------
 3 files changed, 31 insertions(+), 22 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 1eb54b04f..29b6a413f 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -72,16 +72,22 @@ enum class GameResult {
     WIN,
     BUST,
     LOSE,
-    PUSH;
+    PUSH,
+    ;
 
     fun isWin() = this == WIN
+
     fun isBust() = this == BUST
+
     fun isLose() = this == LOSE
-    fun isPush() = this == PUSH
 
+    fun isPush() = this == PUSH
 
     companion object {
-        fun fromScores(dealerScore: Int, playerScore: Int): GameResult {
+        fun fromScores(
+            dealerScore: Int,
+            playerScore: Int,
+        ): GameResult {
             return when {
                 dealerScore > Card.MAX_SUM -> WIN // Dealer bust
                 playerScore > Card.MAX_SUM -> BUST // Player bust
diff --git a/src/main/kotlin/blackjack/domain/Dealer.kt b/src/main/kotlin/blackjack/domain/Dealer.kt
index 69d0f1f0a..86502cf28 100644
--- a/src/main/kotlin/blackjack/domain/Dealer.kt
+++ b/src/main/kotlin/blackjack/domain/Dealer.kt
@@ -12,15 +12,16 @@ class Dealer(
     ): Players {
         val names = fetchPlayerNames()
         val nameAndBets = names.associateWith(getBettingAmount)
-        val players = Players(
-            nameAndBets.map { (name, bet) ->
-                Player(
-                    name = name,
-                    betMoney = BetMoney(bet),
-                    drawCard = drawCard,
-                )
-            }
-        )
+        val players =
+            Players(
+                nameAndBets.map { (name, bet) ->
+                    Player(
+                        name = name,
+                        betMoney = BetMoney(bet),
+                        drawCard = drawCard,
+                    )
+                },
+            )
         onPlayerInit(names)
         initProfitMoney(players.getTotalBetMoneyFromPlayers())
         return players
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index 95f83094e..7186874b4 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -10,11 +10,12 @@ class PlayerTest {
     @DisplayName("Player 가 계속해서 Rank SEVEN 만 뽑으면, 최대 3번 뽑을 수 있고 카드 합은 21이다")
     fun `player can draw up to 3 cards if all are Rank SEVEN, with a total sum of 21`() {
         val fakeDeck = Deck { Card(Rank.SEVEN, Suit.HEARTS) }
-        val player = Player(
-            name = "sara",
-            betMoney = BetMoney(BigDecimal.ZERO),
-            drawCard = { fakeDeck.draw() }
-        )
+        val player =
+            Player(
+                name = "sara",
+                betMoney = BetMoney(BigDecimal.ZERO),
+                drawCard = { fakeDeck.draw() },
+            )
         player.play(
             isDrawCard = { true },
             onDrawCard = {},
@@ -28,11 +29,12 @@ class PlayerTest {
     @DisplayName("Player 가 카드를 뽑지 않는다면 기본으로 주어진 카드만 갖는다")
     fun `player keeps the default cards if no additional cards are drawn`() {
         val fakeDeck = Deck { Card(Rank.TWO, Suit.HEARTS) } // 기본으로 주어질 카드
-        val player = Player(
-            name = "sara",
-            betMoney = BetMoney(BigDecimal.ZERO),
-            drawCard = { fakeDeck.draw() }
-        )
+        val player =
+            Player(
+                name = "sara",
+                betMoney = BetMoney(BigDecimal.ZERO),
+                drawCard = { fakeDeck.draw() },
+            )
         player.play(
             // 카드를 추가로 뽑지 않는다
             isDrawCard = { false },

From 1ab98c982c92c627165cf659fd4a7771a008d5a5 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:55:34 +0900
Subject: [PATCH 16/32] =?UTF-8?q?[step4]=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?=
 =?UTF-8?q?=EB=B3=B4=EA=B0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../kotlin/blackjack/domain/DealerTest.kt     |  16 +++
 .../domain/GameResultCalculatorTest.kt        |   2 +-
 .../kotlin/blackjack/domain/GameResultTest.kt |  32 ++++++
 .../kotlin/blackjack/domain/PlayerTest.kt     | 102 ++++++++++++++++++
 4 files changed, 151 insertions(+), 1 deletion(-)
 create mode 100644 src/test/kotlin/blackjack/domain/GameResultTest.kt

diff --git a/src/test/kotlin/blackjack/domain/DealerTest.kt b/src/test/kotlin/blackjack/domain/DealerTest.kt
index 00f6a85a0..018ab47e6 100644
--- a/src/test/kotlin/blackjack/domain/DealerTest.kt
+++ b/src/test/kotlin/blackjack/domain/DealerTest.kt
@@ -1,6 +1,7 @@
 package blackjack.domain
 
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 import java.math.BigDecimal
@@ -56,4 +57,19 @@ class DealerTest {
         // then
         assertThat(card).isSameAs(firstCard)
     }
+
+    @Test
+    @DisplayName("플레이어가 10000원 만큼 얻었다면 딜러는 최초 총 베팅 금액에서 10000원을 차감한 금액을 갖는다")
+    fun `when player gains 10000, dealer loses 10000`() {
+        // given
+        val dealer = Dealer(drawCard = { Card(Rank.TWO, Suit.HEARTS) })
+        val totalBet = BigDecimal(30000)
+        dealer.profitMoney.set(totalBet)
+
+        // when
+        dealer.adjustProfit(playerProfit = ProfitMoney().apply { set(BigDecimal(10000)) })
+
+        //then
+        assertThat(dealer.profitMoney.getCurrentProfit()).isEqualTo(BigDecimal(20000))
+    }
 }
diff --git a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
index 665d0333a..8de399a43 100644
--- a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
+++ b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
@@ -12,7 +12,7 @@ class GameResultCalculatorTest {
         // Dealer == Bust, Player 승리
         "22, 20, WIN",
         // Player == Bust, Dealer 승리
-        "20, 22, LOSE",
+        "20, 22, BUST",
         // 둘다 Bust 아닐때 Player 점수가 높으면, Player 승리
         "18, 19, WIN",
         // 둘다 Bust 아닐때 Dealer 점수가 높으면, Dealer 승리
diff --git a/src/test/kotlin/blackjack/domain/GameResultTest.kt b/src/test/kotlin/blackjack/domain/GameResultTest.kt
new file mode 100644
index 000000000..fc26208ad
--- /dev/null
+++ b/src/test/kotlin/blackjack/domain/GameResultTest.kt
@@ -0,0 +1,32 @@
+package blackjack.domain
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+class GameResultTest {
+    @DisplayName("딜러와 플레이어 점수가 주어졌을 때 게임 결과를 알맞게 반환한다")
+    @ParameterizedTest(name = "{index} => dealerScore={0}, playerScore={1}, expectedResult={2}")
+    @CsvSource(
+        // Dealer == Bust, Player 승리
+        "22, 20, WIN",
+        // Player == Bust, Dealer 승리
+        "20, 22, BUST",
+        // 둘다 Bust 아닐때 Player 점수가 높으면, Player 승리
+        "18, 19, WIN",
+        // 둘다 Bust 아닐때 Dealer 점수가 높으면, Dealer 승리
+        "19, 18, LOSE",
+    )
+    fun getGameResultFromDealerAndPlayerScores(
+        dealerScore: Int,
+        playerScore: Int,
+        expectedResult: GameResult,
+    ) {
+        val result = GameResult.fromScores(
+            dealerScore = dealerScore,
+            playerScore = playerScore,
+        )
+        assertEquals(expectedResult, result)
+    }
+}
\ No newline at end of file
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index 7186874b4..ed0be4f69 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -1,6 +1,7 @@
 package blackjack.domain
 
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 import java.math.BigDecimal
@@ -44,4 +45,105 @@ class PlayerTest {
         assertThat(player.cards.value.size).isEqualTo(2)
         assertThat(player.cardsSum).isEqualTo(4)
     }
+
+    @Test
+    @DisplayName("BUST 되었다면 플레이어의 베팅 금액을 모두 잃는다")
+    fun `player loses all money on bust`() {
+        // Given
+        val player = initFakePlayer()
+
+        // When
+        player.onBust() // Player loses on bust
+
+        // Then
+        assertEquals(BigDecimal(-10000), player.profitMoney.getCurrentProfit())
+    }
+
+    @Test
+    @DisplayName("WIN 이면 플레이어의 베팅 금액을 그대로 가져간다")
+    fun `player wins and keeps the bet amount`() {
+        // Given
+        val player = initFakePlayer()
+
+        // When
+        player.onWin()
+
+        // Then
+        assertEquals(BigDecimal(10000), player.profitMoney.getCurrentProfit())
+    }
+
+    @Test
+    @DisplayName("LOSE 이면 플레이어의 베팅 금액을 모두 잃는다")
+    fun `player loses all money on lose`() {
+        // Given
+        val player = initFakePlayer()
+
+        // When
+        player.onLose()
+
+        // Then
+        assertEquals(BigDecimal(-10000), player.profitMoney.getCurrentProfit())
+    }
+
+    @Test
+    @DisplayName("PUSH 이면 플레이어의 베팅 금액은 변동되지 않는다")
+    fun `player's profit remains the same on push`() {
+        // Given
+        val player = initFakePlayer()
+
+        // When
+        player.onPush()
+
+        // Then
+        assertEquals(BigDecimal(10000), player.profitMoney.getCurrentProfit())
+    }
+
+    @Test
+    @DisplayName("최초 할당된 2장의 카드 합이 21 이라면 블랙잭이다")
+    fun `if player's initial two cards sum is 21, it is blackjack`() {
+        val player = initBlackJackPlayer()
+        assertThat(player.cardsSum == Card.MAX_SUM).isTrue()
+        assertThat(player.isBlackJackInitially).isTrue()
+    }
+
+    @Test
+    @DisplayName("플레이어에 할당된 최초 2장이 블랙잭이면, 베팅금액의 1.5배를 받는다")
+    fun `player's profit multiplies by 150 percent on blackjack`() {
+        // Given
+        val player = initBlackJackPlayer()
+
+        // When
+        player.onBlackJackInitially()
+
+        // Then
+        assertEquals(BigDecimal(15000), player.profitMoney.getCurrentProfit())
+    }
+
+    private fun initFakePlayer(): Player {
+        val betAmount = BetMoney(BigDecimal(10000))
+        val fakeDeck = Deck { Card(Rank.KING, Suit.HEARTS) }
+        val player = Player(
+            name = "Pobi",
+            betMoney = betAmount,
+            drawCard = { fakeDeck.draw() }
+        )
+        return player
+    }
+
+    private fun initBlackJackPlayer(): Player {
+        val betAmount = BetMoney(BigDecimal(10000))
+        val cards = ArrayDeque(
+            listOf(
+                Card(Rank.ACE, Suit.HEARTS),
+                Card(Rank.KING, Suit.HEARTS)
+            )
+        )
+        val fakeDeck = Deck { cards.removeFirst() }
+        val player = Player(
+            name = "Pobi",
+            betMoney = betAmount,
+            drawCard = { fakeDeck.draw() }
+        )
+        return player
+    }
 }

From 686133615f7fec67e15443d430e4e98d47a8a91a Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:55:46 +0900
Subject: [PATCH 17/32] =?UTF-8?q?[step4]=20=EA=B2=B0=EA=B3=BC=20=EC=B6=94?=
 =?UTF-8?q?=EC=B6=9C=ED=95=98=EB=8A=94=20=EB=B6=80=EB=B6=84=20=EB=A6=AC?=
 =?UTF-8?q?=ED=8C=A9=ED=86=A0=EB=A7=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/BetMoney.kt  |  3 +-
 .../domain/BlackJackResultManager.kt          | 94 ++++++++++---------
 src/main/kotlin/blackjack/domain/Cards.kt     |  4 -
 3 files changed, 54 insertions(+), 47 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BetMoney.kt b/src/main/kotlin/blackjack/domain/BetMoney.kt
index dc61e5c16..c3054ee60 100644
--- a/src/main/kotlin/blackjack/domain/BetMoney.kt
+++ b/src/main/kotlin/blackjack/domain/BetMoney.kt
@@ -1,6 +1,7 @@
 package blackjack.domain
 
 import java.math.BigDecimal
+import java.math.RoundingMode
 
 @JvmInline
 value class BetMoney(private val amount: BigDecimal) {
@@ -9,7 +10,7 @@ value class BetMoney(private val amount: BigDecimal) {
     }
 
     fun getAmountOnBlackJack(): BigDecimal {
-        return amount.multiply((1.5).toBigDecimal())
+        return amount.multiply((1.5).toBigDecimal()).setScale(0, RoundingMode.DOWN)
     }
 
     fun getAmountOnBust(): BigDecimal {
diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 29b6a413f..6d6a20441 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -16,57 +16,45 @@ class BlackJackResultManager(
     }
 
     fun getResultV2(): BlackJackResultV2 {
-        val playersToProfits =
-            players.value.associateWith { player ->
-                val result = GameResult.fromScores(dealer.cardsSum, player.cardsSum)
-                when {
-                    player.isBlackJackInitially && dealer.isBlackJackInitially.not() -> player.onBlackJackInitially()
-                    player.isBlackJackInitially && dealer.isBlackJackInitially -> player.onPush()
-                    result.isWin() -> player.onWin()
-                    result.isBust() -> player.onBust()
-                    result.isLose() -> player.onLose()
-                    result.isPush() -> player.onPush()
-                }
-
-                player.profitMoney
-            }
-        playersToProfits.forEach { (_, profitMoney) ->
-            dealer.adjustProfit(profitMoney)
-        }
-        return BlackJackResultV2(dealer.profitMoney, PlayerToProfitMoney(playersToProfits))
+        val playersProfits = players.getPlayersToProfitMoney(dealer)
+        return BlackJackResultV2(dealer.profitMoney, playersProfits)
     }
 }
 
-data class BlackJackResultV2(
-    val dealerProfitMoney: ProfitMoney,
-    val playerToProfit: PlayerToProfitMoney,
-)
+private fun Players.getPlayersToProfitMoney(dealer: Dealer): PlayerToProfitMoney {
+    val map = value.associateWith { player ->
+        player.setPlayersProfitMoney(
+            result = GameResult.fromScores(dealer.cardsSum, player.cardsSum),
+            isDealerBlackJackInitially = dealer.isBlackJackInitially,
+        )
 
-data class PlayerToProfitMoney(
-    val value: Map<Player, ProfitMoney>,
-)
+        val playerProfitMoney = player.profitMoney
+        dealer.adjustProfit(playerProfitMoney)
+        playerProfitMoney
+    }
+    return PlayerToProfitMoney(map)
+}
 
-@Deprecated("deprecated")
-data class BlackJackResult(
-    val playerToResultMap: PlayerToResultMap,
+private fun Player.setPlayersProfitMoney(
+    result: GameResult,
+    isDealerBlackJackInitially: Boolean
 ) {
-    val dealerWinCount: Int
-        get() = playerToResultMap.getPlayerLoseCounts()
-    val dealerLoseCount: Int
-        get() = playerToResultMap.getPlayerWinningCounts()
+    when {
+        this.isBlackJackInitially && isDealerBlackJackInitially.not() -> this.onBlackJackInitially()
+        this.isBlackJackInitially && isDealerBlackJackInitially -> this.onPush()
+        result.isWin() -> this.onWin()
+        result.isBust() -> this.onBust()
+        result.isLose() -> this.onLose()
+        result.isPush() -> this.onPush()
+    }
 }
 
-@Deprecated("deprecated")
-@JvmInline
-value class PlayerToResultMap(val value: Map<Player, GameResult>) {
-    fun getPlayerWinningCounts(): Int {
-        return value.count { it.value == GameResult.WIN }
-    }
+data class BlackJackResultV2(
+    val dealerProfitMoney: ProfitMoney,
+    val playerToProfit: PlayerToProfitMoney,
+)
 
-    fun getPlayerLoseCounts(): Int {
-        return value.count { it.value == GameResult.LOSE }
-    }
-}
+data class PlayerToProfitMoney(val value: Map<Player, ProfitMoney>)
 
 enum class GameResult {
     WIN,
@@ -98,3 +86,25 @@ enum class GameResult {
         }
     }
 }
+
+@Deprecated("deprecated")
+data class BlackJackResult(
+    val playerToResultMap: PlayerToResultMap,
+) {
+    val dealerWinCount: Int
+        get() = playerToResultMap.getPlayerLoseCounts()
+    val dealerLoseCount: Int
+        get() = playerToResultMap.getPlayerWinningCounts()
+}
+
+@Deprecated("deprecated")
+@JvmInline
+value class PlayerToResultMap(val value: Map<Player, GameResult>) {
+    fun getPlayerWinningCounts(): Int {
+        return value.count { it.value == GameResult.WIN }
+    }
+
+    fun getPlayerLoseCounts(): Int {
+        return value.count { it.value == GameResult.LOSE }
+    }
+}
diff --git a/src/main/kotlin/blackjack/domain/Cards.kt b/src/main/kotlin/blackjack/domain/Cards.kt
index 3c14ea481..5d37654ec 100644
--- a/src/main/kotlin/blackjack/domain/Cards.kt
+++ b/src/main/kotlin/blackjack/domain/Cards.kt
@@ -9,10 +9,6 @@ data class Cards(val value: List<Card>) {
         return adjustForAces(nonAcesSum, aceCount)
     }
 
-    fun isBust(): Boolean {
-        return sumValues() > MAX_SUM
-    }
-
     private fun calculateNonAcesAndCountAces(): Pair<Int, Int> {
         var sum = 0
         var aceCount = 0

From d6ac32a65712aa179f5fcba74a86b6fe535b3b89 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:56:38 +0900
Subject: [PATCH 18/32] =?UTF-8?q?[step4]=20=EC=A3=BC=EC=84=9D=20=EB=B3=B4?=
 =?UTF-8?q?=EA=B0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/BlackJackResultManager.kt | 6 +++---
 src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 6d6a20441..09baea8d9 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -4,7 +4,7 @@ class BlackJackResultManager(
     private val dealer: Dealer,
     private val players: Players,
 ) {
-    @Deprecated("getResultV2 를 사용하세요")
+    @Deprecated("step4에서는 getResultV2 를 사용하세요 - step3 에서만 사용됨")
     fun getResult(): BlackJackResult {
         val dealerScore = dealer.cardsSum
         val playersWinLose =
@@ -87,7 +87,7 @@ enum class GameResult {
     }
 }
 
-@Deprecated("deprecated")
+@Deprecated("deprecated - step3 에서만 사용됨")
 data class BlackJackResult(
     val playerToResultMap: PlayerToResultMap,
 ) {
@@ -97,7 +97,7 @@ data class BlackJackResult(
         get() = playerToResultMap.getPlayerWinningCounts()
 }
 
-@Deprecated("deprecated")
+@Deprecated("deprecated - step3 에서만 사용됨")
 @JvmInline
 value class PlayerToResultMap(val value: Map<Player, GameResult>) {
     fun getPlayerWinningCounts(): Int {
diff --git a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
index e1158ac6c..d03385b2a 100644
--- a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
+++ b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
@@ -1,6 +1,6 @@
 package blackjack.domain
 
-@Deprecated("deprecated")
+@Deprecated("deprecated - step3 에서만 사용됨")
 object PlayerResultCalculator {
     fun calculate(
         dealerScore: Int,

From 204492f86489c8fc940fd1d881564c9a9a4f2a24 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 19:57:08 +0900
Subject: [PATCH 19/32] [step4] ktlintformat

---
 .../domain/BlackJackResultManager.kt          | 23 ++++++-------
 .../kotlin/blackjack/domain/DealerTest.kt     |  3 +-
 .../kotlin/blackjack/domain/GameResultTest.kt | 11 ++++---
 .../kotlin/blackjack/domain/PlayerTest.kt     | 33 ++++++++++---------
 4 files changed, 37 insertions(+), 33 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 09baea8d9..6ec70f1e6 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -22,22 +22,23 @@ class BlackJackResultManager(
 }
 
 private fun Players.getPlayersToProfitMoney(dealer: Dealer): PlayerToProfitMoney {
-    val map = value.associateWith { player ->
-        player.setPlayersProfitMoney(
-            result = GameResult.fromScores(dealer.cardsSum, player.cardsSum),
-            isDealerBlackJackInitially = dealer.isBlackJackInitially,
-        )
-
-        val playerProfitMoney = player.profitMoney
-        dealer.adjustProfit(playerProfitMoney)
-        playerProfitMoney
-    }
+    val map =
+        value.associateWith { player ->
+            player.setPlayersProfitMoney(
+                result = GameResult.fromScores(dealer.cardsSum, player.cardsSum),
+                isDealerBlackJackInitially = dealer.isBlackJackInitially,
+            )
+
+            val playerProfitMoney = player.profitMoney
+            dealer.adjustProfit(playerProfitMoney)
+            playerProfitMoney
+        }
     return PlayerToProfitMoney(map)
 }
 
 private fun Player.setPlayersProfitMoney(
     result: GameResult,
-    isDealerBlackJackInitially: Boolean
+    isDealerBlackJackInitially: Boolean,
 ) {
     when {
         this.isBlackJackInitially && isDealerBlackJackInitially.not() -> this.onBlackJackInitially()
diff --git a/src/test/kotlin/blackjack/domain/DealerTest.kt b/src/test/kotlin/blackjack/domain/DealerTest.kt
index 018ab47e6..c48c00c81 100644
--- a/src/test/kotlin/blackjack/domain/DealerTest.kt
+++ b/src/test/kotlin/blackjack/domain/DealerTest.kt
@@ -1,7 +1,6 @@
 package blackjack.domain
 
 import org.assertj.core.api.Assertions.assertThat
-import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 import java.math.BigDecimal
@@ -69,7 +68,7 @@ class DealerTest {
         // when
         dealer.adjustProfit(playerProfit = ProfitMoney().apply { set(BigDecimal(10000)) })
 
-        //then
+        // then
         assertThat(dealer.profitMoney.getCurrentProfit()).isEqualTo(BigDecimal(20000))
     }
 }
diff --git a/src/test/kotlin/blackjack/domain/GameResultTest.kt b/src/test/kotlin/blackjack/domain/GameResultTest.kt
index fc26208ad..425b364fa 100644
--- a/src/test/kotlin/blackjack/domain/GameResultTest.kt
+++ b/src/test/kotlin/blackjack/domain/GameResultTest.kt
@@ -23,10 +23,11 @@ class GameResultTest {
         playerScore: Int,
         expectedResult: GameResult,
     ) {
-        val result = GameResult.fromScores(
-            dealerScore = dealerScore,
-            playerScore = playerScore,
-        )
+        val result =
+            GameResult.fromScores(
+                dealerScore = dealerScore,
+                playerScore = playerScore,
+            )
         assertEquals(expectedResult, result)
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index ed0be4f69..65f19d118 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -122,28 +122,31 @@ class PlayerTest {
     private fun initFakePlayer(): Player {
         val betAmount = BetMoney(BigDecimal(10000))
         val fakeDeck = Deck { Card(Rank.KING, Suit.HEARTS) }
-        val player = Player(
-            name = "Pobi",
-            betMoney = betAmount,
-            drawCard = { fakeDeck.draw() }
-        )
+        val player =
+            Player(
+                name = "Pobi",
+                betMoney = betAmount,
+                drawCard = { fakeDeck.draw() },
+            )
         return player
     }
 
     private fun initBlackJackPlayer(): Player {
         val betAmount = BetMoney(BigDecimal(10000))
-        val cards = ArrayDeque(
-            listOf(
-                Card(Rank.ACE, Suit.HEARTS),
-                Card(Rank.KING, Suit.HEARTS)
+        val cards =
+            ArrayDeque(
+                listOf(
+                    Card(Rank.ACE, Suit.HEARTS),
+                    Card(Rank.KING, Suit.HEARTS),
+                ),
             )
-        )
         val fakeDeck = Deck { cards.removeFirst() }
-        val player = Player(
-            name = "Pobi",
-            betMoney = betAmount,
-            drawCard = { fakeDeck.draw() }
-        )
+        val player =
+            Player(
+                name = "Pobi",
+                betMoney = betAmount,
+                drawCard = { fakeDeck.draw() },
+            )
         return player
     }
 }

From c2de14a39c391f381e90823a9022317941cc8052 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 20:09:34 +0900
Subject: [PATCH 20/32] =?UTF-8?q?[step4]=20=EB=94=9C=EB=9F=AC=20=EC=88=98?=
 =?UTF-8?q?=EC=9D=B5=20=EA=B3=84=EC=82=B0=20=EB=A1=9C=EC=A7=81=20=EB=B2=84?=
 =?UTF-8?q?=EA=B7=B8=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Dealer.kt  | 5 -----
 src/main/kotlin/blackjack/domain/Players.kt | 6 ------
 2 files changed, 11 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/Dealer.kt b/src/main/kotlin/blackjack/domain/Dealer.kt
index 86502cf28..dc35fafe4 100644
--- a/src/main/kotlin/blackjack/domain/Dealer.kt
+++ b/src/main/kotlin/blackjack/domain/Dealer.kt
@@ -23,7 +23,6 @@ class Dealer(
                 },
             )
         onPlayerInit(names)
-        initProfitMoney(players.getTotalBetMoneyFromPlayers())
         return players
     }
 
@@ -45,10 +44,6 @@ class Dealer(
         profitMoney.set(profit)
     }
 
-    private fun initProfitMoney(totalBet: BigDecimal) {
-        profitMoney.set(totalBet)
-    }
-
     companion object {
         private const val DEALER_CARD_COUNT = 2
         private const val DEALER_DRAW_ONE_MORE_CARD_THRESHOLD = 16
diff --git a/src/main/kotlin/blackjack/domain/Players.kt b/src/main/kotlin/blackjack/domain/Players.kt
index dd01cbda3..2181e772d 100644
--- a/src/main/kotlin/blackjack/domain/Players.kt
+++ b/src/main/kotlin/blackjack/domain/Players.kt
@@ -1,7 +1,5 @@
 package blackjack.domain
 
-import java.math.BigDecimal
-
 data class Players(val value: List<Player>) {
     fun onEachPreparePlay(action: (Player) -> Unit): Players {
         onEach(action)
@@ -17,8 +15,4 @@ data class Players(val value: List<Player>) {
         value.forEach { action(it) }
         return this
     }
-
-    fun getTotalBetMoneyFromPlayers(): BigDecimal {
-        return value.sumOf { it.originalBetAmount }
-    }
 }

From 7f3f1ce40c0a0801d435031edb4a3dd1b2705c33 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 20:25:32 +0900
Subject: [PATCH 21/32] =?UTF-8?q?[step4]=20=EB=94=9C=EB=9F=AC=20=EC=88=98?=
 =?UTF-8?q?=EC=9D=B5=20=EA=B3=84=EC=82=B0=20=EB=A1=9C=EC=A7=81=20=EB=B2=84?=
 =?UTF-8?q?=EA=B7=B8=20=EC=88=98=EC=A0=95=20-=20=EB=B6=88=ED=95=84?=
 =?UTF-8?q?=EC=9A=94=ED=95=9C=20=ED=95=84=EB=93=9C=20=EC=A0=9C=EA=B1=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Player.kt | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 21c8ca344..3c99c4efd 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -5,8 +5,6 @@ class Player(
     private val betMoney: BetMoney,
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
-    val originalBetAmount get() = betMoney.getOriginalBetAmount()
-
     fun play(
         isDrawCard: (String) -> Boolean,
         onDrawCard: () -> Unit,

From 4ab56d952d7db3299d4205e0f1a684e56d57bdb3 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 20:27:26 +0900
Subject: [PATCH 22/32] =?UTF-8?q?[step4]=20GameResult=20=ED=8C=8C=EC=9D=BC?=
 =?UTF-8?q?=20=EB=B6=84=EB=A6=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../domain/BlackJackResultManager.kt          | 31 ------------------
 .../kotlin/blackjack/domain/GameResult.kt     | 32 +++++++++++++++++++
 2 files changed, 32 insertions(+), 31 deletions(-)
 create mode 100644 src/main/kotlin/blackjack/domain/GameResult.kt

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 6ec70f1e6..74de19e5e 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -57,37 +57,6 @@ data class BlackJackResultV2(
 
 data class PlayerToProfitMoney(val value: Map<Player, ProfitMoney>)
 
-enum class GameResult {
-    WIN,
-    BUST,
-    LOSE,
-    PUSH,
-    ;
-
-    fun isWin() = this == WIN
-
-    fun isBust() = this == BUST
-
-    fun isLose() = this == LOSE
-
-    fun isPush() = this == PUSH
-
-    companion object {
-        fun fromScores(
-            dealerScore: Int,
-            playerScore: Int,
-        ): GameResult {
-            return when {
-                dealerScore > Card.MAX_SUM -> WIN // Dealer bust
-                playerScore > Card.MAX_SUM -> BUST // Player bust
-                dealerScore > playerScore -> LOSE
-                playerScore > dealerScore -> WIN
-                else -> PUSH
-            }
-        }
-    }
-}
-
 @Deprecated("deprecated - step3 에서만 사용됨")
 data class BlackJackResult(
     val playerToResultMap: PlayerToResultMap,
diff --git a/src/main/kotlin/blackjack/domain/GameResult.kt b/src/main/kotlin/blackjack/domain/GameResult.kt
new file mode 100644
index 000000000..5c4f51d93
--- /dev/null
+++ b/src/main/kotlin/blackjack/domain/GameResult.kt
@@ -0,0 +1,32 @@
+package blackjack.domain
+
+enum class GameResult {
+    WIN,
+    BUST,
+    LOSE,
+    PUSH,
+    ;
+
+    fun isWin() = this == WIN
+
+    fun isBust() = this == BUST
+
+    fun isLose() = this == LOSE
+
+    fun isPush() = this == PUSH
+
+    companion object {
+        fun fromScores(
+            dealerScore: Int,
+            playerScore: Int,
+        ): GameResult {
+            return when {
+                dealerScore > Card.MAX_SUM -> WIN // Dealer bust
+                playerScore > Card.MAX_SUM -> BUST // Player bust
+                dealerScore > playerScore -> LOSE
+                playerScore > dealerScore -> WIN
+                else -> PUSH
+            }
+        }
+    }
+}

From 4d5b3ca3a3c3da7886dcde42fb74957ca367681f Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 21:38:05 +0900
Subject: [PATCH 23/32] =?UTF-8?q?[step4]=20=ED=99=95=EC=9E=A5=ED=95=A8?=
 =?UTF-8?q?=EC=88=98=20=EC=A0=9C=EA=B1=B0,=20=EC=A4=91=EB=B3=B5=20?=
 =?UTF-8?q?=EC=A0=9C=EA=B1=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../domain/BlackJackResultManager.kt          | 29 -------------------
 .../kotlin/blackjack/domain/GameResult.kt     |  9 +-----
 .../kotlin/blackjack/domain/Participant.kt    |  8 +++++
 src/main/kotlin/blackjack/domain/Player.kt    | 29 +++++++++----------
 src/main/kotlin/blackjack/domain/Players.kt   | 13 +++++++++
 .../kotlin/blackjack/domain/PlayerTest.kt     | 10 +++----
 6 files changed, 40 insertions(+), 58 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 74de19e5e..5071328f8 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -21,35 +21,6 @@ class BlackJackResultManager(
     }
 }
 
-private fun Players.getPlayersToProfitMoney(dealer: Dealer): PlayerToProfitMoney {
-    val map =
-        value.associateWith { player ->
-            player.setPlayersProfitMoney(
-                result = GameResult.fromScores(dealer.cardsSum, player.cardsSum),
-                isDealerBlackJackInitially = dealer.isBlackJackInitially,
-            )
-
-            val playerProfitMoney = player.profitMoney
-            dealer.adjustProfit(playerProfitMoney)
-            playerProfitMoney
-        }
-    return PlayerToProfitMoney(map)
-}
-
-private fun Player.setPlayersProfitMoney(
-    result: GameResult,
-    isDealerBlackJackInitially: Boolean,
-) {
-    when {
-        this.isBlackJackInitially && isDealerBlackJackInitially.not() -> this.onBlackJackInitially()
-        this.isBlackJackInitially && isDealerBlackJackInitially -> this.onPush()
-        result.isWin() -> this.onWin()
-        result.isBust() -> this.onBust()
-        result.isLose() -> this.onLose()
-        result.isPush() -> this.onPush()
-    }
-}
-
 data class BlackJackResultV2(
     val dealerProfitMoney: ProfitMoney,
     val playerToProfit: PlayerToProfitMoney,
diff --git a/src/main/kotlin/blackjack/domain/GameResult.kt b/src/main/kotlin/blackjack/domain/GameResult.kt
index 5c4f51d93..de4503fa5 100644
--- a/src/main/kotlin/blackjack/domain/GameResult.kt
+++ b/src/main/kotlin/blackjack/domain/GameResult.kt
@@ -5,16 +5,9 @@ enum class GameResult {
     BUST,
     LOSE,
     PUSH,
+    BLACK_JACK,
     ;
 
-    fun isWin() = this == WIN
-
-    fun isBust() = this == BUST
-
-    fun isLose() = this == LOSE
-
-    fun isPush() = this == PUSH
-
     companion object {
         fun fromScores(
             dealerScore: Int,
diff --git a/src/main/kotlin/blackjack/domain/Participant.kt b/src/main/kotlin/blackjack/domain/Participant.kt
index b23901a28..41d05b547 100644
--- a/src/main/kotlin/blackjack/domain/Participant.kt
+++ b/src/main/kotlin/blackjack/domain/Participant.kt
@@ -30,6 +30,14 @@ abstract class Participant(
         return false
     }
 
+    fun getGameResultWith(dealer: Participant): GameResult {
+        return when {
+            this.isBlackJackInitially && dealer.isBlackJackInitially.not() -> GameResult.BLACK_JACK
+            this.isBlackJackInitially && dealer.isBlackJackInitially -> GameResult.PUSH
+            else -> GameResult.fromScores(dealer.cardsSum, this.cardsSum)
+        }
+    }
+
     abstract fun isAddCardEnabled(): Boolean
 
     companion object {
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 3c99c4efd..c6c5ea25c 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -1,5 +1,7 @@
 package blackjack.domain
 
+import java.math.BigDecimal
+
 class Player(
     val name: String,
     private val betMoney: BetMoney,
@@ -18,24 +20,19 @@ class Player(
         onExitPlay()
     }
 
-    fun onBlackJackInitially() {
-        profitMoney.set(betMoney.getAmountOnBlackJack())
-    }
-
-    fun onWin() {
-        profitMoney.set(betMoney.getOriginalBetAmount())
-    }
-
-    fun onBust() {
-        profitMoney.set(betMoney.getAmountOnBust())
-    }
-
-    fun onLose() {
-        profitMoney.set(betMoney.getAmountOnLose())
+    fun setProfitMoneyFromGameResult(result: GameResult) {
+        val betMoney = getBetMoneyFromGameResult(result)
+        profitMoney.set(betMoney)
     }
 
-    fun onPush() {
-        profitMoney.set(betMoney.getOriginalBetAmount())
+    private fun getBetMoneyFromGameResult(gameResult: GameResult): BigDecimal {
+        return when (gameResult) {
+            GameResult.BLACK_JACK -> betMoney.getAmountOnBlackJack()
+            GameResult.WIN -> betMoney.getOriginalBetAmount()
+            GameResult.PUSH -> betMoney.getOriginalBetAmount()
+            GameResult.LOSE -> betMoney.getAmountOnLose()
+            GameResult.BUST -> betMoney.getAmountOnBust()
+        }
     }
 
     private fun shouldContinueDrawing(isDrawCard: (String) -> Boolean): Boolean {
diff --git a/src/main/kotlin/blackjack/domain/Players.kt b/src/main/kotlin/blackjack/domain/Players.kt
index 2181e772d..c7a4bb923 100644
--- a/src/main/kotlin/blackjack/domain/Players.kt
+++ b/src/main/kotlin/blackjack/domain/Players.kt
@@ -15,4 +15,17 @@ data class Players(val value: List<Player>) {
         value.forEach { action(it) }
         return this
     }
+
+    fun getPlayersToProfitMoney(dealer: Dealer): PlayerToProfitMoney {
+        val map =
+            value.associateWith { player ->
+                val gameResult = player.getGameResultWith(dealer)
+                player.setProfitMoneyFromGameResult(gameResult)
+
+                val playerProfitMoney = player.profitMoney
+                dealer.adjustProfit(playerProfitMoney)
+                playerProfitMoney
+            }
+        return PlayerToProfitMoney(map)
+    }
 }
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index 65f19d118..ee576a868 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -53,7 +53,7 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        player.onBust() // Player loses on bust
+        player.setProfitMoneyFromGameResult(GameResult.BUST)
 
         // Then
         assertEquals(BigDecimal(-10000), player.profitMoney.getCurrentProfit())
@@ -66,7 +66,7 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        player.onWin()
+        player.setProfitMoneyFromGameResult(GameResult.WIN)
 
         // Then
         assertEquals(BigDecimal(10000), player.profitMoney.getCurrentProfit())
@@ -79,7 +79,7 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        player.onLose()
+        player.setProfitMoneyFromGameResult(GameResult.LOSE)
 
         // Then
         assertEquals(BigDecimal(-10000), player.profitMoney.getCurrentProfit())
@@ -92,7 +92,7 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        player.onPush()
+        player.setProfitMoneyFromGameResult(GameResult.PUSH)
 
         // Then
         assertEquals(BigDecimal(10000), player.profitMoney.getCurrentProfit())
@@ -113,7 +113,7 @@ class PlayerTest {
         val player = initBlackJackPlayer()
 
         // When
-        player.onBlackJackInitially()
+        player.setProfitMoneyFromGameResult(GameResult.BLACK_JACK)
 
         // Then
         assertEquals(BigDecimal(15000), player.profitMoney.getCurrentProfit())

From 8876e4b873dd72555efb68ca9ba80297b0eb5170 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 21:41:15 +0900
Subject: [PATCH 24/32] =?UTF-8?q?[step4]=20Participant=20=EC=B1=85?=
 =?UTF-8?q?=EC=9E=84=20=EB=B3=80=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Participant.kt | 8 --------
 src/main/kotlin/blackjack/domain/Player.kt      | 8 ++++++++
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/Participant.kt b/src/main/kotlin/blackjack/domain/Participant.kt
index 41d05b547..b23901a28 100644
--- a/src/main/kotlin/blackjack/domain/Participant.kt
+++ b/src/main/kotlin/blackjack/domain/Participant.kt
@@ -30,14 +30,6 @@ abstract class Participant(
         return false
     }
 
-    fun getGameResultWith(dealer: Participant): GameResult {
-        return when {
-            this.isBlackJackInitially && dealer.isBlackJackInitially.not() -> GameResult.BLACK_JACK
-            this.isBlackJackInitially && dealer.isBlackJackInitially -> GameResult.PUSH
-            else -> GameResult.fromScores(dealer.cardsSum, this.cardsSum)
-        }
-    }
-
     abstract fun isAddCardEnabled(): Boolean
 
     companion object {
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index c6c5ea25c..5719ea0ab 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -20,6 +20,14 @@ class Player(
         onExitPlay()
     }
 
+    fun getGameResultWith(dealer: Dealer): GameResult {
+        return when {
+            this.isBlackJackInitially && dealer.isBlackJackInitially.not() -> GameResult.BLACK_JACK
+            this.isBlackJackInitially && dealer.isBlackJackInitially -> GameResult.PUSH
+            else -> GameResult.fromScores(dealer.cardsSum, this.cardsSum)
+        }
+    }
+
     fun setProfitMoneyFromGameResult(result: GameResult) {
         val betMoney = getBetMoneyFromGameResult(result)
         profitMoney.set(betMoney)

From e77f4f5c57071a77881e197a2e8ec73998a49116 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Mon, 16 Dec 2024 21:51:11 +0900
Subject: [PATCH 25/32] =?UTF-8?q?[step4]=20=EC=95=94=EC=8B=9C=EC=A0=81?=
 =?UTF-8?q?=EC=9C=BC=EB=A1=9C=20Dealer=20=EC=9D=98=20=EC=88=98=EC=9D=B5?=
 =?UTF-8?q?=EC=9D=84=20=EC=84=B8=ED=8C=85=ED=95=98=EB=8A=94=20=EB=B6=80?=
 =?UTF-8?q?=EB=B6=84=EC=9D=84=20=EB=AA=85=EC=8B=9C=EC=A0=81=EC=9C=BC?=
 =?UTF-8?q?=EB=A1=9C=20=EB=B3=80=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../blackjack/domain/BlackJackResultManager.kt      |  5 ++++-
 src/main/kotlin/blackjack/domain/Players.kt         | 13 +++++++------
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 5071328f8..fb6dca212 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -16,7 +16,10 @@ class BlackJackResultManager(
     }
 
     fun getResultV2(): BlackJackResultV2 {
-        val playersProfits = players.getPlayersToProfitMoney(dealer)
+        val playersProfits = players.getPlayersToProfitMoney(
+            getGameResult = { player -> player.getGameResultWith(dealer) },
+            onSetPlayerProfitMoney = { profitMoney -> dealer.adjustProfit(profitMoney) }
+        )
         return BlackJackResultV2(dealer.profitMoney, playersProfits)
     }
 }
diff --git a/src/main/kotlin/blackjack/domain/Players.kt b/src/main/kotlin/blackjack/domain/Players.kt
index c7a4bb923..5b5838006 100644
--- a/src/main/kotlin/blackjack/domain/Players.kt
+++ b/src/main/kotlin/blackjack/domain/Players.kt
@@ -16,15 +16,16 @@ data class Players(val value: List<Player>) {
         return this
     }
 
-    fun getPlayersToProfitMoney(dealer: Dealer): PlayerToProfitMoney {
+    fun getPlayersToProfitMoney(
+        getGameResult: (Player) -> GameResult,
+        onSetPlayerProfitMoney: (ProfitMoney) -> Unit
+    ): PlayerToProfitMoney {
         val map =
             value.associateWith { player ->
-                val gameResult = player.getGameResultWith(dealer)
+                val gameResult = getGameResult(player)
                 player.setProfitMoneyFromGameResult(gameResult)
-
-                val playerProfitMoney = player.profitMoney
-                dealer.adjustProfit(playerProfitMoney)
-                playerProfitMoney
+                onSetPlayerProfitMoney(player.profitMoney)
+                player.profitMoney
             }
         return PlayerToProfitMoney(map)
     }

From 28a20fa5a492c59ac509877cf5caf4d9dc973379 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Tue, 17 Dec 2024 00:36:29 +0900
Subject: [PATCH 26/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep4]=20Deprecated=20=ED=81=B4=EB=9E=98=EC=8A=A4=20=EB=B0=8F=20?=
 =?UTF-8?q?=ED=95=A8=EC=88=98=20=EC=A0=9C=EA=B1=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../controller/BlackJackController.kt         |  2 +-
 .../domain/BlackJackResultManager.kt          | 37 +------------------
 .../domain/PlayerResultCalculator.kt          | 17 ---------
 src/main/kotlin/blackjack/view/ResultView.kt  |  4 +-
 .../domain/GameResultCalculatorTest.kt        | 33 -----------------
 5 files changed, 5 insertions(+), 88 deletions(-)
 delete mode 100644 src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
 delete mode 100644 src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt

diff --git a/src/main/kotlin/blackjack/controller/BlackJackController.kt b/src/main/kotlin/blackjack/controller/BlackJackController.kt
index 350b499f5..b9615fb29 100644
--- a/src/main/kotlin/blackjack/controller/BlackJackController.kt
+++ b/src/main/kotlin/blackjack/controller/BlackJackController.kt
@@ -60,7 +60,7 @@ object BlackJackController {
         players.onEach { player ->
             ResultView.printFinalScoresForPlayer(player)
         }
-        val result = BlackJackResultManager(dealer, players).getResultV2()
+        val result = BlackJackResultManager(dealer, players).getResult()
         ResultView.printFinalProfit(result)
     }
 }
diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index fb6dca212..48ee8365e 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -4,51 +4,18 @@ class BlackJackResultManager(
     private val dealer: Dealer,
     private val players: Players,
 ) {
-    @Deprecated("step4에서는 getResultV2 를 사용하세요 - step3 에서만 사용됨")
     fun getResult(): BlackJackResult {
-        val dealerScore = dealer.cardsSum
-        val playersWinLose =
-            players.value.associateWith { player ->
-                PlayerResultCalculator.calculate(dealerScore, player.cardsSum)
-            }
-
-        return BlackJackResult(PlayerToResultMap(playersWinLose))
-    }
-
-    fun getResultV2(): BlackJackResultV2 {
         val playersProfits = players.getPlayersToProfitMoney(
             getGameResult = { player -> player.getGameResultWith(dealer) },
             onSetPlayerProfitMoney = { profitMoney -> dealer.adjustProfit(profitMoney) }
         )
-        return BlackJackResultV2(dealer.profitMoney, playersProfits)
+        return BlackJackResult(dealer.profitMoney, playersProfits)
     }
 }
 
-data class BlackJackResultV2(
+data class BlackJackResult(
     val dealerProfitMoney: ProfitMoney,
     val playerToProfit: PlayerToProfitMoney,
 )
 
 data class PlayerToProfitMoney(val value: Map<Player, ProfitMoney>)
-
-@Deprecated("deprecated - step3 에서만 사용됨")
-data class BlackJackResult(
-    val playerToResultMap: PlayerToResultMap,
-) {
-    val dealerWinCount: Int
-        get() = playerToResultMap.getPlayerLoseCounts()
-    val dealerLoseCount: Int
-        get() = playerToResultMap.getPlayerWinningCounts()
-}
-
-@Deprecated("deprecated - step3 에서만 사용됨")
-@JvmInline
-value class PlayerToResultMap(val value: Map<Player, GameResult>) {
-    fun getPlayerWinningCounts(): Int {
-        return value.count { it.value == GameResult.WIN }
-    }
-
-    fun getPlayerLoseCounts(): Int {
-        return value.count { it.value == GameResult.LOSE }
-    }
-}
diff --git a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt b/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
deleted file mode 100644
index d03385b2a..000000000
--- a/src/main/kotlin/blackjack/domain/PlayerResultCalculator.kt
+++ /dev/null
@@ -1,17 +0,0 @@
-package blackjack.domain
-
-@Deprecated("deprecated - step3 에서만 사용됨")
-object PlayerResultCalculator {
-    fun calculate(
-        dealerScore: Int,
-        playerScore: Int,
-    ): GameResult {
-        return when {
-            dealerScore > Card.MAX_SUM -> GameResult.WIN
-            playerScore > Card.MAX_SUM -> GameResult.BUST
-            dealerScore > playerScore -> GameResult.LOSE
-            playerScore > dealerScore -> GameResult.WIN
-            else -> GameResult.PUSH
-        }
-    }
-}
diff --git a/src/main/kotlin/blackjack/view/ResultView.kt b/src/main/kotlin/blackjack/view/ResultView.kt
index 465bf615d..e4947ff6e 100644
--- a/src/main/kotlin/blackjack/view/ResultView.kt
+++ b/src/main/kotlin/blackjack/view/ResultView.kt
@@ -1,6 +1,6 @@
 package blackjack.view
 
-import blackjack.domain.BlackJackResultV2
+import blackjack.domain.BlackJackResult
 import blackjack.domain.Card
 import blackjack.domain.Dealer
 import blackjack.domain.Player
@@ -40,7 +40,7 @@ object ResultView {
         return "${player.name} 카드: ${player.cards.value.map { "${it.rank.rankName}${it.suit.koreanName}" }}"
     }
 
-    fun printFinalProfit(result: BlackJackResultV2) {
+    fun printFinalProfit(result: BlackJackResult) {
         println("\n### 최종 수익")
         println("딜러 : ${result.dealerProfitMoney.getCurrentProfit()}")
         result.playerToProfit.value.forEach { (player, profit) ->
diff --git a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt b/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
deleted file mode 100644
index 8de399a43..000000000
--- a/src/test/kotlin/blackjack/domain/GameResultCalculatorTest.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package blackjack.domain
-
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.DisplayName
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.CsvSource
-
-class GameResultCalculatorTest {
-    @DisplayName("딜러의 점수와 플레이어의 점수가 주어졌을 때 알맞은 게임 결과를 계산한다")
-    @ParameterizedTest(name = "{index} => dealerScore={0}, playerScore={1}, expectedResult={2}")
-    @CsvSource(
-        // Dealer == Bust, Player 승리
-        "22, 20, WIN",
-        // Player == Bust, Dealer 승리
-        "20, 22, BUST",
-        // 둘다 Bust 아닐때 Player 점수가 높으면, Player 승리
-        "18, 19, WIN",
-        // 둘다 Bust 아닐때 Dealer 점수가 높으면, Dealer 승리
-        "19, 18, LOSE",
-    )
-    fun `should calculate game result correctly based on dealer and player scores`(
-        dealerScore: Int,
-        playerScore: Int,
-        expectedResult: GameResult,
-    ) {
-        val result =
-            PlayerResultCalculator.calculate(
-                dealerScore = dealerScore,
-                playerScore = playerScore,
-            )
-        assertEquals(expectedResult, result)
-    }
-}

From 334f5d86efc1bf7a6a39d9050979e1889364c86a Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Tue, 17 Dec 2024 00:39:31 +0900
Subject: [PATCH 27/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep4]=20GameResult=20=EB=A1=9C=EB=B6=80=ED=84=B0=20=EB=B2=A0?=
 =?UTF-8?q?=ED=8C=85=EA=B8=88=EC=95=A1=20=EB=B0=98=ED=99=98=ED=95=98?=
 =?UTF-8?q?=EB=8A=94=20=EB=A1=9C=EC=A7=81=EC=9D=84=20GameResult=EC=9D=98?=
 =?UTF-8?q?=20=EC=B1=85=EC=9E=84=EC=9C=BC=EB=A1=9C=20=EC=9D=B4=EB=8F=99?=
 =?UTF-8?q?=EC=8B=9C=ED=82=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/GameResult.kt | 12 ++++++++++++
 src/main/kotlin/blackjack/domain/Player.kt     | 16 ++--------------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/GameResult.kt b/src/main/kotlin/blackjack/domain/GameResult.kt
index de4503fa5..d563fdf29 100644
--- a/src/main/kotlin/blackjack/domain/GameResult.kt
+++ b/src/main/kotlin/blackjack/domain/GameResult.kt
@@ -1,5 +1,7 @@
 package blackjack.domain
 
+import java.math.BigDecimal
+
 enum class GameResult {
     WIN,
     BUST,
@@ -8,6 +10,16 @@ enum class GameResult {
     BLACK_JACK,
     ;
 
+    fun getBetMoneyAmount(betMoney: BetMoney): BigDecimal {
+        return when (this) {
+            BLACK_JACK -> betMoney.getAmountOnBlackJack()
+            WIN -> betMoney.getOriginalBetAmount()
+            PUSH -> betMoney.getOriginalBetAmount()
+            LOSE -> betMoney.getAmountOnLose()
+            BUST -> betMoney.getAmountOnBust()
+        }
+    }
+
     companion object {
         fun fromScores(
             dealerScore: Int,
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 5719ea0ab..95942d25b 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -1,7 +1,5 @@
 package blackjack.domain
 
-import java.math.BigDecimal
-
 class Player(
     val name: String,
     private val betMoney: BetMoney,
@@ -29,18 +27,8 @@ class Player(
     }
 
     fun setProfitMoneyFromGameResult(result: GameResult) {
-        val betMoney = getBetMoneyFromGameResult(result)
-        profitMoney.set(betMoney)
-    }
-
-    private fun getBetMoneyFromGameResult(gameResult: GameResult): BigDecimal {
-        return when (gameResult) {
-            GameResult.BLACK_JACK -> betMoney.getAmountOnBlackJack()
-            GameResult.WIN -> betMoney.getOriginalBetAmount()
-            GameResult.PUSH -> betMoney.getOriginalBetAmount()
-            GameResult.LOSE -> betMoney.getAmountOnLose()
-            GameResult.BUST -> betMoney.getAmountOnBust()
-        }
+        val betMoneyAmount = result.getBetMoneyAmount(betMoney)
+        profitMoney.set(betMoneyAmount)
     }
 
     private fun shouldContinueDrawing(isDrawCard: (String) -> Boolean): Boolean {

From 4a2a26803d0b72c91bc51abfcc5d6281959143fe Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Tue, 17 Dec 2024 11:38:20 +0900
Subject: [PATCH 28/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep4]=20ResultManager=20=EC=83=9D=EC=84=B1=EC=9E=90=20=EC=A3=BC?=
 =?UTF-8?q?=EC=9E=85=EC=97=90=EC=84=9C=20=EB=A9=94=EC=84=9C=EB=93=9C?=
 =?UTF-8?q?=EC=A3=BC=EC=9E=85=EC=9C=BC=EB=A1=9C=20=EB=B3=80=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../kotlin/blackjack/controller/BlackJackController.kt     | 2 +-
 src/main/kotlin/blackjack/domain/BlackJackResultManager.kt | 7 ++-----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/main/kotlin/blackjack/controller/BlackJackController.kt b/src/main/kotlin/blackjack/controller/BlackJackController.kt
index b9615fb29..e45641baf 100644
--- a/src/main/kotlin/blackjack/controller/BlackJackController.kt
+++ b/src/main/kotlin/blackjack/controller/BlackJackController.kt
@@ -60,7 +60,7 @@ object BlackJackController {
         players.onEach { player ->
             ResultView.printFinalScoresForPlayer(player)
         }
-        val result = BlackJackResultManager(dealer, players).getResult()
+        val result = BlackJackResultManager.getResult(dealer, players)
         ResultView.printFinalProfit(result)
     }
 }
diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 48ee8365e..6f9b2b176 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -1,10 +1,7 @@
 package blackjack.domain
 
-class BlackJackResultManager(
-    private val dealer: Dealer,
-    private val players: Players,
-) {
-    fun getResult(): BlackJackResult {
+object BlackJackResultManager {
+    fun getResult(dealer: Dealer, players: Players): BlackJackResult {
         val playersProfits = players.getPlayersToProfitMoney(
             getGameResult = { player -> player.getGameResultWith(dealer) },
             onSetPlayerProfitMoney = { profitMoney -> dealer.adjustProfit(profitMoney) }

From 7c8140494164697c0842334c9532de3073e3d016 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Thu, 19 Dec 2024 23:27:04 +0900
Subject: [PATCH 29/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep4]=20=EC=9D=BC=EB=B6=80=20=EA=B5=AC=EC=A1=B0=20=EB=B3=80?=
 =?UTF-8?q?=EA=B2=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/BetMoney.kt  | 20 ++++++--
 .../domain/BlackJackResultManager.kt          | 17 ++++---
 src/main/kotlin/blackjack/domain/Dealer.kt    |  5 --
 .../kotlin/blackjack/domain/GameResult.kt     | 27 +++++-----
 src/main/kotlin/blackjack/domain/Player.kt    | 13 ++---
 src/main/kotlin/blackjack/domain/Players.kt   | 19 ++++---
 .../kotlin/blackjack/domain/DealerTest.kt     | 15 ------
 .../kotlin/blackjack/domain/GameResultTest.kt | 51 +++++++++++--------
 .../kotlin/blackjack/domain/PlayerTest.kt     | 20 ++++----
 9 files changed, 96 insertions(+), 91 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BetMoney.kt b/src/main/kotlin/blackjack/domain/BetMoney.kt
index c3054ee60..aaeb33765 100644
--- a/src/main/kotlin/blackjack/domain/BetMoney.kt
+++ b/src/main/kotlin/blackjack/domain/BetMoney.kt
@@ -1,23 +1,35 @@
 package blackjack.domain
 
+import blackjack.domain.GameResult.*
 import java.math.BigDecimal
 import java.math.RoundingMode
 
 @JvmInline
 value class BetMoney(private val amount: BigDecimal) {
-    fun getOriginalBetAmount(): BigDecimal {
+    fun getAmount(gameResult: GameResult): BigDecimal {
+        return when (gameResult) {
+            BLACK_JACK -> getAmountOnBlackJack()
+            WIN -> getOriginalBetAmount()
+            PUSH -> getOriginalBetAmount()
+            LOSE -> getAmountOnLose()
+            BUST -> getAmountOnBust()
+        }
+    }
+
+    private fun getOriginalBetAmount(): BigDecimal {
         return amount
     }
 
-    fun getAmountOnBlackJack(): BigDecimal {
+    private fun getAmountOnBlackJack(): BigDecimal {
         return amount.multiply((1.5).toBigDecimal()).setScale(0, RoundingMode.DOWN)
     }
 
-    fun getAmountOnBust(): BigDecimal {
+    private fun getAmountOnBust(): BigDecimal {
         return -(amount)
     }
 
-    fun getAmountOnLose(): BigDecimal {
+    private fun getAmountOnLose(): BigDecimal {
         return -(amount)
     }
+
 }
diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index 6f9b2b176..e1600f17d 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -1,18 +1,23 @@
 package blackjack.domain
 
+import java.math.BigDecimal
+
 object BlackJackResultManager {
     fun getResult(dealer: Dealer, players: Players): BlackJackResult {
         val playersProfits = players.getPlayersToProfitMoney(
-            getGameResult = { player -> player.getGameResultWith(dealer) },
-            onSetPlayerProfitMoney = { profitMoney -> dealer.adjustProfit(profitMoney) }
+            dealer.isBlackJackInitially,
+            dealer.cardsSum
         )
-        return BlackJackResult(dealer.profitMoney, playersProfits)
+        return BlackJackResult(playersProfits)
     }
 }
 
 data class BlackJackResult(
-    val dealerProfitMoney: ProfitMoney,
     val playerToProfit: PlayerToProfitMoney,
-)
+) {
+    val dealerProfitMoney: ProfitMoney get() = ProfitMoney().apply { set(-playerToProfit.getAllProfitSum) }
+}
 
-data class PlayerToProfitMoney(val value: Map<Player, ProfitMoney>)
+data class PlayerToProfitMoney(val value: Map<Player, ProfitMoney>) {
+    val getAllProfitSum: BigDecimal get() = value.values.sumOf { it.getCurrentProfit() }
+}
diff --git a/src/main/kotlin/blackjack/domain/Dealer.kt b/src/main/kotlin/blackjack/domain/Dealer.kt
index dc35fafe4..2357cb68d 100644
--- a/src/main/kotlin/blackjack/domain/Dealer.kt
+++ b/src/main/kotlin/blackjack/domain/Dealer.kt
@@ -39,11 +39,6 @@ class Dealer(
         return cards.value[0]
     }
 
-    fun adjustProfit(playerProfit: ProfitMoney) {
-        val profit = profitMoney.getCurrentProfit() - playerProfit.getCurrentProfit()
-        profitMoney.set(profit)
-    }
-
     companion object {
         private const val DEALER_CARD_COUNT = 2
         private const val DEALER_DRAW_ONE_MORE_CARD_THRESHOLD = 16
diff --git a/src/main/kotlin/blackjack/domain/GameResult.kt b/src/main/kotlin/blackjack/domain/GameResult.kt
index d563fdf29..bd0bd9106 100644
--- a/src/main/kotlin/blackjack/domain/GameResult.kt
+++ b/src/main/kotlin/blackjack/domain/GameResult.kt
@@ -1,7 +1,5 @@
 package blackjack.domain
 
-import java.math.BigDecimal
-
 enum class GameResult {
     WIN,
     BUST,
@@ -10,18 +8,21 @@ enum class GameResult {
     BLACK_JACK,
     ;
 
-    fun getBetMoneyAmount(betMoney: BetMoney): BigDecimal {
-        return when (this) {
-            BLACK_JACK -> betMoney.getAmountOnBlackJack()
-            WIN -> betMoney.getOriginalBetAmount()
-            PUSH -> betMoney.getOriginalBetAmount()
-            LOSE -> betMoney.getAmountOnLose()
-            BUST -> betMoney.getAmountOnBust()
+    companion object {
+        fun getGameResultsWith(
+            isPlayerBlackJackInitially: Boolean,
+            isDealerBlackJackInitially: Boolean,
+            dealerCardSum: Int,
+            playerCardSum: Int,
+        ): GameResult {
+            return when {
+                isPlayerBlackJackInitially && isDealerBlackJackInitially.not() -> BLACK_JACK
+                isPlayerBlackJackInitially && isDealerBlackJackInitially -> PUSH
+                else -> fromScores(dealerCardSum, playerCardSum)
+            }
         }
-    }
 
-    companion object {
-        fun fromScores(
+        private fun fromScores(
             dealerScore: Int,
             playerScore: Int,
         ): GameResult {
@@ -34,4 +35,4 @@ enum class GameResult {
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 95942d25b..7326f8ddc 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -18,17 +18,10 @@ class Player(
         onExitPlay()
     }
 
-    fun getGameResultWith(dealer: Dealer): GameResult {
-        return when {
-            this.isBlackJackInitially && dealer.isBlackJackInitially.not() -> GameResult.BLACK_JACK
-            this.isBlackJackInitially && dealer.isBlackJackInitially -> GameResult.PUSH
-            else -> GameResult.fromScores(dealer.cardsSum, this.cardsSum)
-        }
-    }
-
-    fun setProfitMoneyFromGameResult(result: GameResult) {
-        val betMoneyAmount = result.getBetMoneyAmount(betMoney)
+    fun getProfitMoney(gameResult: GameResult): ProfitMoney {
+        val betMoneyAmount = betMoney.getAmount(gameResult)
         profitMoney.set(betMoneyAmount)
+        return profitMoney
     }
 
     private fun shouldContinueDrawing(isDrawCard: (String) -> Boolean): Boolean {
diff --git a/src/main/kotlin/blackjack/domain/Players.kt b/src/main/kotlin/blackjack/domain/Players.kt
index 5b5838006..8c8a5330d 100644
--- a/src/main/kotlin/blackjack/domain/Players.kt
+++ b/src/main/kotlin/blackjack/domain/Players.kt
@@ -17,16 +17,19 @@ data class Players(val value: List<Player>) {
     }
 
     fun getPlayersToProfitMoney(
-        getGameResult: (Player) -> GameResult,
-        onSetPlayerProfitMoney: (ProfitMoney) -> Unit
+        isDealerBlackJack: Boolean,
+        dealerCardSum: Int,
     ): PlayerToProfitMoney {
-        val map =
+        return PlayerToProfitMoney(
             value.associateWith { player ->
-                val gameResult = getGameResult(player)
-                player.setProfitMoneyFromGameResult(gameResult)
-                onSetPlayerProfitMoney(player.profitMoney)
-                player.profitMoney
+                val gameResult = GameResult.getGameResultsWith(
+                    isPlayerBlackJackInitially = player.isBlackJackInitially,
+                    isDealerBlackJackInitially = isDealerBlackJack,
+                    dealerCardSum = dealerCardSum,
+                    playerCardSum = player.cardsSum
+                )
+                player.getProfitMoney(gameResult)
             }
-        return PlayerToProfitMoney(map)
+        )
     }
 }
diff --git a/src/test/kotlin/blackjack/domain/DealerTest.kt b/src/test/kotlin/blackjack/domain/DealerTest.kt
index c48c00c81..00f6a85a0 100644
--- a/src/test/kotlin/blackjack/domain/DealerTest.kt
+++ b/src/test/kotlin/blackjack/domain/DealerTest.kt
@@ -56,19 +56,4 @@ class DealerTest {
         // then
         assertThat(card).isSameAs(firstCard)
     }
-
-    @Test
-    @DisplayName("플레이어가 10000원 만큼 얻었다면 딜러는 최초 총 베팅 금액에서 10000원을 차감한 금액을 갖는다")
-    fun `when player gains 10000, dealer loses 10000`() {
-        // given
-        val dealer = Dealer(drawCard = { Card(Rank.TWO, Suit.HEARTS) })
-        val totalBet = BigDecimal(30000)
-        dealer.profitMoney.set(totalBet)
-
-        // when
-        dealer.adjustProfit(playerProfit = ProfitMoney().apply { set(BigDecimal(10000)) })
-
-        // then
-        assertThat(dealer.profitMoney.getCurrentProfit()).isEqualTo(BigDecimal(20000))
-    }
 }
diff --git a/src/test/kotlin/blackjack/domain/GameResultTest.kt b/src/test/kotlin/blackjack/domain/GameResultTest.kt
index 425b364fa..e84e68f6e 100644
--- a/src/test/kotlin/blackjack/domain/GameResultTest.kt
+++ b/src/test/kotlin/blackjack/domain/GameResultTest.kt
@@ -3,31 +3,42 @@ package blackjack.domain
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.CsvSource
+import org.junit.jupiter.params.provider.MethodSource
 
 class GameResultTest {
     @DisplayName("딜러와 플레이어 점수가 주어졌을 때 게임 결과를 알맞게 반환한다")
-    @ParameterizedTest(name = "{index} => dealerScore={0}, playerScore={1}, expectedResult={2}")
-    @CsvSource(
-        // Dealer == Bust, Player 승리
-        "22, 20, WIN",
-        // Player == Bust, Dealer 승리
-        "20, 22, BUST",
-        // 둘다 Bust 아닐때 Player 점수가 높으면, Player 승리
-        "18, 19, WIN",
-        // 둘다 Bust 아닐때 Dealer 점수가 높으면, Dealer 승리
-        "19, 18, LOSE",
-    )
-    fun getGameResultFromDealerAndPlayerScores(
-        dealerScore: Int,
-        playerScore: Int,
-        expectedResult: GameResult,
+    @ParameterizedTest
+    @MethodSource("gameResultProvider")
+    fun testGetGameResultsWith(
+        isPlayerBlackJackInitially: Boolean,
+        isDealerBlackJackInitially: Boolean,
+        dealerCardSum: Int,
+        playerCardSum: Int,
+        expected: GameResult,
     ) {
-        val result =
-            GameResult.fromScores(
-                dealerScore = dealerScore,
-                playerScore = playerScore,
+        val result = GameResult.getGameResultsWith(
+            isPlayerBlackJackInitially,
+            isDealerBlackJackInitially,
+            dealerCardSum,
+            playerCardSum
+        )
+        assertEquals(expected, result)
+    }
+
+    companion object {
+        @JvmStatic
+        fun gameResultProvider(): List<Arguments> {
+            return listOf(
+                Arguments.of(true, false, 20, 21, GameResult.BLACK_JACK),
+                Arguments.of(true, true, 21, 21, GameResult.PUSH),
+                Arguments.of(false, false, 22, 18, GameResult.WIN),
+                Arguments.of(false, false, 20, 22, GameResult.BUST),
+                Arguments.of(false, false, 20, 19, GameResult.LOSE),
+                Arguments.of(false, false, 19, 20, GameResult.WIN),
+                Arguments.of(false, false, 20, 20, GameResult.PUSH)
             )
-        assertEquals(expectedResult, result)
+        }
     }
 }
diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index ee576a868..8ecf0a998 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -53,10 +53,10 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        player.setProfitMoneyFromGameResult(GameResult.BUST)
+        val profit = player.getProfitMoney(GameResult.BUST)
 
         // Then
-        assertEquals(BigDecimal(-10000), player.profitMoney.getCurrentProfit())
+        assertEquals(BigDecimal(-10000), profit)
     }
 
     @Test
@@ -66,10 +66,10 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        player.setProfitMoneyFromGameResult(GameResult.WIN)
+        val profit = player.getProfitMoney(GameResult.WIN)
 
         // Then
-        assertEquals(BigDecimal(10000), player.profitMoney.getCurrentProfit())
+        assertEquals(BigDecimal(10000), profit)
     }
 
     @Test
@@ -79,10 +79,10 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        player.setProfitMoneyFromGameResult(GameResult.LOSE)
+        val profit = player.getProfitMoney(GameResult.LOSE)
 
         // Then
-        assertEquals(BigDecimal(-10000), player.profitMoney.getCurrentProfit())
+        assertEquals(BigDecimal(-10000), profit)
     }
 
     @Test
@@ -92,10 +92,10 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        player.setProfitMoneyFromGameResult(GameResult.PUSH)
+        val profit = player.getProfitMoney(GameResult.PUSH)
 
         // Then
-        assertEquals(BigDecimal(10000), player.profitMoney.getCurrentProfit())
+        assertEquals(BigDecimal(10000), profit)
     }
 
     @Test
@@ -113,10 +113,10 @@ class PlayerTest {
         val player = initBlackJackPlayer()
 
         // When
-        player.setProfitMoneyFromGameResult(GameResult.BLACK_JACK)
+        val profit = player.getProfitMoney(GameResult.BLACK_JACK)
 
         // Then
-        assertEquals(BigDecimal(15000), player.profitMoney.getCurrentProfit())
+        assertEquals(BigDecimal(15000), profit)
     }
 
     private fun initFakePlayer(): Player {

From 3c5be6dca4aaefdd4fb84a6d0581982db46dc1f2 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Thu, 19 Dec 2024 23:28:30 +0900
Subject: [PATCH 30/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep4]=20profitMoney=20=EB=8A=94=20Player=20=EA=B0=80=20=EA=B4=80?=
 =?UTF-8?q?=EB=A6=AC=ED=95=98=EB=8F=84=EB=A1=9D=20=ED=95=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/Participant.kt | 1 -
 src/main/kotlin/blackjack/domain/Player.kt      | 2 ++
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/blackjack/domain/Participant.kt b/src/main/kotlin/blackjack/domain/Participant.kt
index b23901a28..9ff1f98d1 100644
--- a/src/main/kotlin/blackjack/domain/Participant.kt
+++ b/src/main/kotlin/blackjack/domain/Participant.kt
@@ -6,7 +6,6 @@ abstract class Participant(
     private val _cards = mutableListOf<Card>()
     val cards: Cards = Cards(_cards)
     val cardsSum: Int get() = cards.sumValues()
-    val profitMoney: ProfitMoney = ProfitMoney()
     val isBlackJackInitially: Boolean
 
     init {
diff --git a/src/main/kotlin/blackjack/domain/Player.kt b/src/main/kotlin/blackjack/domain/Player.kt
index 7326f8ddc..78d75896e 100644
--- a/src/main/kotlin/blackjack/domain/Player.kt
+++ b/src/main/kotlin/blackjack/domain/Player.kt
@@ -5,6 +5,8 @@ class Player(
     private val betMoney: BetMoney,
     private val drawCard: () -> Card,
 ) : Participant(drawCard = drawCard) {
+    private val profitMoney: ProfitMoney = ProfitMoney()
+
     fun play(
         isDrawCard: (String) -> Boolean,
         onDrawCard: () -> Unit,

From 223331d3b8012798a7c668b07b4493c5c8b9c263 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Thu, 19 Dec 2024 23:29:35 +0900
Subject: [PATCH 31/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep4]=20lint?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/main/kotlin/blackjack/domain/BetMoney.kt     |  1 -
 .../blackjack/domain/BlackJackResultManager.kt   | 14 +++++++++-----
 src/main/kotlin/blackjack/domain/GameResult.kt   |  2 +-
 src/main/kotlin/blackjack/domain/Players.kt      | 15 ++++++++-------
 .../kotlin/blackjack/domain/GameResultTest.kt    | 16 ++++++++--------
 5 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/src/main/kotlin/blackjack/domain/BetMoney.kt b/src/main/kotlin/blackjack/domain/BetMoney.kt
index aaeb33765..876edb863 100644
--- a/src/main/kotlin/blackjack/domain/BetMoney.kt
+++ b/src/main/kotlin/blackjack/domain/BetMoney.kt
@@ -31,5 +31,4 @@ value class BetMoney(private val amount: BigDecimal) {
     private fun getAmountOnLose(): BigDecimal {
         return -(amount)
     }
-
 }
diff --git a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
index e1600f17d..005747360 100644
--- a/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
+++ b/src/main/kotlin/blackjack/domain/BlackJackResultManager.kt
@@ -3,11 +3,15 @@ package blackjack.domain
 import java.math.BigDecimal
 
 object BlackJackResultManager {
-    fun getResult(dealer: Dealer, players: Players): BlackJackResult {
-        val playersProfits = players.getPlayersToProfitMoney(
-            dealer.isBlackJackInitially,
-            dealer.cardsSum
-        )
+    fun getResult(
+        dealer: Dealer,
+        players: Players,
+    ): BlackJackResult {
+        val playersProfits =
+            players.getPlayersToProfitMoney(
+                dealer.isBlackJackInitially,
+                dealer.cardsSum,
+            )
         return BlackJackResult(playersProfits)
     }
 }
diff --git a/src/main/kotlin/blackjack/domain/GameResult.kt b/src/main/kotlin/blackjack/domain/GameResult.kt
index bd0bd9106..de5eabb79 100644
--- a/src/main/kotlin/blackjack/domain/GameResult.kt
+++ b/src/main/kotlin/blackjack/domain/GameResult.kt
@@ -35,4 +35,4 @@ enum class GameResult {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/blackjack/domain/Players.kt b/src/main/kotlin/blackjack/domain/Players.kt
index 8c8a5330d..b12d6b553 100644
--- a/src/main/kotlin/blackjack/domain/Players.kt
+++ b/src/main/kotlin/blackjack/domain/Players.kt
@@ -22,14 +22,15 @@ data class Players(val value: List<Player>) {
     ): PlayerToProfitMoney {
         return PlayerToProfitMoney(
             value.associateWith { player ->
-                val gameResult = GameResult.getGameResultsWith(
-                    isPlayerBlackJackInitially = player.isBlackJackInitially,
-                    isDealerBlackJackInitially = isDealerBlackJack,
-                    dealerCardSum = dealerCardSum,
-                    playerCardSum = player.cardsSum
-                )
+                val gameResult =
+                    GameResult.getGameResultsWith(
+                        isPlayerBlackJackInitially = player.isBlackJackInitially,
+                        isDealerBlackJackInitially = isDealerBlackJack,
+                        dealerCardSum = dealerCardSum,
+                        playerCardSum = player.cardsSum,
+                    )
                 player.getProfitMoney(gameResult)
-            }
+            },
         )
     }
 }
diff --git a/src/test/kotlin/blackjack/domain/GameResultTest.kt b/src/test/kotlin/blackjack/domain/GameResultTest.kt
index e84e68f6e..282829295 100644
--- a/src/test/kotlin/blackjack/domain/GameResultTest.kt
+++ b/src/test/kotlin/blackjack/domain/GameResultTest.kt
@@ -4,7 +4,6 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
-import org.junit.jupiter.params.provider.CsvSource
 import org.junit.jupiter.params.provider.MethodSource
 
 class GameResultTest {
@@ -18,12 +17,13 @@ class GameResultTest {
         playerCardSum: Int,
         expected: GameResult,
     ) {
-        val result = GameResult.getGameResultsWith(
-            isPlayerBlackJackInitially,
-            isDealerBlackJackInitially,
-            dealerCardSum,
-            playerCardSum
-        )
+        val result =
+            GameResult.getGameResultsWith(
+                isPlayerBlackJackInitially,
+                isDealerBlackJackInitially,
+                dealerCardSum,
+                playerCardSum,
+            )
         assertEquals(expected, result)
     }
 
@@ -37,7 +37,7 @@ class GameResultTest {
                 Arguments.of(false, false, 20, 22, GameResult.BUST),
                 Arguments.of(false, false, 20, 19, GameResult.LOSE),
                 Arguments.of(false, false, 19, 20, GameResult.WIN),
-                Arguments.of(false, false, 20, 20, GameResult.PUSH)
+                Arguments.of(false, false, 20, 20, GameResult.PUSH),
             )
         }
     }

From fde1866a3d5d3b341f09accd63a2b331cafd91b4 Mon Sep 17 00:00:00 2001
From: Sara Han <sarahan774@gmail.com>
Date: Thu, 19 Dec 2024 23:32:47 +0900
Subject: [PATCH 32/32] =?UTF-8?q?[=EC=BD=94=EB=93=9C=EB=A6=AC=EB=B7=B0][st?=
 =?UTF-8?q?ep4]=20test=20=EC=98=A4=EB=A5=98=20=EC=88=98=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/test/kotlin/blackjack/domain/PlayerTest.kt | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/test/kotlin/blackjack/domain/PlayerTest.kt b/src/test/kotlin/blackjack/domain/PlayerTest.kt
index 8ecf0a998..00e442efd 100644
--- a/src/test/kotlin/blackjack/domain/PlayerTest.kt
+++ b/src/test/kotlin/blackjack/domain/PlayerTest.kt
@@ -53,7 +53,7 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        val profit = player.getProfitMoney(GameResult.BUST)
+        val profit = player.getProfitMoney(GameResult.BUST).getCurrentProfit()
 
         // Then
         assertEquals(BigDecimal(-10000), profit)
@@ -66,7 +66,7 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        val profit = player.getProfitMoney(GameResult.WIN)
+        val profit = player.getProfitMoney(GameResult.WIN).getCurrentProfit()
 
         // Then
         assertEquals(BigDecimal(10000), profit)
@@ -79,7 +79,7 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        val profit = player.getProfitMoney(GameResult.LOSE)
+        val profit = player.getProfitMoney(GameResult.LOSE).getCurrentProfit()
 
         // Then
         assertEquals(BigDecimal(-10000), profit)
@@ -92,7 +92,7 @@ class PlayerTest {
         val player = initFakePlayer()
 
         // When
-        val profit = player.getProfitMoney(GameResult.PUSH)
+        val profit = player.getProfitMoney(GameResult.PUSH).getCurrentProfit()
 
         // Then
         assertEquals(BigDecimal(10000), profit)
@@ -113,7 +113,7 @@ class PlayerTest {
         val player = initBlackJackPlayer()
 
         // When
-        val profit = player.getProfitMoney(GameResult.BLACK_JACK)
+        val profit = player.getProfitMoney(GameResult.BLACK_JACK).getCurrentProfit()
 
         // Then
         assertEquals(BigDecimal(15000), profit)