YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Started merging new poker code in.

Browse Source
This commit is contained in:
Dominic Masters
2021-10-09 15:43:26 -07:00
parent aff317b904
commit 131c59fbf6
41 changed files with 1380 additions and 1083 deletions
Download Patch File Download Diff File Expand all files Collapse all files

249
test/poker2/poker.c → test/poker/poker.c
View File

@ -8,7 +8,7 @@
#include "poker.h"
void test_pokerInit_should_InitializePokerGame(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerCount);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
@ -17,7 +17,7 @@ void test_pokerInit_should_InitializePokerGame(void) {
}
void test_pokerResetRound_should_ResetTheRound(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
poker.potCount = 0x03;
@ -34,7 +34,7 @@ void test_pokerResetRound_should_ResetTheRound(void) {
}
void test_pokerResetRound_should_ResetThePlayers(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
pokerInit(&poker);
@ -56,7 +56,10 @@ void test_pokerResetRound_should_ResetThePlayers(void) {
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_BITS_LOW(
POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, poker.players[i].state
);
TEST_ASSERT_BITS_LOW(POKER_PLAYER_STATE_SHOWING, poker.players[i].state);
TEST_ASSERT_EQUAL_UINT8(
0xFF - POKER_PLAYER_STATE_FOLDED - POKER_PLAYER_STATE_HAS_BET_THIS_ROUND,
poker.players[i].state
@ -65,7 +68,7 @@ void test_pokerResetRound_should_ResetThePlayers(void) {
}
void test_pokerNewDealer_should_FindANewDealer(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
@ -101,7 +104,7 @@ void test_pokerNewDealer_should_FindANewDealer(void) {
void test_pokerNewDealer_should_SkipOutPlayers(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
@ -127,7 +130,7 @@ void test_pokerNewDealer_should_SkipOutPlayers(void) {
}
void test_pokerTakeBlinds_should_TakeTheBlinds(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
@ -163,7 +166,7 @@ void test_pokerTakeBlinds_should_TakeTheBlinds(void) {
}
void test_pokerPotAdd_should_AddAPot(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
TEST_ASSERT_EQUAL_UINT8(1, poker.potCount);
@ -172,8 +175,8 @@ void test_pokerPotAdd_should_AddAPot(void) {
}
void test_pokerPotAdd_should_ResetThePot(void) {
poker2_t poker;
poker2pot_t *pot;
poker_t poker;
pokerpot_t *pot;
uint8_t i;
pokerInit(&poker);
@ -184,8 +187,8 @@ void test_pokerPotAdd_should_ResetThePot(void) {
}
void test_pokerPotAddPlayer_should_AddAPlayer(void) {
poker2_t poker;
poker2pot_t *pot;
poker_t poker;
pokerpot_t *pot;
pokerInit(&poker);
pokerPlayerAdd(&poker);
@ -204,7 +207,7 @@ void test_pokerPotAddPlayer_should_AddAPlayer(void) {
}
void test_pokerPlayerAdd_should_AddAPlayer(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
TEST_ASSERT_EQUAL_UINT8(0, poker.playerCount);
@ -215,8 +218,8 @@ void test_pokerPlayerAdd_should_AddAPlayer(void) {
}
void test_pokerPlayerAdd_should_ResetThePlayer(void) {
poker2_t poker;
poker2player_t *player;
poker_t poker;
pokerplayer_t *player;
pokerInit(&poker);
player = poker.players + pokerPlayerAdd(&poker);
@ -227,7 +230,7 @@ void test_pokerPlayerAdd_should_ResetThePlayer(void) {
}
void test_pokerTurn_should_TurnCardsFromTheDeck(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
@ -247,7 +250,7 @@ void test_pokerTurn_should_TurnCardsFromTheDeck(void) {
}
void test_pokerBurn_should_SendCardsToTheGrave(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
@ -268,7 +271,7 @@ void test_pokerBurn_should_SendCardsToTheGrave(void) {
}
void test_pokerGetCallValue_should_CalculateTheCallValue(void) {
poker2_t poker;
poker_t poker;
uint8_t first, second;
pokerInit(&poker);
first = pokerPlayerAdd(&poker);
@ -291,7 +294,7 @@ void test_pokerGetCallValue_should_CalculateTheCallValue(void) {
}
void test_pokerGetCallValue_should_SkipOutPlayers(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
pokerInit(&poker);
@ -315,9 +318,9 @@ void test_pokerGetCallValue_should_SkipOutPlayers(void) {
}
void test_pokerPlayerDeal_should_DealCardsToThePlayer(void) {
poker2_t poker;
poker_t poker;
uint8_t playerIndex;
poker2player_t *player;
pokerplayer_t *player;
pokerInit(&poker);
@ -339,9 +342,9 @@ void test_pokerPlayerDeal_should_DealCardsToThePlayer(void) {
}
void test_pokerPlayerChipsAdd_should_AddChipsToThePlayer(void) {
poker2_t poker;
poker_t poker;
uint8_t playerIndex;
poker2player_t *player;
pokerplayer_t *player;
pokerInit(&poker);
playerIndex = pokerPlayerAdd(&poker);
@ -357,9 +360,9 @@ void test_pokerPlayerChipsAdd_should_AddChipsToThePlayer(void) {
}
void test_pokerPlayerChipsAdd_should_TurnOutStateOff(void) {
poker2_t poker;
poker_t poker;
uint8_t playerIndex;
poker2player_t *player;
pokerplayer_t *player;
pokerInit(&poker);
playerIndex = pokerPlayerAdd(&poker);
@ -372,7 +375,7 @@ void test_pokerPlayerChipsAdd_should_TurnOutStateOff(void) {
}
void test_pokerPlayerDealAll_should_DealCardsToEveryone(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
@ -396,7 +399,7 @@ void test_pokerPlayerDealAll_should_DealCardsToEveryone(void) {
}
void test_pokerPlayerDealAll_should_DealMultipleCardsToEveryone(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
@ -420,7 +423,7 @@ void test_pokerPlayerDealAll_should_DealMultipleCardsToEveryone(void) {
}
void test_pokerPlayerDealAll_should_NotDealToOutPlayers(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
@ -442,7 +445,7 @@ void test_pokerPlayerDealAll_should_NotDealToOutPlayers(void) {
}
void test_pokerPlayerDealAll_should_NotDealToFoldedPlayers(void) {
poker2_t poker;
poker_t poker;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 100);
@ -462,7 +465,7 @@ void test_pokerPlayerDealAll_should_NotDealToFoldedPlayers(void) {
}
void test_pokerPlayerDoesNeedToBetThisRound_should_CheckCallValue(void) {
poker2_t poker;
poker_t poker;
uint8_t first, second;
pokerInit(&poker);
@ -486,7 +489,7 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_CheckCallValue(void) {
}
void test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet(void) {
poker2_t poker;
poker_t poker;
uint8_t first, second;
pokerInit(&poker);
first = pokerPlayerAdd(&poker);
@ -507,7 +510,7 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet(void) {
}
void test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers(void) {
poker2_t poker;
poker_t poker;
uint8_t first, second;
pokerInit(&poker);
first = pokerPlayerAdd(&poker);
@ -532,7 +535,7 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers(void) {
}
void test_pokerPlayerGetRemainingBetter_should_ReturnRemainingBetters(void) {
poker2_t poker;
poker_t poker;
uint8_t p0, p1, p2, p3, p4;
pokerInit(&poker);
@ -585,7 +588,7 @@ void test_pokerPlayerGetRemainingBetter_should_ReturnRemainingBetters(void) {
}
void test_pokerPlayerGetNextBetter_should_GetTheNextBetter(void) {
poker2_t poker;
poker_t poker;
uint8_t p0, p1, p2, p3, p4;
uint8_t better;
pokerInit(&poker);
@ -650,7 +653,7 @@ void test_pokerPlayerGetNextBetter_should_GetTheNextBetter(void) {
}
void test_pokerPlayerGetCallBet_should_GetCallBet(void) {
poker2_t poker;
poker_t poker;
uint8_t p0, p1, p2;
pokerInit(&poker);
@ -675,9 +678,9 @@ void test_pokerPlayerGetCallBet_should_GetCallBet(void) {
}
void test_pokerPlayerBetPot_should_AddChipsToThePot(void) {
poker2_t poker;
poker2pot_t *pot;
poker2player_t *player;
poker_t poker;
pokerpot_t *pot;
pokerplayer_t *player;
uint8_t i;
pokerInit(&poker);
@ -695,9 +698,9 @@ void test_pokerPlayerBetPot_should_AddChipsToThePot(void) {
}
void test_pokerPlayerBetPot_should_UpdatePlayerState(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
pokerplayer_t *player;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -716,8 +719,8 @@ void test_pokerPlayerBetPot_should_UpdatePlayerState(void) {
}
void test_pokerPlayerBet_should_BetToTheActivePot(void) {
poker2_t poker;
poker2pot_t *pot;
poker_t poker;
pokerpot_t *pot;
uint8_t i, j;
pokerInit(&poker);
@ -737,7 +740,7 @@ void test_pokerPlayerBet_should_BetToTheActivePot(void) {
}
void test_pokerPlayerCanCheck_should_CompareThePotAndPlayerBet(void) {
poker2_t poker;
poker_t poker;
uint8_t p0, p1, p2;
pokerInit(&poker);
@ -775,8 +778,8 @@ void test_pokerPlayerCanCheck_should_CompareThePotAndPlayerBet(void) {
}
void test_pokerTurnFold_should_ReturnAFoldAction(void) {
poker2_t poker;
poker2turn_t turn;
poker_t poker;
pokerturn_t turn;
pokerInit(&poker);
pokerPlayerAdd(&poker);
@ -787,8 +790,8 @@ void test_pokerTurnFold_should_ReturnAFoldAction(void) {
}
void test_pokerTurnBet_should_ReturnACheckAction(void) {
poker2_t poker;
poker2turn_t turn;
poker_t poker;
pokerturn_t turn;
pokerInit(&poker);
pokerPlayerAdd(&poker);
@ -799,8 +802,8 @@ void test_pokerTurnBet_should_ReturnACheckAction(void) {
}
void test_pokerTurnBet_should_ReturnAnAllInAction(void) {
poker2_t poker;
poker2turn_t turn;
poker_t poker;
pokerturn_t turn;
pokerInit(&poker);
pokerPlayerAdd(&poker);
pokerPlayerChipsAdd(poker.players, 500);
@ -818,8 +821,8 @@ void test_pokerTurnBet_should_ReturnAnAllInAction(void) {
}
void test_pokerTurnBet_should_ReturnACallAction(void) {
poker2_t poker;
poker2turn_t turn;
poker_t poker;
pokerturn_t turn;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
@ -840,8 +843,8 @@ void test_pokerTurnBet_should_ReturnACallAction(void) {
}
void test_pokerTurnBet_should_ReturnARaiseAction(void) {
poker2_t poker;
poker2turn_t turn;
poker_t poker;
pokerturn_t turn;
pokerInit(&poker);
pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
@ -857,8 +860,8 @@ void test_pokerTurnBet_should_ReturnARaiseAction(void) {
}
void test_pokerHandGetFull_should_ReturnTheFullHand(void) {
poker2_t poker;
poker2player_t *player;
poker_t poker;
pokerplayer_t *player;
uint8_t i;
card_t cards[POKER_WINNING_FULL_SIZE];
@ -905,7 +908,7 @@ void test_pokerHandGetFull_should_ReturnTheFullHand(void) {
}
void test_pokerWinnerFillRemaining_should_FillTheRestOfTheArray(void) {
poker2playerwinning_t winning;
pokerplayerwinning_t winning;
winning.fullSize = 7;
winning.full[0] = CARD_CLUBS_ACE;
winning.full[1] = CARD_CLUBS_TWO;
@ -920,7 +923,7 @@ void test_pokerWinnerFillRemaining_should_FillTheRestOfTheArray(void) {
winning.setSize = 1;
winning.set[0] = CARD_CLUBS_ACE;
debug_WinnerFillRemaining(&winning);
pokerWinnerFillRemaining(&winning);
TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_SET_SIZE, winning.setSize);
TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_ACE, winning.set[0]);
TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_SEVEN, winning.set[1]);
@ -930,10 +933,10 @@ void test_pokerWinnerFillRemaining_should_FillTheRestOfTheArray(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculateHighCard(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -963,10 +966,10 @@ void test_pokerWinnerGetForPlayer_should_CalculateHighCard(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculatePair(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1008,10 +1011,10 @@ void test_pokerWinnerGetForPlayer_should_CalculatePair(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculateTwoPair(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1037,10 +1040,10 @@ void test_pokerWinnerGetForPlayer_should_CalculateTwoPair(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculateThreeOfAKind(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1066,10 +1069,10 @@ void test_pokerWinnerGetForPlayer_should_CalculateThreeOfAKind(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculateAStraight(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1095,10 +1098,10 @@ void test_pokerWinnerGetForPlayer_should_CalculateAStraight(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculateAFlush(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1124,10 +1127,10 @@ void test_pokerWinnerGetForPlayer_should_CalculateAFlush(void) {
}
void test_pokerWinnerGet_should_CalculateFullHouse(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1153,10 +1156,10 @@ void test_pokerWinnerGet_should_CalculateFullHouse(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculateFourOfAKind(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1182,10 +1185,10 @@ void test_pokerWinnerGetForPlayer_should_CalculateFourOfAKind(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculateStraightFlush(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1211,10 +1214,10 @@ void test_pokerWinnerGetForPlayer_should_CalculateStraightFlush(void) {
}
void test_pokerWinnerGetForPlayer_should_CalculateRoyalFlush(void) {
poker2_t poker;
poker_t poker;
uint8_t i;
poker2player_t *player;
poker2playerwinning_t winning;
pokerplayer_t *player;
pokerplayerwinning_t winning;
pokerInit(&poker);
i = pokerPlayerAdd(&poker);
@ -1240,11 +1243,11 @@ void test_pokerWinnerGetForPlayer_should_CalculateRoyalFlush(void) {
}
void test_pokerWinnerCompare_should_CompareWinningHands(void) {
poker2_t poker;
poker_t poker;
uint8_t p0i, p1i;
poker2player_t *p0;
poker2player_t *p1;
poker2playerwinning_t w0, w1;
pokerplayer_t *p0;
pokerplayer_t *p1;
pokerplayerwinning_t w0, w1;
card_t kicker;
// Construct two hands of the same type (pairs of eights)
@ -1277,7 +1280,7 @@ void test_pokerWinnerCompare_should_CompareWinningHands(void) {
TEST_ASSERT_EQUAL_UINT8(w0.type, w1.type);
// Get the kicker, should be the king.
kicker = debug_pokerWinnerCompare(&w0, &w1);
kicker = pokerWinnerCompare(&w0, &w1);
TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_KING, kicker);
// Change the kickers
@ -1285,48 +1288,53 @@ void test_pokerWinnerCompare_should_CompareWinningHands(void) {
p1->cards[1] = CARD_CLUBS_KING;
pokerWinnerGetForPlayer(&poker, p0, &w0);
pokerWinnerGetForPlayer(&poker, p1, &w1);
kicker = debug_pokerWinnerCompare(&w0, &w1);
kicker = pokerWinnerCompare(&w0, &w1);
TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_ACE, kicker);
// Low left weight
p0->cards[1] = CARD_HEARTS_JACK;
pokerWinnerGetForPlayer(&poker, p0, &w0);
kicker = debug_pokerWinnerCompare(&w0, &w1);
kicker = pokerWinnerCompare(&w0, &w1);
TEST_ASSERT_EQUAL_UINT8(0xFF, kicker);
}
void test_pokerWinnerDetermine_should_DecideTheWinnerCorrectly(void) {
poker2_t poker;
uint8_t p0i, p1i;
poker2player_t *p0;
poker2player_t *p1;
poker_t poker;
uint8_t p0i, p1i, p2i;
pokerplayer_t *p0;
pokerplayer_t *p1;
pokerplayer_t *p2;
// Outputs
uint8_t winnerCount, participantCount;
uint8_t winnerPlayers[POKER_PLAYER_COUNT_MAX];
uint8_t participants[POKER_PLAYER_COUNT_MAX];
poker2playerwinning_t winners[POKER_PLAYER_COUNT_MAX];
pokerplayerwinning_t winners[POKER_PLAYER_COUNT_MAX];
// Set up the players
pokerInit(&poker);
p0i = pokerPlayerAdd(&poker);
p1i = pokerPlayerAdd(&poker);
p2i = pokerPlayerAdd(&poker);
p0 = poker.players + p0i;
p1 = poker.players + p1i;
p2 = poker.players + p2i;
pokerPotAddPlayer(poker.pots + 0, p0i);
pokerPotAddPlayer(poker.pots + 0, p1i);
pokerPotAddPlayer(poker.pots + 0, p2i);
pokerPlayerChipsAdd(p0, 10000);
pokerPlayerChipsAdd(p1, 10000);
pokerPlayerChipsAdd(p2, 10000);
// Set up the community
poker.communitySize = 5;
poker.community[0] = CARD_HEARTS_TWO;
poker.community[1] = CARD_DIAMONDS_NINE;
poker.community[2] = CARD_DIAMONDS_FOUR;
poker.community[3] = CARD_CLUBS_SIX;
poker.community[3] = CARD_DIAMONDS_SIX;
poker.community[4] = CARD_HEARTS_EIGHT;
// Set up the player hands
@ -1338,6 +1346,11 @@ void test_pokerWinnerDetermine_should_DecideTheWinnerCorrectly(void) {
p1->cards[0] = CARD_SPADES_EIGHT;
p1->cards[1] = CARD_CLUBS_QUEEN;//Low, not
p2->state |= POKER_PLAYER_STATE_FOLDED;// Start folded
p2->cardCount = 2;
p2->cards[0] = CARD_DIAMONDS_TWO;
p2->cards[1] = CARD_DIAMONDS_KING;
// Run first test.
pokerWinnerDetermineForPot(
&poker, poker.pots + 0,
@ -1369,10 +1382,44 @@ void test_pokerWinnerDetermine_should_DecideTheWinnerCorrectly(void) {
TEST_ASSERT_EQUAL_UINT8(1, winnerPlayers[0]);
TEST_ASSERT_EQUAL_UINT8(0, participants[0]);
TEST_ASSERT_EQUAL_UINT8(1, participants[1]);
// Unfold p2
p2->state = flagOff(p2->state, POKER_PLAYER_STATE_FOLDED);
pokerWinnerDetermineForPot(
&poker, poker.pots + 0,
winners, winnerPlayers, &winnerCount,
participants, &participantCount
);
TEST_ASSERT_EQUAL_UINT8(1, winnerCount);
TEST_ASSERT_EQUAL_UINT8(3, participantCount);
TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_PAIR, winners[0].type);
TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_TWO_PAIR, winners[1].type);
TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_FLUSH, winners[2].type);
TEST_ASSERT_EQUAL_UINT8(2, winnerPlayers[0]);
TEST_ASSERT_EQUAL_UINT8(0, participants[0]);
TEST_ASSERT_EQUAL_UINT8(1, participants[1]);
TEST_ASSERT_EQUAL_UINT8(2, participants[2]);
// Create a new pot that P2 isn't participating in.
pokerPotAdd(&poker);
pokerPotAddPlayer(poker.pots + 1, p0i);
pokerPotAddPlayer(poker.pots + 1, p1i);
pokerWinnerDetermineForPot(
&poker, poker.pots + 1,
winners, winnerPlayers, &winnerCount,
participants, &participantCount
);
TEST_ASSERT_EQUAL_UINT8(1, winnerCount);
TEST_ASSERT_EQUAL_UINT8(2, participantCount);
TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_PAIR, winners[0].type);
TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_TWO_PAIR, winners[1].type);
TEST_ASSERT_EQUAL_UINT8(1, winnerPlayers[0]);
TEST_ASSERT_EQUAL_UINT8(0, participants[0]);
TEST_ASSERT_EQUAL_UINT8(1, participants[1]);
}
int test_poker2() {
int test_poker() {
UNITY_BEGIN();
RUN_TEST(test_pokerInit_should_InitializePokerGame);

0
test/poker2/poker.h → test/poker/poker.h
View File