628 lines
22 KiB
C
628 lines
22 KiB
C
/**
|
|
* Copyright (c) 2021 Dominic Masters
|
|
*
|
|
* This software is released under the MIT License.
|
|
* https://opensource.org/licenses/MIT
|
|
*/
|
|
|
|
#include "poker.h"
|
|
|
|
void test_pokerInit_should_InitializePokerGame(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerCount);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.state);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
|
|
}
|
|
|
|
void test_pokerResetRound_should_ResetTheRound(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
poker.potCount = 0x03;
|
|
poker.graveSize = 0x10;
|
|
poker.communitySize = 0x03;
|
|
poker.deckSize = 0x0;
|
|
|
|
pokerResetRound(&poker);
|
|
|
|
TEST_ASSERT_NOT_EQUAL_UINT8(0, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.graveSize);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.communitySize);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.potCount);
|
|
}
|
|
|
|
void test_pokerResetRound_should_ResetThePlayers(void) {
|
|
poker2_t poker;
|
|
uint8_t i;
|
|
pokerInit(&poker);
|
|
|
|
pokerPlayerAdd(&poker);
|
|
pokerPlayerAdd(&poker);
|
|
pokerPlayerAdd(&poker);
|
|
|
|
for(i = 0; i < poker.playerCount; i++) {
|
|
poker.players[i].cardCount = 32;
|
|
poker.players[i].chips = 100;
|
|
poker.players[i].state = 0xFF;
|
|
poker.players[i].currentBet = 12345;
|
|
};
|
|
|
|
pokerResetRound(&poker);
|
|
|
|
for(i = 0; i < poker.playerCount; i++) {
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.players[i].cardCount);
|
|
TEST_ASSERT_EQUAL_INT32(0, poker.players[i].currentBet);
|
|
TEST_ASSERT_EQUAL_INT32(100, poker.players[i].chips);
|
|
TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_FOLDED, poker.players[i].state);
|
|
TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, poker.players[i].state);
|
|
TEST_ASSERT_EQUAL_UINT8(
|
|
0xFF - POKER_PLAYER_STATE_FOLDED - POKER_PLAYER_STATE_HAS_BET_THIS_ROUND,
|
|
poker.players[i].state
|
|
);
|
|
}
|
|
}
|
|
|
|
void test_pokerNewDealer_should_FindANewDealer(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
|
|
|
|
pokerNewDealer(&poker);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);
|
|
|
|
pokerNewDealer(&poker);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(3, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(4, poker.playerBigBlind);
|
|
|
|
pokerNewDealer(&poker);
|
|
TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(4, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
|
|
|
|
pokerNewDealer(&poker);
|
|
TEST_ASSERT_EQUAL_UINT8(4, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);
|
|
}
|
|
|
|
void test_pokerNewDealer_should_SkipOutPlayers(void) {
|
|
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerAdd(&poker);
|
|
|
|
pokerNewDealer(&poker);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(3, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
|
|
|
|
pokerNewDealer(&poker);
|
|
TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);
|
|
|
|
pokerNewDealer(&poker);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.playerSmallBlind);
|
|
TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);
|
|
}
|
|
|
|
void test_pokerTakeBlinds_should_TakeTheBlinds(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
|
|
|
|
pokerNewDealer(&poker);
|
|
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 1)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 2)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 3)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 4)->chips);
|
|
|
|
pokerTakeBlinds(&poker, 100, 200);
|
|
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 1)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(900, (poker.players + 2)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(800, (poker.players + 3)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 4)->chips);
|
|
|
|
pokerNewDealer(&poker);
|
|
pokerTakeBlinds(&poker, 100, 200);
|
|
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 1)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(900, (poker.players + 2)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(700, (poker.players + 3)->chips);
|
|
TEST_ASSERT_EQUAL_INT32(800, (poker.players + 4)->chips);
|
|
}
|
|
|
|
void test_pokerPotAdd_should_AddAPot(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.potCount);
|
|
TEST_ASSERT_EQUAL_UINT8(1, pokerPotAdd(&poker));
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.potCount);
|
|
}
|
|
|
|
void test_pokerPotAdd_should_ResetThePot(void) {
|
|
poker2_t poker;
|
|
poker2pot_t *pot;
|
|
uint8_t i;
|
|
pokerInit(&poker);
|
|
|
|
i = pokerPotAdd(&poker);
|
|
pot = poker.pots + i;
|
|
TEST_ASSERT_EQUAL_UINT8(0, pot->playerCount);
|
|
TEST_ASSERT_EQUAL_INT32(0, pot->chips);
|
|
}
|
|
|
|
void test_pokerPotAddPlayer_should_AddAPlayer(void) {
|
|
poker2_t poker;
|
|
poker2pot_t *pot;
|
|
|
|
pokerInit(&poker);
|
|
pokerPlayerAdd(&poker);
|
|
pokerPlayerAdd(&poker);
|
|
|
|
pot = poker.pots + 0;
|
|
TEST_ASSERT_EQUAL_UINT8(0, pot->playerCount);
|
|
|
|
pokerPotAddPlayer(pot, 1);
|
|
TEST_ASSERT_EQUAL_UINT8(1, pot->playerCount);
|
|
TEST_ASSERT_EQUAL_UINT8(0x01, pot->players[0]);
|
|
|
|
pokerPotAddPlayer(pot, 0);
|
|
TEST_ASSERT_EQUAL_UINT8(2, pot->playerCount);
|
|
TEST_ASSERT_EQUAL_UINT8(0x00, pot->players[1]);
|
|
}
|
|
|
|
void test_pokerPlayerAdd_should_AddAPlayer(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.playerCount);
|
|
TEST_ASSERT_EQUAL(0, pokerPlayerAdd(&poker));
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.playerCount);
|
|
TEST_ASSERT_EQUAL(1, pokerPlayerAdd(&poker));
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.playerCount);
|
|
}
|
|
|
|
void test_pokerPlayerAdd_should_ResetThePlayer(void) {
|
|
poker2_t poker;
|
|
poker2player_t *player;
|
|
pokerInit(&poker);
|
|
|
|
player = poker.players + pokerPlayerAdd(&poker);
|
|
TEST_ASSERT_EQUAL_INT32(0, player->chips);
|
|
TEST_ASSERT_EQUAL_INT32(0, player->currentBet);
|
|
TEST_ASSERT_EQUAL_UINT8(0, player->cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(POKER_PLAYER_STATE_OUT, player->state);
|
|
}
|
|
|
|
void test_pokerTurn_should_TurnCardsFromTheDeck(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.communitySize);
|
|
|
|
pokerTurn(&poker, 1);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 1, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.communitySize);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, poker.community[0]);
|
|
|
|
pokerTurn(&poker, 3);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 4, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(4, poker.communitySize);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, poker.community[1]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.community[2]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.community[3]);
|
|
}
|
|
|
|
void test_pokerBurn_should_SendCardsToTheGrave(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.graveSize);
|
|
|
|
pokerBurn(&poker, 1);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 1, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.graveSize);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, poker.grave[0]);
|
|
|
|
pokerBurn(&poker, 3);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 4, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(4, poker.graveSize);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, poker.grave[1]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.grave[2]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.grave[3]);
|
|
|
|
}
|
|
|
|
void test_pokerGetCallValue_should_CalculateTheCallValue(void) {
|
|
poker2_t poker;
|
|
uint8_t first, second;
|
|
pokerInit(&poker);
|
|
first = pokerPlayerAdd(&poker);
|
|
second = pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + first, 10000);
|
|
pokerPlayerChipsAdd(poker.players + second, 10000);
|
|
|
|
TEST_ASSERT_EQUAL_INT32(0, pokerGetCallValue(&poker));
|
|
pokerPlayerBet(&poker, first, 100);
|
|
TEST_ASSERT_EQUAL_INT32(100, pokerGetCallValue(&poker));
|
|
pokerPlayerBet(&poker, second, 150);
|
|
TEST_ASSERT_EQUAL_INT32(150, pokerGetCallValue(&poker));
|
|
|
|
pokerPotAdd(&poker);
|
|
TEST_ASSERT_EQUAL_INT32(150, pokerGetCallValue(&poker));
|
|
TEST_ASSERT_EQUAL_INT32(0, poker.pots[1].chips);
|
|
pokerPlayerBet(&poker, second, 50);
|
|
TEST_ASSERT_EQUAL_INT32(200, pokerGetCallValue(&poker));
|
|
TEST_ASSERT_EQUAL_INT32(50, poker.pots[1].chips);
|
|
}
|
|
|
|
void test_pokerGetCallValue_should_SkipOutPlayers(void) {
|
|
poker2_t poker;
|
|
uint8_t i;
|
|
pokerInit(&poker);
|
|
|
|
i = pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + i, 10000);
|
|
pokerPlayerBet(&poker, i, 300);
|
|
|
|
i = pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + i, 10000);
|
|
pokerPlayerBet(&poker, i, 500);
|
|
|
|
i = pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + i, 10000);
|
|
pokerPlayerBet(&poker, i, 200);
|
|
|
|
TEST_ASSERT_EQUAL_INT32(500, pokerGetCallValue(&poker));
|
|
poker.players[1].state |= POKER_PLAYER_STATE_OUT;
|
|
TEST_ASSERT_EQUAL_INT32(300, pokerGetCallValue(&poker));
|
|
poker.players[0].state |= POKER_PLAYER_STATE_OUT;
|
|
TEST_ASSERT_EQUAL_INT32(200, pokerGetCallValue(&poker));
|
|
}
|
|
|
|
void test_pokerPlayerDeal_should_DealCardsToThePlayer(void) {
|
|
poker2_t poker;
|
|
uint8_t playerIndex;
|
|
poker2player_t *player;
|
|
|
|
pokerInit(&poker);
|
|
|
|
playerIndex = pokerPlayerAdd(&poker);
|
|
player = poker.players + playerIndex;
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(0, player->cardCount);
|
|
|
|
pokerPlayerDeal(&poker, player, 0x01);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 1, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(1, player->cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, player->cards[0]);
|
|
|
|
pokerPlayerDeal(&poker, player, 0x01);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 2, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(2, player->cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, player->cards[1]);
|
|
}
|
|
|
|
void test_pokerPlayerChipsAdd_should_AddChipsToThePlayer(void) {
|
|
poker2_t poker;
|
|
uint8_t playerIndex;
|
|
poker2player_t *player;
|
|
|
|
pokerInit(&poker);
|
|
playerIndex = pokerPlayerAdd(&poker);
|
|
player = poker.players + playerIndex;
|
|
|
|
TEST_ASSERT_EQUAL_INT32(0, player->chips);
|
|
pokerPlayerChipsAdd(player, 32);
|
|
TEST_ASSERT_EQUAL_INT32(32, player->chips);
|
|
pokerPlayerChipsAdd(player, 10);
|
|
TEST_ASSERT_EQUAL_INT32(42, player->chips);
|
|
pokerPlayerChipsAdd(player, -30);
|
|
TEST_ASSERT_EQUAL_INT32(12, player->chips);
|
|
}
|
|
|
|
void test_pokerPlayerChipsAdd_should_TurnOutStateOff(void) {
|
|
poker2_t poker;
|
|
uint8_t playerIndex;
|
|
poker2player_t *player;
|
|
|
|
pokerInit(&poker);
|
|
playerIndex = pokerPlayerAdd(&poker);
|
|
player = poker.players + playerIndex;
|
|
|
|
player->state |= POKER_PLAYER_STATE_OUT;
|
|
TEST_ASSERT_BITS_HIGH(POKER_PLAYER_STATE_OUT, player->state);
|
|
pokerPlayerChipsAdd(player, 32);
|
|
TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_OUT, player->state);
|
|
}
|
|
|
|
void test_pokerPlayerDealAll_should_DealCardsToEveryone(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.players[0].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.players[1].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.players[2].cardCount);
|
|
|
|
pokerPlayerDealAll(&poker, 1);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE - 3, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.players[0].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.players[1].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(1, poker.players[2].cardCount);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, poker.players[0].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, poker.players[1].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.players[2].cards[0]);
|
|
}
|
|
|
|
void test_pokerPlayerDealAll_should_DealMultipleCardsToEveryone(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.players[0].cardCount);
|
|
|
|
pokerPlayerDealAll(&poker, 0x02);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.players[0].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.players[1].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.players[2].cardCount);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, poker.players[0].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, poker.players[1].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.players[2].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.players[0].cards[1]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TEN, poker.players[1].cards[1]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_NINE, poker.players[2].cards[1]);
|
|
}
|
|
|
|
void test_pokerPlayerDealAll_should_NotDealToOutPlayers(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.players[0].cardCount);
|
|
|
|
pokerPlayerDealAll(&poker, 0x02);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.players[0].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.players[1].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.players[2].cardCount);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, poker.players[0].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, poker.players[2].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.players[0].cards[1]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.players[2].cards[1]);
|
|
}
|
|
|
|
void test_pokerPlayerDealAll_should_NotDealToFoldedPlayers(void) {
|
|
poker2_t poker;
|
|
pokerInit(&poker);
|
|
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
|
|
poker.players[0].state |= POKER_PLAYER_STATE_FOLDED;
|
|
|
|
pokerPlayerDealAll(&poker, 2);
|
|
TEST_ASSERT_EQUAL_UINT8(0, poker.players[0].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.players[1].cardCount);
|
|
TEST_ASSERT_EQUAL_UINT8(2, poker.players[2].cardCount);
|
|
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, poker.players[1].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, poker.players[2].cards[0]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.players[1].cards[1]);
|
|
TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.players[2].cards[1]);
|
|
}
|
|
|
|
void test_pokerPlayerDoesNeedToBetThisRound_should_CheckCallValue(void) {
|
|
poker2_t poker;
|
|
uint8_t first, second;
|
|
|
|
pokerInit(&poker);
|
|
|
|
first = pokerPlayerAdd(&poker);
|
|
second = pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + first, 10000);
|
|
pokerPlayerChipsAdd(poker.players + second, 10000);
|
|
|
|
pokerPlayerBet(&poker, first, 100);
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
|
|
pokerPlayerBet(&poker, second, 200);
|
|
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
|
|
pokerPlayerBet(&poker, first, 100);
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
}
|
|
|
|
void test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet(void) {
|
|
poker2_t poker;
|
|
uint8_t first, second;
|
|
pokerInit(&poker);
|
|
first = pokerPlayerAdd(&poker);
|
|
second = pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + first, 10000);
|
|
pokerPlayerChipsAdd(poker.players + second, 10000);
|
|
|
|
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
|
|
pokerPlayerBet(&poker, first, 100);
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
|
|
pokerPlayerBet(&poker, second, 100);
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
}
|
|
|
|
void test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers(void) {
|
|
poker2_t poker;
|
|
uint8_t first, second;
|
|
pokerInit(&poker);
|
|
first = pokerPlayerAdd(&poker);
|
|
second = pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players + first, 10000);
|
|
pokerPlayerChipsAdd(poker.players + second, 10000);
|
|
|
|
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
|
|
pokerPlayerBet(&poker, first, 100);
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
|
|
poker.players[second].state |= POKER_PLAYER_STATE_FOLDED;
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
|
|
pokerPlayerBet(&poker, first, 100);
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
|
|
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
|
|
}
|
|
|
|
void test_pokerPlayerBetPot_should_AddChipsToThePot(void) {
|
|
poker2_t poker;
|
|
poker2pot_t *pot;
|
|
poker2player_t *player;
|
|
uint8_t i;
|
|
|
|
pokerInit(&poker);
|
|
pot = poker.pots;
|
|
i = pokerPlayerAdd(&poker);
|
|
player = poker.players + i;
|
|
pokerPlayerChipsAdd(player, 1000);
|
|
|
|
TEST_ASSERT_EQUAL_INT32(0, pot->chips);
|
|
TEST_ASSERT_EQUAL_INT32(1000, player->chips);
|
|
|
|
pokerPlayerBetPot(&poker, pot, i, 100);
|
|
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
|
|
TEST_ASSERT_EQUAL_INT32(900, player->chips);
|
|
}
|
|
|
|
void test_pokerPlayerBetPot_should_UpdatePlayerState(void) {
|
|
poker2_t poker;
|
|
uint8_t i;
|
|
poker2player_t *player;
|
|
|
|
pokerInit(&poker);
|
|
i = pokerPlayerAdd(&poker);
|
|
player = poker.players + i;
|
|
pokerPlayerChipsAdd(player, 1000);
|
|
|
|
TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, player->state);
|
|
TEST_ASSERT_EQUAL_INT32(0, player->currentBet);
|
|
|
|
pokerPlayerBetPot(&poker, poker.pots, i, 100);
|
|
TEST_ASSERT_BITS_HIGH(POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, player->state);
|
|
TEST_ASSERT_EQUAL_INT32(100, player->currentBet);
|
|
|
|
pokerPlayerBetPot(&poker, poker.pots, i, 250);
|
|
TEST_ASSERT_EQUAL_INT32(350, player->currentBet);
|
|
}
|
|
|
|
void test_pokerPlayerBet_should_BetToTheActivePot(void) {
|
|
poker2_t poker;
|
|
poker2pot_t *pot;
|
|
uint8_t i, j;
|
|
|
|
pokerInit(&poker);
|
|
i = pokerPlayerAdd(&poker);
|
|
pokerPlayerChipsAdd(poker.players+i, 1000);
|
|
pot = poker.pots;
|
|
|
|
TEST_ASSERT_EQUAL_INT32(0, pot->chips);
|
|
pokerPlayerBet(&poker, i, 100);
|
|
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
|
|
|
|
j = pokerPotAdd(&poker);
|
|
pokerPlayerBet(&poker, i, 50);
|
|
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
|
|
pot = poker.pots + j;
|
|
TEST_ASSERT_EQUAL_INT32(50, pot->chips);
|
|
}
|
|
|
|
int test_poker() {
|
|
UNITY_BEGIN();
|
|
|
|
RUN_TEST(test_pokerInit_should_InitializePokerGame);
|
|
RUN_TEST(test_pokerResetRound_should_ResetTheRound);
|
|
RUN_TEST(test_pokerResetRound_should_ResetThePlayers);
|
|
RUN_TEST(test_pokerPotAdd_should_AddAPot);
|
|
RUN_TEST(test_pokerPotAdd_should_ResetThePot);
|
|
RUN_TEST(test_pokerNewDealer_should_FindANewDealer);
|
|
RUN_TEST(test_pokerNewDealer_should_SkipOutPlayers);
|
|
RUN_TEST(test_pokerTakeBlinds_should_TakeTheBlinds);
|
|
RUN_TEST(test_pokerPotAddPlayer_should_AddAPlayer);
|
|
RUN_TEST(test_pokerPlayerAdd_should_ResetThePlayer);
|
|
RUN_TEST(test_pokerTurn_should_TurnCardsFromTheDeck);
|
|
RUN_TEST(test_pokerBurn_should_SendCardsToTheGrave);
|
|
RUN_TEST(test_pokerGetCallValue_should_CalculateTheCallValue);
|
|
RUN_TEST(test_pokerPlayerDeal_should_DealCardsToThePlayer);
|
|
RUN_TEST(test_pokerPlayerChipsAdd_should_AddChipsToThePlayer);
|
|
RUN_TEST(test_pokerPlayerChipsAdd_should_TurnOutStateOff);
|
|
RUN_TEST(test_pokerPlayerDealAll_should_DealCardsToEveryone);
|
|
RUN_TEST(test_pokerPlayerDealAll_should_DealMultipleCardsToEveryone);
|
|
RUN_TEST(test_pokerPlayerDealAll_should_NotDealToOutPlayers);
|
|
RUN_TEST(test_pokerPlayerDealAll_should_NotDealToFoldedPlayers);
|
|
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_CheckCallValue);
|
|
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet);
|
|
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers);
|
|
RUN_TEST(test_pokerPlayerBetPot_should_AddChipsToThePot);
|
|
RUN_TEST(test_pokerPlayerBetPot_should_UpdatePlayerState);
|
|
RUN_TEST(test_pokerPlayerBet_should_BetToTheActivePot);
|
|
|
|
return UNITY_END();
|
|
} |