diff --git a/README.md b/README.md index 2f845848790..d08ad3c6ef4 100644 --- a/README.md +++ b/README.md @@ -20,17 +20,28 @@ - [x] 버스트인 사람 패배 - 둘다 버스트인 경우 - [x] 무승부 +- [x] 수익 계산 + - [x] 플레이어는 승리시 배팅금액 만큼 수익을 얻는다. + - [x] 플레이어가 블랙잭인지 판단할 수 있다. + - 처음 받은 2개의 카드가 21인 경우 블랙잭으로 판단 + - [x] 참가자가 블랙잭인 경우 배팅금액의 1.5배 수익을 얻는다. + - [x] 플레이어는 패배시 배팅금액 만큼 손해를 본다 + - [x] 플레이어는 무승부시 배팅금액 만큼 수익도 손해도 보지 않는다. + - [x] 딜러는 플레이어들이 패배한 금액 만큼 수익을 얻는다. + - [x] 딜러는 플레이어들이 승리한 금액 만큼 손해를 본다. - [x] 게임진행 - [x] 초기 시작시 인당 카드 2장씩 지급 - [x] 참가자 한명이 버스트가 되거나 카드를 안받는다 선택한 경우 다음 참가자 차례로 넘어감 - [x] 마지막 참가자가 버스트가 되거나 카드를 안받을 경우 게임 종료 - [x] 전체 플레이어 승패 결과 계산 + - [x] 전체 참가자 수익 계산 -[x] 입력 - [x] 게임 참가자 이름 입력 + - [x] 게임 배팅 금액 입력 - [x] 카드 더받기 유무 입력 - [x] 출력 - [x] 분배 받은 카드 목록 출력 - [x] 딜러와 참가자 카드 합계 결과 출력 - - [x] 최종 승패 결과 출력 \ No newline at end of file + - [x] 최종 수익 출력 \ No newline at end of file diff --git a/src/main/java/blackjack/controller/BlackjackController.java b/src/main/java/blackjack/controller/BlackjackController.java index 861c8653bb7..e82f2ec8bde 100644 --- a/src/main/java/blackjack/controller/BlackjackController.java +++ b/src/main/java/blackjack/controller/BlackjackController.java @@ -3,16 +3,16 @@ import blackjack.domain.Dealer; import blackjack.domain.GameResult; import blackjack.domain.Player; -import blackjack.domain.PlayerCardsName; -import blackjack.domain.PlayerFinalCardsScore; -import blackjack.domain.PlayerFinalResult; -import blackjack.domain.ScoreCompareResult; +import blackjack.dto.PlayerCardsName; +import blackjack.dto.PlayerFinalCardsScore; +import blackjack.dto.PlayerProfitResult; +import blackjack.domain.ProfitResults; import blackjack.service.CardDistributor; import blackjack.service.Game; import blackjack.utils.InputParser; import blackjack.utils.RetryInput; +import java.math.BigDecimal; import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -20,18 +20,16 @@ import blackjack.view.OutputView; public class BlackjackController { - private final CardDistributor cardDistributor; - private final Game game; private static final RetryInput retryInput = new RetryInput(); + private final CardDistributor cardDistributor; public BlackjackController(CardDistributor cardDistributor) { this.cardDistributor = cardDistributor; - this.game = new Game(cardDistributor); } public void startGame() { List playerNames = getPlayerNames(); - List players = getPlayers(playerNames); + List players = createPlayersWithBettingAmounts(playerNames); Dealer dealer = new Dealer(); setupInitialHand(players, dealer, playerNames); // 2장씩 카드 분배 @@ -39,8 +37,10 @@ public void startGame() { processTurn(players); // 플레이어 hit or stand playDealerTurn(dealer); + Game game = new Game(players, dealer); + calculateFinalScore(players, dealer); - calculateFinalGameResult(players, dealer); + calculateFinalGameProfitResult(game); } private void setupInitialHand(List players, Dealer dealer, List playerNames) { @@ -55,20 +55,22 @@ private static List getPlayerNames() { ); } - private void calculateFinalGameResult(List players, Dealer dealer) { - GameResult gameResult = game.judgeTotalGameResult(players, dealer); - Map dealerResult = gameResult.dealerResult(); + private void calculateFinalGameProfitResult(Game game) { + GameResult gameResult = game.judgeTotalGameResult(); + ProfitResults profitResults = game.calculateTotalProfitResults(gameResult); + + BigDecimal dealerProfit = profitResults.dealerProfit(); + Map playerProfit = profitResults.playerProfit(); - LinkedHashMap playerResult = gameResult.playerResults(); - List playerNameResult = new ArrayList<>(); - for (Entry entry : playerResult.entrySet()) { - playerNameResult.add(new PlayerFinalResult(entry.getKey().getName(), entry.getValue())); + List playerNameProfitResult = new ArrayList<>(); + for (Entry entry : playerProfit.entrySet()) { + playerNameProfitResult.add(PlayerProfitResult.from(entry.getKey(), entry.getValue())); } - OutputView.printFinalResult(dealerResult, playerNameResult); + OutputView.printFinalProfitResult(dealerProfit, playerNameProfitResult); } private void playDealerTurn(Dealer dealer) { - game.dealerDrawsCardsUntilDone(dealer); + cardDistributor.distributeCardsToDealerUntilScoreAtLeast(dealer); OutputView.printDealerCardDrawnResult(dealer.getAdditionalDrawnCardCount()); } @@ -85,12 +87,15 @@ private void processPlayerTurn(Player player) { } private boolean canContinueTurn(Player player) { + if (player.isBust()) { + return false; + } String hitOrStand = InputView.askHitOrStand(player.getName()); - return isHit(hitOrStand) && !player.isBust(); + return isHit(hitOrStand); } private void drawCard(Player player) { - cardDistributor.distributeCardToPlayer(player); + cardDistributor.distributeCardsToParticipant(player, 1); OutputView.printDrawnCards(player.getName(), player.getCardNames()); } @@ -102,10 +107,12 @@ private static void printInitialCards(List players, Dealer dealer) { OutputView.printAllUserCards(playersCardsName, dealer.getOneCardName()); } - private List getPlayers(List playerNames) { + private List createPlayersWithBettingAmounts(List playerNames) { List players = new ArrayList<>(); for (String playerName : playerNames) { - players.add(new Player(playerName)); + BigDecimal bettingAmount = retryInput.read( + () -> InputParser.parseBetAmount(InputView.askToPlayerBettingAmount(playerName))); + players.add(new Player(playerName, bettingAmount)); } return players; } @@ -125,9 +132,9 @@ private void calculateFinalScore(List players, Dealer dealer) { private void distributeInitialCards(List players, Dealer dealer) { for (Player player : players) { - cardDistributor.distributeTwoCardsToPlayer(player); + cardDistributor.distributeCardsToParticipant(player, 2); } - cardDistributor.distributeTwoCardsToDealer(dealer); + cardDistributor.distributeCardsToParticipant(dealer, 2); } private boolean isHit(String hitOrStand) { @@ -139,5 +146,4 @@ private boolean isHit(String hitOrStand) { } throw new IllegalArgumentException("잘못된 입력입니다. y 또는 n을 입력해주세요"); } - } diff --git a/src/main/java/blackjack/domain/Card.java b/src/main/java/blackjack/domain/Card.java index 32dc033ac68..92ce368c3d8 100644 --- a/src/main/java/blackjack/domain/Card.java +++ b/src/main/java/blackjack/domain/Card.java @@ -1,46 +1,17 @@ package blackjack.domain; -public record Card(String rank, String shape) { +public record Card(Rank rank, Shape shape) { public String getDisplayName() { - return rank + shape; + return rank.getName() + shape.getName(); } public int translateToScore() { - if (rank.equals("J") || rank.equals("Q") || rank.equals("K")) { - return 10; - } - if (rank.equals("A")) { - return 11; - } - - return convertToNumber(rank); - } - - private static int convertToNumber(String rank) { - int score; - try { - score = Integer.parseInt(rank); - } catch (IllegalArgumentException e) { - throw new IllegalArgumentException("J,Q,K 외의 문자열 입력은 불가능합니다."); - } - - if (score > 10 || score < 2) { - throw new IllegalArgumentException("2~10 사이의 숫자만 가능합니다."); - } - return score; + return rank.getScore(); } - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (!(o instanceof Card card)) { - return false; - } - return rank.equals(card.rank) && - shape.equals(card.shape); + public boolean isAce() { + return rank == Rank.ACE; } } diff --git a/src/main/java/blackjack/domain/Cards.java b/src/main/java/blackjack/domain/Cards.java index 75989eec445..157a33c837b 100644 --- a/src/main/java/blackjack/domain/Cards.java +++ b/src/main/java/blackjack/domain/Cards.java @@ -41,13 +41,11 @@ public List getCardNames() { return cardNames; } + public int getCardCount() { + return cards.size(); + } + private int countAces() { - int count = 0; - for (Card card : cards) { - if (card.rank().equals("A")) { - count++; - } - } - return count; + return (int) cards.stream().filter(Card::isAce).count(); } } \ No newline at end of file diff --git a/src/main/java/blackjack/domain/Participant.java b/src/main/java/blackjack/domain/Participant.java index af62a9f4d14..9b4b4d9dfd1 100644 --- a/src/main/java/blackjack/domain/Participant.java +++ b/src/main/java/blackjack/domain/Participant.java @@ -4,6 +4,8 @@ public abstract class Participant { private static final int BUST_SCORE = 21; + private static final int BLACKJACK_SCORE = 21; + private static final int BLACKJACK_CARD_COUNT = 2; private final Cards drawnCards; @@ -26,4 +28,11 @@ public boolean isBust() { public int calculateTotalScore() { return drawnCards.sumScore(); } + + public boolean isBlackjack() { + if (drawnCards.getCardCount() != BLACKJACK_CARD_COUNT) { + return false; + } + return drawnCards.sumScore() == BLACKJACK_SCORE; + } } diff --git a/src/main/java/blackjack/domain/Player.java b/src/main/java/blackjack/domain/Player.java index dec8a1a9d54..d09a9395e3a 100644 --- a/src/main/java/blackjack/domain/Player.java +++ b/src/main/java/blackjack/domain/Player.java @@ -1,15 +1,41 @@ package blackjack.domain; +import java.math.BigDecimal; + public class Player extends Participant { + private static final BigDecimal BLACKJACK_PROFIT_RATE = BigDecimal.valueOf(1.5); + private final String name; + private final BigDecimal bettingAmount; public Player(String name) { + this(name, BigDecimal.valueOf(0)); + } + + public Player(String name, BigDecimal bettingAmount) { this.name = name; + this.bettingAmount = bettingAmount; } public String getName() { return name; } + public BigDecimal calculateProfit(ScoreCompareResult compareResult) { + if (compareResult == ScoreCompareResult.PLAYER_WIN) { + return calculateProfitWhenPlayerWins(); + } + if (compareResult == ScoreCompareResult.PLAYER_LOSE) { + return bettingAmount.negate(); + } + return BigDecimal.ZERO; + } + + private BigDecimal calculateProfitWhenPlayerWins() { + if (isBlackjack()) { + return (bettingAmount.multiply(BLACKJACK_PROFIT_RATE)); + } + return bettingAmount; + } } diff --git a/src/main/java/blackjack/domain/PlayerFinalResult.java b/src/main/java/blackjack/domain/PlayerFinalResult.java deleted file mode 100644 index e8961d583ef..00000000000 --- a/src/main/java/blackjack/domain/PlayerFinalResult.java +++ /dev/null @@ -1,5 +0,0 @@ -package blackjack.domain; - -public record PlayerFinalResult(String name, ScoreCompareResult scoreCompareResult) { - -} diff --git a/src/main/java/blackjack/domain/ProfitResults.java b/src/main/java/blackjack/domain/ProfitResults.java new file mode 100644 index 00000000000..e3e96af2381 --- /dev/null +++ b/src/main/java/blackjack/domain/ProfitResults.java @@ -0,0 +1,7 @@ +package blackjack.domain; + +import java.math.BigDecimal; +import java.util.Map; + +public record ProfitResults(BigDecimal dealerProfit, Map playerProfit) { +} \ No newline at end of file diff --git a/src/main/java/blackjack/domain/Rank.java b/src/main/java/blackjack/domain/Rank.java new file mode 100644 index 00000000000..0421c5ff3db --- /dev/null +++ b/src/main/java/blackjack/domain/Rank.java @@ -0,0 +1,33 @@ +package blackjack.domain; + +public enum Rank { + TWO("2", 2), + THREE("3", 3), + FOUR("4", 4), + FIVE("5", 5), + SIX("6", 6), + SEVEN("7", 7), + EIGHT("8", 8), + NINE("9", 9), + TEN("10", 10), + JACK("J", 10), + QUEEN("Q", 10), + KING("K", 10), + ACE("A", 11); + + private final String name; + private final int score; + + Rank(String name, int score) { + this.name = name; + this.score = score; + } + + public String getName() { + return name; + } + + public int getScore() { + return score; + } +} diff --git a/src/main/java/blackjack/domain/ScoreCompareResult.java b/src/main/java/blackjack/domain/ScoreCompareResult.java index d7553eefeb1..726cf9e3cd1 100644 --- a/src/main/java/blackjack/domain/ScoreCompareResult.java +++ b/src/main/java/blackjack/domain/ScoreCompareResult.java @@ -3,7 +3,7 @@ public enum ScoreCompareResult { PLAYER_WIN, DEALER_WIN, - PLAYER_LOSS, - DEALER_LOSS, + PLAYER_LOSE, + DEALER_LOSE, PUSH } diff --git a/src/main/java/blackjack/domain/Shape.java b/src/main/java/blackjack/domain/Shape.java new file mode 100644 index 00000000000..2d871615ddd --- /dev/null +++ b/src/main/java/blackjack/domain/Shape.java @@ -0,0 +1,18 @@ +package blackjack.domain; + +public enum Shape { + HEART("하트"), + DIAMOND("다이아몬드"), + CLUB("클로버"), + SPADE("스페이드"); + + private final String name; + + Shape(String name) { + this.name = name; + } + + public String getName() { + return name; + } +} diff --git a/src/main/java/blackjack/domain/PlayerCardsName.java b/src/main/java/blackjack/dto/PlayerCardsName.java similarity index 79% rename from src/main/java/blackjack/domain/PlayerCardsName.java rename to src/main/java/blackjack/dto/PlayerCardsName.java index cbb22683e3a..5355880d75c 100644 --- a/src/main/java/blackjack/domain/PlayerCardsName.java +++ b/src/main/java/blackjack/dto/PlayerCardsName.java @@ -1,4 +1,4 @@ -package blackjack.domain; +package blackjack.dto; import java.util.List; diff --git a/src/main/java/blackjack/domain/PlayerFinalCardsScore.java b/src/main/java/blackjack/dto/PlayerFinalCardsScore.java similarity index 82% rename from src/main/java/blackjack/domain/PlayerFinalCardsScore.java rename to src/main/java/blackjack/dto/PlayerFinalCardsScore.java index 5bdcd606297..b9bc4e8cb81 100644 --- a/src/main/java/blackjack/domain/PlayerFinalCardsScore.java +++ b/src/main/java/blackjack/dto/PlayerFinalCardsScore.java @@ -1,4 +1,4 @@ -package blackjack.domain; +package blackjack.dto; import java.util.List; diff --git a/src/main/java/blackjack/dto/PlayerProfitResult.java b/src/main/java/blackjack/dto/PlayerProfitResult.java new file mode 100644 index 00000000000..646fb81a6ad --- /dev/null +++ b/src/main/java/blackjack/dto/PlayerProfitResult.java @@ -0,0 +1,11 @@ +package blackjack.dto; + +import blackjack.domain.Player; +import java.math.BigDecimal; + +public record PlayerProfitResult(String playerName, BigDecimal profit) { + + public static PlayerProfitResult from(Player player, BigDecimal profit) { + return new PlayerProfitResult(player.getName(), profit); + } +} diff --git a/src/main/java/blackjack/service/CardDistributor.java b/src/main/java/blackjack/service/CardDistributor.java index ab63e7d2c9b..e415e944837 100644 --- a/src/main/java/blackjack/service/CardDistributor.java +++ b/src/main/java/blackjack/service/CardDistributor.java @@ -2,7 +2,7 @@ import blackjack.domain.Card; import blackjack.domain.Dealer; -import blackjack.domain.Player; +import blackjack.domain.Participant; public class CardDistributor { @@ -12,27 +12,16 @@ public CardDistributor(RandomCardPicker randomCardPicker) { this.randomCardPicker = randomCardPicker; } - public void distributeCardToPlayer(Player player) { - Card card = randomCardPicker.drawCard(); - player.receiveOneCard(card); - } - - public void distributeCardToDealer(Dealer dealer) { - Card card = randomCardPicker.drawCard(); - dealer.receiveOneCard(card); - } - - public void distributeTwoCardsToPlayer(Player player) { - for (int i = 0; i < 2; i++) { + public void distributeCardsToParticipant(Participant participant, int numberOfCards) { + for (int i = 0; i < numberOfCards; i++) { Card card = randomCardPicker.drawCard(); - player.receiveOneCard(card); + participant.receiveOneCard(card); } } - public void distributeTwoCardsToDealer(Dealer dealer) { - for (int i = 0; i < 2; i++) { - Card card = randomCardPicker.drawCard(); - dealer.receiveOneCard(card); + public void distributeCardsToDealerUntilScoreAtLeast(Dealer dealer) { + while (!dealer.isDealerDone()) { + distributeCardsToParticipant(dealer, 1); } } } diff --git a/src/main/java/blackjack/service/Game.java b/src/main/java/blackjack/service/Game.java index f2e9e10f4b8..70aadc43c6c 100644 --- a/src/main/java/blackjack/service/Game.java +++ b/src/main/java/blackjack/service/Game.java @@ -3,27 +3,25 @@ import blackjack.domain.Dealer; import blackjack.domain.GameResult; import blackjack.domain.Player; +import blackjack.domain.ProfitResults; import blackjack.domain.ScoreCompareResult; +import java.math.BigDecimal; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; public class Game { + private final List players; + private final Dealer dealer; - private final CardDistributor cardDistributor; - public Game(CardDistributor cardDistributor) { - this.cardDistributor = cardDistributor; + public Game(List players, Dealer dealer) { + this.players = players; + this.dealer = dealer; } - public void dealerDrawsCardsUntilDone(Dealer dealer) { - while (!dealer.isDealerDone()) { - cardDistributor.distributeCardToDealer(dealer); - } - } - - public GameResult judgeTotalGameResult(List players, Dealer dealer) { + public GameResult judgeTotalGameResult() { Map dealerResult = new HashMap<>(); LinkedHashMap playerResults = new LinkedHashMap<>(); @@ -36,22 +34,39 @@ public GameResult judgeTotalGameResult(List players, Dealer dealer) { return new GameResult(dealerResult, playerResults); } - private ScoreCompareResult toPlayerResult(ScoreCompareResult result) { + public ProfitResults calculateTotalProfitResults(GameResult gameResult) { + LinkedHashMap playerResults = gameResult.playerResults(); + + BigDecimal dealerProfit = BigDecimal.ZERO; + Map playerProfits = new LinkedHashMap<>(); + for (Map.Entry entry : playerResults.entrySet()) { + Player player = entry.getKey(); + ScoreCompareResult result = entry.getValue(); + + BigDecimal profit = player.calculateProfit(result); + dealerProfit = dealerProfit.subtract(profit); + playerProfits.put(player, profit); + } + + return new ProfitResults(dealerProfit, playerProfits); + } + + private static ScoreCompareResult toPlayerResult(ScoreCompareResult result) { if (result == ScoreCompareResult.DEALER_WIN) { - return ScoreCompareResult.PLAYER_LOSS; + return ScoreCompareResult.PLAYER_LOSE; } return result; } - private ScoreCompareResult toDealerKey(ScoreCompareResult result) { + private static ScoreCompareResult toDealerKey(ScoreCompareResult result) { if (result == ScoreCompareResult.PLAYER_WIN) { - return ScoreCompareResult.DEALER_LOSS; + return ScoreCompareResult.DEALER_LOSE; } return result; } - public ScoreCompareResult compareScore(Player player, Dealer dealer) { + public static ScoreCompareResult compareScore(Player player, Dealer dealer) { boolean isPlayerBust = player.isBust(); boolean isDealerBust = dealer.isBust(); @@ -63,7 +78,7 @@ public ScoreCompareResult compareScore(Player player, Dealer dealer) { } - private ScoreCompareResult compareScoreWhenBust(boolean isPlayerBust, boolean isDealerBust) { + private static ScoreCompareResult compareScoreWhenBust(boolean isPlayerBust, boolean isDealerBust) { if (isPlayerBust && isDealerBust) { return ScoreCompareResult.PUSH; } @@ -76,7 +91,7 @@ private ScoreCompareResult compareScoreWhenBust(boolean isPlayerBust, boolean is throw new IllegalArgumentException("버스트인 사람이 1명은 포함되어야 합니다."); } - private ScoreCompareResult compareScoreWhenNotBust(int playerTotalScore, int dealerTotalScore) { + private static ScoreCompareResult compareScoreWhenNotBust(int playerTotalScore, int dealerTotalScore) { if (playerTotalScore > dealerTotalScore) { return ScoreCompareResult.PLAYER_WIN; } diff --git a/src/main/java/blackjack/service/RandomCardPicker.java b/src/main/java/blackjack/service/RandomCardPicker.java index 46f056b47e5..a65bf80d20f 100644 --- a/src/main/java/blackjack/service/RandomCardPicker.java +++ b/src/main/java/blackjack/service/RandomCardPicker.java @@ -1,6 +1,8 @@ package blackjack.service; import blackjack.domain.Card; +import blackjack.domain.Rank; +import blackjack.domain.Shape; import java.util.ArrayList; import java.util.List; import java.util.Random; @@ -20,17 +22,22 @@ public Card drawCard() { } private List initializeNotDrawnCards() { - List ranks = List.of("2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"); - List shapes = List.of("하트", "스페이드", "다이아몬드", "클로버"); - + List ranks = List.of(Rank.values()); List notDrawnCards = new ArrayList<>(); - for (String rank : ranks) { - for (String shape : shapes) { - notDrawnCards.add(new Card(rank, shape)); - } + for (Rank rank : ranks) { + notDrawnCards.addAll(createCardsByRank(rank)); } return notDrawnCards; } + private List createCardsByRank(Rank rank) { + List shapes = List.of(Shape.values()); + List cardsByRank = new ArrayList<>(); + for (Shape shape : shapes) { + cardsByRank.add(new Card(rank, shape)); + } + return cardsByRank; + } + } diff --git a/src/main/java/blackjack/utils/InputParser.java b/src/main/java/blackjack/utils/InputParser.java index 754578910d3..b035741d28b 100644 --- a/src/main/java/blackjack/utils/InputParser.java +++ b/src/main/java/blackjack/utils/InputParser.java @@ -1,5 +1,6 @@ package blackjack.utils; +import java.math.BigDecimal; import java.util.List; import java.util.stream.Stream; @@ -19,4 +20,16 @@ public static List splitPlayerNames(String input) { .map(String::trim) .toList(); } + + public static BigDecimal parseBetAmount(String input) { + try { + BigDecimal amount = new BigDecimal(input); + if (amount.compareTo(BigDecimal.ZERO) <= 0) { + throw new IllegalArgumentException("[ERROR] 베팅 금액은 양수여야 합니다. 다시 입력해주세요."); + } + return amount; + } catch (NumberFormatException e) { + throw new IllegalArgumentException("[ERROR] 유효한 숫자를 입력해주세요. 다시 입력해주세요."); + } + } } diff --git a/src/main/java/blackjack/view/InputView.java b/src/main/java/blackjack/view/InputView.java index fad744f5fd1..42dbc3d7cc0 100644 --- a/src/main/java/blackjack/view/InputView.java +++ b/src/main/java/blackjack/view/InputView.java @@ -6,6 +6,7 @@ public class InputView { private static final String ASK_PLAYER_NAMES = "게임에 참여할 사람의 이름을 입력하세요.(쉼표 기준으로 분리)"; private static final String ASK_HIT_OR_STAND = "%s는 한장의 카드를 더 받겠습니까?(예는 y, 아니오는 n)\n"; + private static final String ASK_TO_PLAYER_BETTING_AMOUNT = "%s의 베팅 금액은?\n"; private static final Scanner scanner = new Scanner(System.in); public static String askPlayerNames() { @@ -17,4 +18,9 @@ public static String askHitOrStand(String playerName) { System.out.printf(ASK_HIT_OR_STAND, playerName); return scanner.nextLine(); } + + public static String askToPlayerBettingAmount(String playerName) { + System.out.printf(ASK_TO_PLAYER_BETTING_AMOUNT, playerName); + return scanner.nextLine(); + } } diff --git a/src/main/java/blackjack/view/OutputView.java b/src/main/java/blackjack/view/OutputView.java index 9bf9776ebf6..92267d0a59d 100644 --- a/src/main/java/blackjack/view/OutputView.java +++ b/src/main/java/blackjack/view/OutputView.java @@ -1,11 +1,10 @@ package blackjack.view; -import blackjack.domain.PlayerCardsName; -import blackjack.domain.PlayerFinalCardsScore; -import blackjack.domain.PlayerFinalResult; -import blackjack.domain.ScoreCompareResult; +import blackjack.dto.PlayerCardsName; +import blackjack.dto.PlayerFinalCardsScore; +import blackjack.dto.PlayerProfitResult; +import java.math.BigDecimal; import java.util.List; -import java.util.Map; public class OutputView { @@ -51,30 +50,15 @@ public static void printFinalCardScores(List playerFinalC } } - public static void printFinalResult( - Map dealerResult, - List playerResults) { + public static void printFinalProfitResult( + BigDecimal dealerProfit, + List playersProfitResults) { System.out.println(); - System.out.println("## 최종 승패"); - int wins = dealerResult.getOrDefault(ScoreCompareResult.DEALER_WIN, 0); - int losses = dealerResult.getOrDefault(ScoreCompareResult.DEALER_LOSS, 0); - int pushes = dealerResult.getOrDefault(ScoreCompareResult.PUSH, 0); - System.out.printf("딜러: %d승 %d무 %d패%n", wins, pushes, losses); + System.out.println("## 최종 수익"); + System.out.printf("딜러: %d%n", dealerProfit.intValue()); - for (PlayerFinalResult playerResult : playerResults) { - System.out.println(playerResult.name() + ": " + toKorean(playerResult.scoreCompareResult())); + for (PlayerProfitResult playerProfitResult : playersProfitResults) { + System.out.println(playerProfitResult.playerName() + ": " + playerProfitResult.profit().intValue()); } } - - private static String toKorean(ScoreCompareResult result) { - if (result == ScoreCompareResult.PLAYER_WIN) { - return "승"; - } - if (result == ScoreCompareResult.PLAYER_LOSS) { - return "패"; - } - return "무"; - } - - } diff --git a/src/test/java/BustTest.java b/src/test/java/BustTest.java index 3b49e58dd0e..8461ab8b73e 100644 --- a/src/test/java/BustTest.java +++ b/src/test/java/BustTest.java @@ -3,6 +3,8 @@ import blackjack.domain.Card; import blackjack.domain.Dealer; import blackjack.domain.Player; +import blackjack.domain.Rank; +import blackjack.domain.Shape; import org.junit.jupiter.api.Test; public class BustTest { @@ -10,9 +12,9 @@ public class BustTest { @Test void player_busts_when_sum_exceeds_21() { Player player = new Player("Alice"); - player.receiveOneCard(new Card("2", "하트")); - player.receiveOneCard(new Card("Q", "스페이드")); - player.receiveOneCard(new Card("10", "클로버")); + player.receiveOneCard(new Card(Rank.TWO, Shape.HEART)); + player.receiveOneCard(new Card(Rank.QUEEN, Shape.SPADE)); + player.receiveOneCard(new Card(Rank.TEN, Shape.CLUB)); assertThat(player.isBust()).isEqualTo(true); } @@ -20,9 +22,9 @@ void player_busts_when_sum_exceeds_21() { @Test void dealer_busts_when_sum_exceeds_21() { Dealer dealer = new Dealer(); - dealer.receiveOneCard(new Card("2", "하트")); - dealer.receiveOneCard(new Card("Q", "스페이드")); - dealer.receiveOneCard(new Card("10", "클로버")); + dealer.receiveOneCard(new Card(Rank.TWO, Shape.HEART)); + dealer.receiveOneCard(new Card(Rank.QUEEN, Shape.SPADE)); + dealer.receiveOneCard(new Card(Rank.TEN, Shape.CLUB)); assertThat(dealer.isBust()).isEqualTo(true); } @@ -30,9 +32,9 @@ void dealer_busts_when_sum_exceeds_21() { @Test void player_not_busts_when_sum_21_or_less() { Player player = new Player("Alice"); - player.receiveOneCard(new Card("A", "하트")); - player.receiveOneCard(new Card("Q", "스페이드")); - player.receiveOneCard(new Card("10", "클로버")); + player.receiveOneCard(new Card(Rank.ACE, Shape.HEART)); + player.receiveOneCard(new Card(Rank.QUEEN, Shape.SPADE)); + player.receiveOneCard(new Card(Rank.TEN, Shape.CLUB)); assertThat(player.isBust()).isEqualTo(false); } @@ -40,9 +42,9 @@ void player_not_busts_when_sum_21_or_less() { @Test void dealer_not_busts_when_sum_21_or_less() { Dealer dealer = new Dealer(); - dealer.receiveOneCard(new Card("A", "하트")); - dealer.receiveOneCard(new Card("Q", "스페이드")); - dealer.receiveOneCard(new Card("10", "클로버")); + dealer.receiveOneCard(new Card(Rank.ACE, Shape.HEART)); + dealer.receiveOneCard(new Card(Rank.QUEEN, Shape.SPADE)); + dealer.receiveOneCard(new Card(Rank.TEN, Shape.CLUB)); assertThat(dealer.isBust()).isEqualTo(false); } diff --git a/src/test/java/CardDistributorTest.java b/src/test/java/CardDistributorTest.java deleted file mode 100644 index 9e8ea25f416..00000000000 --- a/src/test/java/CardDistributorTest.java +++ /dev/null @@ -1,10 +0,0 @@ -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - -import java.util.Random; -import org.junit.jupiter.api.Test; - -public class CardDistributorTest { - -} diff --git a/src/test/java/CardTest.java b/src/test/java/CardTest.java index 1d758ae03b0..d6ec2b04dee 100644 --- a/src/test/java/CardTest.java +++ b/src/test/java/CardTest.java @@ -2,18 +2,17 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import blackjack.domain.Card; +import blackjack.domain.Rank; +import blackjack.domain.Shape; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; public class CardTest { - Card card2 = new Card("2", "하트"); - Card cardJ = new Card("J", "스페이드"); - Card cardQ = new Card("Q", "다이아몬드"); - Card cardK = new Card("K", "클로버"); - - Card cardException1 = new Card("B", "하트"); - Card cardException2 = new Card("-1", "스페이드"); + Card card2 = new Card(Rank.TWO, Shape.HEART); + Card cardJ = new Card(Rank.JACK, Shape.SPADE); + Card cardQ = new Card(Rank.QUEEN, Shape.DIAMOND); + Card cardK = new Card(Rank.KING, Shape.CLUB); @Test @@ -24,13 +23,4 @@ void calculate_card_score() { assertThat(cardQ.translateToScore()).isEqualTo(10); assertThat(cardK.translateToScore()).isEqualTo(10); } - - @Test - @DisplayName("카드 점수 계산 예외 처리") - void calculate_card_score_exception() { - assertThatThrownBy(() -> cardException1.translateToScore()) - .isInstanceOf(IllegalArgumentException.class); - assertThatThrownBy(() -> cardException2.translateToScore()) - .isInstanceOf(IllegalArgumentException.class); - } } diff --git a/src/test/java/CardsSumTest.java b/src/test/java/CardsSumTest.java index 6fa20a7326c..554caac38a8 100644 --- a/src/test/java/CardsSumTest.java +++ b/src/test/java/CardsSumTest.java @@ -2,6 +2,8 @@ import blackjack.domain.Card; import blackjack.domain.Cards; +import blackjack.domain.Rank; +import blackjack.domain.Shape; import java.util.List; import org.junit.jupiter.api.Test; @@ -10,30 +12,30 @@ public class CardsSumTest { @Test void cards_sum_without_ace() { Cards cards = new Cards(List.of( - new Card("2", "하트"), - new Card("3", "스페이드"), - new Card("J", "다이아몬드"), - new Card("Q", "클로버"))); + new Card(Rank.TWO, Shape.HEART), + new Card(Rank.THREE, Shape.SPADE), + new Card(Rank.JACK, Shape.DIAMOND), + new Card(Rank.QUEEN, Shape.CLUB))); assertThat(cards.sumScore()).isEqualTo(25); } @Test void cards_sum_with_ace() { Cards cards1 = new Cards(List.of( - new Card("2", "하트"), - new Card("3", "스페이드"), - new Card("A", "다이아몬드"), - new Card("J", "클로버"), - new Card("Q", "하트"))); + new Card(Rank.TWO, Shape.HEART), + new Card(Rank.THREE, Shape.SPADE), + new Card(Rank.ACE, Shape.DIAMOND), + new Card(Rank.JACK, Shape.CLUB), + new Card(Rank.QUEEN, Shape.HEART))); Cards cards2 = new Cards(List.of( - new Card("2", "하트"), - new Card("3", "스페이드"), - new Card("A", "다이아몬드"))); + new Card(Rank.TWO, Shape.HEART), + new Card(Rank.THREE, Shape.SPADE), + new Card(Rank.ACE, Shape.DIAMOND))); Cards cards3 = new Cards(List.of( - new Card("2", "하트"), - new Card("3", "스페이드"), - new Card("A", "다이아몬드"), - new Card("A", "클로버"))); + new Card(Rank.TWO, Shape.HEART), + new Card(Rank.THREE, Shape.SPADE), + new Card(Rank.ACE, Shape.DIAMOND), + new Card(Rank.ACE, Shape.CLUB))); assertThat(cards1.sumScore()).isEqualTo(26); assertThat(cards2.sumScore()).isEqualTo(16); assertThat(cards3.sumScore()).isEqualTo(17); diff --git a/src/test/java/DealerTest.java b/src/test/java/DealerTest.java index b8e30e27d55..2617605ed43 100644 --- a/src/test/java/DealerTest.java +++ b/src/test/java/DealerTest.java @@ -2,6 +2,8 @@ import blackjack.domain.Card; import blackjack.domain.Dealer; +import blackjack.domain.Rank; +import blackjack.domain.Shape; import org.junit.jupiter.api.Test; public class DealerTest { @@ -9,26 +11,26 @@ public class DealerTest { @Test void calculate_dealer_total_score() { Dealer dealer1 = new Dealer(); - dealer1.receiveOneCard(new Card("A", "하트")); - dealer1.receiveOneCard(new Card("Q", "스페이드")); + dealer1.receiveOneCard(new Card(Rank.ACE, Shape.HEART)); + dealer1.receiveOneCard(new Card(Rank.QUEEN, Shape.SPADE)); assertThat(dealer1.calculateTotalScore()).isEqualTo(21); Dealer dealer2 = new Dealer(); - dealer2.receiveOneCard(new Card("3", "하트")); - dealer2.receiveOneCard(new Card("10", "스페이드")); + dealer2.receiveOneCard(new Card(Rank.THREE, Shape.HEART)); + dealer2.receiveOneCard(new Card(Rank.TEN, Shape.SPADE)); assertThat(dealer2.calculateTotalScore()).isEqualTo(13); } @Test void is_dealer_done_when_total_score_is_17_or_more() { Dealer dealer1 = new Dealer(); - dealer1.receiveOneCard(new Card("10", "하트")); - dealer1.receiveOneCard(new Card("7", "스페이드")); + dealer1.receiveOneCard(new Card(Rank.TEN, Shape.HEART)); + dealer1.receiveOneCard(new Card(Rank.SEVEN, Shape.SPADE)); assertThat(dealer1.isDealerDone()).isEqualTo(true); Dealer dealer2 = new Dealer(); - dealer2.receiveOneCard(new Card("2", "하트")); - dealer2.receiveOneCard(new Card("7", "스페이드")); + dealer2.receiveOneCard(new Card(Rank.TWO, Shape.HEART)); + dealer2.receiveOneCard(new Card(Rank.SEVEN, Shape.SPADE)); assertThat(dealer2.isDealerDone()).isEqualTo(false); } } diff --git a/src/test/java/GameTest.java b/src/test/java/GameTest.java index e61e2f85507..3d1657bf30c 100644 --- a/src/test/java/GameTest.java +++ b/src/test/java/GameTest.java @@ -2,11 +2,13 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import blackjack.domain.Rank; import blackjack.domain.ScoreCompareResult; import blackjack.domain.Card; import blackjack.domain.Dealer; import blackjack.domain.GameResult; import blackjack.domain.Player; +import blackjack.domain.Shape; import blackjack.service.CardDistributor; import blackjack.service.Game; import java.util.LinkedHashMap; @@ -19,7 +21,7 @@ public class GameTest { @Test - void dealer_should_draw_card_until_score_at_least_17() { + void dealer_should_draw_card_until_score_at_least_17() { // TODO: 책임 CardDistributor로 이동 Dealer dealer = new Dealer(); Random mockRandom = mock(Random.class); RandomCardPicker randomCardPicker = new RandomCardPicker(mockRandom); @@ -28,8 +30,7 @@ void dealer_should_draw_card_until_score_at_least_17() { // 2 하트, 2 스페이드, 2 클로버, 2 다이아몬드, 3 하트, 3 스페이드, 3 클로버, 3 다이아몬드, ... when(mockRandom.nextInt(52)).thenReturn(0); - Game game = new Game(cardDistributor); - game.dealerDrawsCardsUntilDone(dealer); + cardDistributor.distributeCardsToDealerUntilScoreAtLeast(dealer); assertThat(dealer.calculateTotalScore()).isEqualTo(17); } @@ -39,14 +40,13 @@ void compare_score_when_player_win() { Player player = new Player("player1"); Dealer dealer = new Dealer(); - player.receiveOneCard(new Card("A", "하트")); - player.receiveOneCard(new Card("Q", "스페이드")); + player.receiveOneCard(new Card(Rank.ACE, Shape.HEART)); + player.receiveOneCard(new Card(Rank.QUEEN, Shape.SPADE)); - dealer.receiveOneCard(new Card("10", "하트")); - dealer.receiveOneCard(new Card("7", "스페이드")); + dealer.receiveOneCard(new Card(Rank.TEN, Shape.HEART)); + dealer.receiveOneCard(new Card(Rank.SEVEN, Shape.SPADE)); - Game game = new Game(null); - assertThat(game.compareScore(player, dealer)).isEqualTo(ScoreCompareResult.PLAYER_WIN); + assertThat(Game.compareScore(player, dealer)).isEqualTo(ScoreCompareResult.PLAYER_WIN); } @Test @@ -54,14 +54,13 @@ void compare_score_when_dealer_win() { Player player = new Player("player1"); Dealer dealer = new Dealer(); - player.receiveOneCard(new Card("A", "하트")); - player.receiveOneCard(new Card("4", "스페이드")); + player.receiveOneCard(new Card(Rank.ACE, Shape.HEART)); + player.receiveOneCard(new Card(Rank.FOUR, Shape.SPADE)); - dealer.receiveOneCard(new Card("10", "하트")); - dealer.receiveOneCard(new Card("9", "스페이드")); + dealer.receiveOneCard(new Card(Rank.TEN, Shape.HEART)); + dealer.receiveOneCard(new Card(Rank.NINE, Shape.SPADE)); - Game game = new Game(null); - assertThat(game.compareScore(player, dealer)).isEqualTo(ScoreCompareResult.DEALER_WIN); + assertThat(Game.compareScore(player, dealer)).isEqualTo(ScoreCompareResult.DEALER_WIN); } @Test @@ -69,34 +68,38 @@ void compare_score_when_push() { Player player = new Player("player1"); Dealer dealer = new Dealer(); - player.receiveOneCard(new Card("A", "하트")); - player.receiveOneCard(new Card("Q", "스페이드")); + player.receiveOneCard(new Card(Rank.ACE, Shape.HEART)); + player.receiveOneCard(new Card(Rank.QUEEN, Shape.SPADE)); - dealer.receiveOneCard(new Card("10", "하트")); - dealer.receiveOneCard(new Card("A", "스페이드")); + dealer.receiveOneCard(new Card(Rank.TEN, Shape.HEART)); + dealer.receiveOneCard(new Card(Rank.ACE, Shape.SPADE)); - Game game = new Game(null); - assertThat(game.compareScore(player, dealer)).isEqualTo(ScoreCompareResult.PUSH); + assertThat(Game.compareScore(player, dealer)).isEqualTo(ScoreCompareResult.PUSH); } @Test void judge_total_winner_result() { - Player pobi = createPlayer("pobi", "2:하트", "8:스페이드", "A:클로버"); - Player jason = createPlayer("jason", "7:클로버", "K:스페이드"); - Player brown = createPlayer("brown", "10:하트", "10:클로버"); - Dealer dealer = createDealer("3:다이아몬드", "9:클로버", "8:다이아몬드"); - - Game game = new Game(null); + Player pobi = createPlayer("pobi", + new Card(Rank.TWO, Shape.HEART), new Card(Rank.EIGHT, Shape.SPADE), new Card(Rank.ACE, Shape.CLUB)); + Player jason = createPlayer("jason", + new Card(Rank.SEVEN, Shape.CLUB), new Card(Rank.KING, Shape.SPADE)); + Player brown = createPlayer("brown", + new Card(Rank.TEN, Shape.HEART), new Card(Rank.TEN, Shape.CLUB)); + Dealer dealer = createDealer( + new Card(Rank.THREE, Shape.DIAMOND), new Card(Rank.NINE, Shape.CLUB), + new Card(Rank.EIGHT, Shape.DIAMOND)); + + Game game = new Game(List.of(pobi, jason, brown), dealer); Map dealerResult = Map.of( ScoreCompareResult.DEALER_WIN, 1, - ScoreCompareResult.DEALER_LOSS, 1, + ScoreCompareResult.DEALER_LOSE, 1, ScoreCompareResult.PUSH, 1 ); LinkedHashMap playerResults = new LinkedHashMap<>(); playerResults.put(pobi, ScoreCompareResult.PLAYER_WIN); - playerResults.put(jason, ScoreCompareResult.PLAYER_LOSS); + playerResults.put(jason, ScoreCompareResult.PLAYER_LOSE); playerResults.put(brown, ScoreCompareResult.PUSH); GameResult expected = new GameResult( @@ -104,25 +107,23 @@ void judge_total_winner_result() { playerResults ); - GameResult actual = game.judgeTotalGameResult(List.of(pobi, jason, brown), dealer); + GameResult actual = game.judgeTotalGameResult(); assertThat(actual).usingRecursiveComparison().isEqualTo(expected); } - private Player createPlayer(String name, String... cards) { + private Player createPlayer(String name, Card... cards) { Player player = new Player(name); - for (String card : cards) { - String[] parts = card.split(":"); - player.receiveOneCard(new Card(parts[0], parts[1])); + for (Card card : cards) { + player.receiveOneCard(card); } return player; } - private Dealer createDealer(String... cards) { + private Dealer createDealer(Card... cards) { Dealer dealer = new Dealer(); - for (String card : cards) { - String[] parts = card.split(":"); - dealer.receiveOneCard(new Card(parts[0], parts[1])); + for (Card card : cards) { + dealer.receiveOneCard(card); } return dealer; } diff --git a/src/test/java/PlayerBetTest.java b/src/test/java/PlayerBetTest.java new file mode 100644 index 00000000000..69ead9c7337 --- /dev/null +++ b/src/test/java/PlayerBetTest.java @@ -0,0 +1,85 @@ +import static org.assertj.core.api.AssertionsForClassTypes.assertThat; + +import blackjack.domain.Card; +import blackjack.domain.Dealer; +import blackjack.domain.GameResult; +import blackjack.domain.Player; +import blackjack.domain.ProfitResults; +import blackjack.domain.Rank; +import blackjack.domain.ScoreCompareResult; +import blackjack.domain.Shape; +import blackjack.service.Game; +import java.math.BigDecimal; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; + +public class PlayerBetTest { + @Test + void calculate_profit_when_player_win_except_blackjack() { + Player player = new Player("player", BigDecimal.valueOf(1000)); + + assertThat(player.calculateProfit(ScoreCompareResult.PLAYER_WIN)).isEqualByComparingTo(BigDecimal.valueOf(1000)); + } + + @Test + void calculate_profit_when_player_win_with_blackjack() { + Player player = createPlayer("player", BigDecimal.valueOf(1000), + new Card(Rank.ACE, Shape.SPADE), new Card(Rank.TEN, Shape.HEART)); + + assertThat(player.calculateProfit(ScoreCompareResult.PLAYER_WIN)).isEqualByComparingTo(BigDecimal.valueOf(1500)); + } + + @Test + void calculate_profit_when_player_lose() { + Player player = new Player("player", BigDecimal.valueOf(1000)); + + assertThat(player.calculateProfit(ScoreCompareResult.PLAYER_LOSE)).isEqualByComparingTo(BigDecimal.valueOf(-1000)); + } + + @Test + void calculate_profit_when_player_draw() { + Player player = new Player("player", BigDecimal.valueOf(1000)); + + assertThat(player.calculateProfit(ScoreCompareResult.PUSH)).isEqualByComparingTo(BigDecimal.ZERO); + } + + @Test + void calculate_total_profit_result() { + Player winningPlayer = createPlayer("winningPlayer", BigDecimal.valueOf(1000), + new Card(Rank.QUEEN, Shape.SPADE), new Card(Rank.TEN, Shape.HEART)); + Player losingPlayer = createPlayer("losingPlayer", BigDecimal.valueOf(1500), + new Card(Rank.NINE, Shape.SPADE), new Card(Rank.EIGHT, Shape.HEART)); + Dealer dealer = createDealer( + new Card(Rank.TEN, Shape.SPADE), new Card(Rank.EIGHT, Shape.HEART)); + + Game game = new Game(List.of(winningPlayer, losingPlayer), dealer); + GameResult gameResult = game.judgeTotalGameResult(); + + ProfitResults actualProfitResults = game.calculateTotalProfitResults(gameResult); + ProfitResults expectedProfitResults = new ProfitResults(BigDecimal.valueOf(500), Map.of( + winningPlayer, BigDecimal.valueOf(1000), + losingPlayer, BigDecimal.valueOf(-1500) + )); + assertThat(actualProfitResults).usingRecursiveComparison() + .withComparatorForType(BigDecimal::compareTo, BigDecimal.class) + .isEqualTo(expectedProfitResults); + } + + + private Player createPlayer(String name, BigDecimal bettingAmount, Card... cards) { + Player player = new Player(name, bettingAmount); + for (Card card : cards) { + player.receiveOneCard(card); + } + return player; + } + + private Dealer createDealer(Card... cards) { + Dealer dealer = new Dealer(); + for (Card card : cards) { + dealer.receiveOneCard(card); + } + return dealer; + } +} \ No newline at end of file diff --git a/src/test/java/PlayerTest.java b/src/test/java/PlayerTest.java index 5b3575a954d..7f1efeccf9c 100644 --- a/src/test/java/PlayerTest.java +++ b/src/test/java/PlayerTest.java @@ -2,19 +2,37 @@ import blackjack.domain.Card; import blackjack.domain.Player; +import blackjack.domain.Rank; +import blackjack.domain.Shape; import org.junit.jupiter.api.Test; public class PlayerTest { @Test void calculate_player_total_score() { Player player1 = new Player("player1"); - player1.receiveOneCard(new Card("A", "하트")); - player1.receiveOneCard(new Card("Q", "스페이드")); + player1.receiveOneCard(new Card(Rank.ACE, Shape.HEART)); + player1.receiveOneCard(new Card(Rank.QUEEN, Shape.SPADE)); assertThat(player1.calculateTotalScore()).isEqualTo(21); Player player2 = new Player("player2"); - player2.receiveOneCard(new Card("3", "하트")); - player2.receiveOneCard(new Card("10", "스페이드")); + player2.receiveOneCard(new Card(Rank.THREE, Shape.HEART)); + player2.receiveOneCard(new Card(Rank.TEN, Shape.SPADE)); assertThat(player2.calculateTotalScore()).isEqualTo(13); } + + @Test + void player_is_blackjack_when_score_is_21() { + Player player = new Player("player"); + player.receiveOneCard(new Card(Rank.ACE, Shape.HEART)); + player.receiveOneCard(new Card(Rank.JACK, Shape.SPADE)); + assertThat(player.isBlackjack()).isTrue(); + } + + @Test + void player_is_not_blackjack_when_score_is_20() { + Player player = new Player("player"); + player.receiveOneCard(new Card(Rank.QUEEN, Shape.HEART)); + player.receiveOneCard(new Card(Rank.JACK, Shape.SPADE)); + assertThat(player.isBlackjack()).isFalse(); + } } diff --git a/src/test/java/RandomCardPickerTest.java b/src/test/java/RandomCardPickerTest.java index 8bdddb6c974..2f5cc8f8c05 100644 --- a/src/test/java/RandomCardPickerTest.java +++ b/src/test/java/RandomCardPickerTest.java @@ -3,6 +3,8 @@ import static org.mockito.Mockito.when; import blackjack.domain.Card; +import blackjack.domain.Rank; +import blackjack.domain.Shape; import java.util.HashSet; import java.util.Random; import java.util.Set; @@ -15,10 +17,10 @@ void draw_random_card() { Random mockRandom = mock(Random.class); RandomCardPicker randomCardPicker = new RandomCardPicker(mockRandom); - when(mockRandom.nextInt(13)).thenReturn(0); // "2" - when(mockRandom.nextInt(4)).thenReturn(0); // "하트" + when(mockRandom.nextInt(13)).thenReturn(0); // Rank.TWO + when(mockRandom.nextInt(4)).thenReturn(0); // Shape.HEART - assertThat(randomCardPicker.drawCard()).isEqualTo(new Card("2", "하트")); + assertThat(randomCardPicker.drawCard()).isEqualTo(new Card(Rank.TWO, Shape.HEART)); } @Test