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

Split the bet tests out.

Browse Source
This commit is contained in:
Dominic Masters
2021-10-14 22:40:33 -07:00
parent d79929762a
commit 466cb1e2b9
17 changed files with 266 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

186
test/poker/bet.c Normal file
View File

@ -0,0 +1,186 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "bet.h"
void test_pokerBetGetNextPlayer_should_GetTheNextBetter(void) {
poker_t poker;
uint8_t p0, p1, p2, p3, p4;
pokerInit(&poker);
p0 = pokerPlayerAdd(&poker);
p1 = pokerPlayerAdd(&poker);
p2 = pokerPlayerAdd(&poker);
p3 = pokerPlayerAdd(&poker);
p4 = pokerPlayerAdd(&poker);
pokerPlayerChipsAdd(poker.players + p0, 10000);
pokerPlayerChipsAdd(poker.players + p1, 10000);
pokerPlayerChipsAdd(poker.players + p2, 10000);
pokerPlayerChipsAdd(poker.players + p3, 10000);
pokerPlayerChipsAdd(poker.players + p4, 10000);
pokerDealerNew(&poker);
// Start at blind+1
poker.better = poker.playerBigBlind;
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x04, poker.better);
// Blind+2
pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker));
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x00, poker.better);
// BLind+3
pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker));
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x01, poker.better);
// Dealer
pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker));
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x02, poker.better);
// Small blind
pokerBetForPlayer(
&poker, poker.better,
pokerBetGetCurrentCallValue(&poker) - poker.players[0x02].currentBet
);
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x03, poker.better);
// Big Blind
pokerBetForPlayer(
&poker, poker.better,
pokerBetGetCurrentCallValue(&poker) - poker.players[0x03].currentBet
);
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0xFF, poker.better);
// Raise
poker.better = poker.playerBigBlind;
pokerBetForPlayer(&poker, poker.better, 100);
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x04, poker.better);
// Raise
pokerBetForPlayer(&poker, poker.better, 100);
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x00, poker.better);
}
void test_pokerBetGetRemainingBetterCount_should_ReturnCountNeedsToBet(void){
poker_t poker;
uint8_t p0, p1, p2;
pokerInit(&poker);
p0 = pokerPlayerAdd(&poker);
p1 = pokerPlayerAdd(&poker);
p2 = pokerPlayerAdd(&poker);
TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingBetterCount(&poker));
pokerPlayerChipsAdd(poker.players + p0, 1000);
TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingBetterCount(&poker));
pokerPlayerChipsAdd(poker.players + p2, 1000);
TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingBetterCount(&poker));
pokerPlayerChipsAdd(poker.players + p1, 1000);
TEST_ASSERT_EQUAL_UINT8(0x03, pokerBetGetRemainingBetterCount(&poker));
poker.players[0].state |= POKER_PLAYER_STATE_FOLDED;
TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingBetterCount(&poker));
poker.players[1].state |= POKER_PLAYER_STATE_HAS_BET_THIS_ROUND;
TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingBetterCount(&poker));
poker.players[2].chips = 0;
TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingBetterCount(&poker));
}
void test_pokerBet_should_AddChipsToThePot(void) {
poker_t poker;
pokerpot_t *pot;
pokerplayer_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(0, pot->call);
TEST_ASSERT_EQUAL_INT32(1000, player->chips);
pokerBet(&poker, pot, i, 100);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
TEST_ASSERT_EQUAL_INT32(100, pot->call);
TEST_ASSERT_EQUAL_INT32(900, player->chips);
pokerBet(&poker, pot, i, 100);
TEST_ASSERT_EQUAL_INT32(200, pot->chips);
TEST_ASSERT_EQUAL_INT32(100, pot->call);
TEST_ASSERT_EQUAL_INT32(800, player->chips);
}
void test_pokerBet_should_UpdatePlayerState(void) {
poker_t poker;
uint8_t i;
pokerplayer_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);
TEST_ASSERT_EQUAL_UINT8(0, player->timesRaised);
pokerBet(&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);
TEST_ASSERT_EQUAL_UINT8(1, player->timesRaised);
pokerBet(&poker, poker.pots, i, 250);
TEST_ASSERT_EQUAL_INT32(350, player->currentBet);
TEST_ASSERT_EQUAL_UINT8(2, player->timesRaised);
}
void test_pokerBetForPlayer_should_BetToTheActivePot(void) {
poker_t poker;
pokerpot_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);
pokerBetForPlayer(&poker, i, 100);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
j = pokerPotAdd(&poker);
pokerBetForPlayer(&poker, i, 50);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
pot = poker.pots + j;
TEST_ASSERT_EQUAL_INT32(50, pot->chips);
}
int test_bet_h() {
UNITY_BEGIN();
// RUN_TEST(test_pokerBetGetRemainingPlayer_should_ReturnRemainingBetters);
RUN_TEST(test_pokerBetGetNextPlayer_should_GetTheNextBetter);
RUN_TEST(test_pokerBetGetRemainingBetterCount_should_ReturnCountNeedsToBet);
RUN_TEST(test_pokerBet_should_AddChipsToThePot);
RUN_TEST(test_pokerBet_should_UpdatePlayerState);
RUN_TEST(test_pokerBetForPlayer_should_BetToTheActivePot);
return UNITY_END();
}

10
test/poker/bet.h Normal file
View File

@ -0,0 +1,10 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include <unity.h>
#include <poker/bet.h>
int test_bet_h();

218
test/poker/poker.c
View File

@ -220,7 +220,7 @@ void test_pokerTakeBlinds_should_TakeTheBlinds(void) {
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 3)->chips);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 4)->chips);
pokerTakeBlinds(&poker, 100, 200);
pokerTakeBlinds(&poker);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 1)->chips);
@ -229,7 +229,7 @@ void test_pokerTakeBlinds_should_TakeTheBlinds(void) {
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 4)->chips);
pokerDealerNew(&poker);
pokerTakeBlinds(&poker, 100, 200);
pokerTakeBlinds(&poker);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 0)->chips);
TEST_ASSERT_EQUAL_INT32(1000, (poker.players + 1)->chips);
@ -257,6 +257,7 @@ void test_pokerPotAdd_should_ResetThePot(void) {
pot = poker.pots + i;
TEST_ASSERT_EQUAL_UINT8(0, pot->playerCount);
TEST_ASSERT_EQUAL_INT32(0, pot->chips);
TEST_ASSERT_EQUAL_INT32(0, pot->call);
}
void test_pokerPotHasPlayer_should_DetermineIfPlayerInThePot(void) {
@ -647,125 +648,6 @@ void test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers(void) {
TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
}
void test_pokerBetGetRemainingPlayer_should_ReturnRemainingBetters(void) {
poker_t poker;
uint8_t p0, p1, p2, p3, p4;
pokerInit(&poker);
p0 = pokerPlayerAdd(&poker);
p1 = pokerPlayerAdd(&poker);
p2 = pokerPlayerAdd(&poker);
p3 = pokerPlayerAdd(&poker);
p4 = pokerPlayerAdd(&poker);
pokerPlayerChipsAdd(poker.players + p0, 10000);
pokerPlayerChipsAdd(poker.players + p1, 10000);
pokerPlayerChipsAdd(poker.players + p2, 10000);
pokerPlayerChipsAdd(poker.players + p3, 10000);
pokerPlayerChipsAdd(poker.players + p4, 10000);
pokerDealerNew(&poker);
// Blind + 1
TEST_ASSERT_EQUAL(0x04, pokerBetGetRemainingPlayer(&poker));
// Blind + 2
pokerBetForPlayer(&poker, 0x04, pokerBetGetCurrentCallValue(&poker));
TEST_ASSERT_EQUAL(0x00, pokerBetGetRemainingPlayer(&poker));
// Blind + 3
pokerBetForPlayer(&poker, 0x00, pokerBetGetCurrentCallValue(&poker));
TEST_ASSERT_EQUAL(0x01, pokerBetGetRemainingPlayer(&poker));
// Blind + 4 / Small Blind
pokerBetForPlayer(&poker, 0x01, pokerBetGetCurrentCallValue(&poker));
TEST_ASSERT_EQUAL(0x02, pokerBetGetRemainingPlayer(&poker));
// Blind + 5 / Big Blind
pokerBetForPlayer(
&poker, 0x02, pokerBetGetCurrentCallValue(&poker) - poker.players[0x01].currentBet
);
TEST_ASSERT_EQUAL(0x03, pokerBetGetRemainingPlayer(&poker));
// No remaining players.
pokerBetForPlayer(&poker, 0x03, 0);
TEST_ASSERT_EQUAL(0xFF, pokerBetGetRemainingPlayer(&poker));
// Raise
pokerBetForPlayer(&poker, 0x03, 100);
TEST_ASSERT_EQUAL(0x04, pokerBetGetRemainingPlayer(&poker));
// Raise
pokerBetForPlayer(&poker, 0x04, 100);
TEST_ASSERT_EQUAL(0x00, pokerBetGetRemainingPlayer(&poker));
}
void test_pokerBetGetNextPlayer_should_GetTheNextBetter(void) {
poker_t poker;
uint8_t p0, p1, p2, p3, p4;
pokerInit(&poker);
p0 = pokerPlayerAdd(&poker);
p1 = pokerPlayerAdd(&poker);
p2 = pokerPlayerAdd(&poker);
p3 = pokerPlayerAdd(&poker);
p4 = pokerPlayerAdd(&poker);
pokerPlayerChipsAdd(poker.players + p0, 10000);
pokerPlayerChipsAdd(poker.players + p1, 10000);
pokerPlayerChipsAdd(poker.players + p2, 10000);
pokerPlayerChipsAdd(poker.players + p3, 10000);
pokerPlayerChipsAdd(poker.players + p4, 10000);
pokerDealerNew(&poker);
// Start at blind+1
poker.better = poker.playerBigBlind;
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x04, poker.better);
// Blind+2
pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker));
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x00, poker.better);
// BLind+3
pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker));
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x01, poker.better);
// Dealer
pokerBetForPlayer(&poker, poker.better, pokerBetGetCurrentCallValue(&poker));
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x02, poker.better);
// Small blind
pokerBetForPlayer(
&poker, poker.better,
pokerBetGetCurrentCallValue(&poker) - poker.players[0x02].currentBet
);
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x03, poker.better);
// Big Blind
pokerBetForPlayer(
&poker, poker.better,
pokerBetGetCurrentCallValue(&poker) - poker.players[0x03].currentBet
);
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0xFF, poker.better);
// Raise
poker.better = poker.playerBigBlind;
pokerBetForPlayer(&poker, poker.better, 100);
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x04, poker.better);
// Raise
pokerBetForPlayer(&poker, poker.better, 100);
poker.better = pokerBetGetNextPlayer(&poker);
TEST_ASSERT_EQUAL_UINT8(0x00, poker.better);
}
void test_pokerPlayerGetCallBet_should_GetCallBet(void) {
poker_t poker;
uint8_t p0, p1, p2;
@ -817,94 +699,6 @@ void test_pokerInRoundGetCount_should_ReturnCountOfPlayersInRound(void) {
TEST_ASSERT_EQUAL_UINT8(0x00, pokerInRoundGetCount(&poker));
}
void test_pokerBetGetRemainingPlayerCount_should_ReturnCountNeedsToBet(void){
poker_t poker;
uint8_t p0, p1, p2;
pokerInit(&poker);
p0 = pokerPlayerAdd(&poker);
p1 = pokerPlayerAdd(&poker);
p2 = pokerPlayerAdd(&poker);
TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingPlayerCount(&poker));
pokerPlayerChipsAdd(poker.players + p0, 1000);
TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingPlayerCount(&poker));
pokerPlayerChipsAdd(poker.players + p2, 1000);
TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingPlayerCount(&poker));
pokerPlayerChipsAdd(poker.players + p1, 1000);
TEST_ASSERT_EQUAL_UINT8(0x03, pokerBetGetRemainingPlayerCount(&poker));
poker.players[0].state |= POKER_PLAYER_STATE_FOLDED;
TEST_ASSERT_EQUAL_UINT8(0x02, pokerBetGetRemainingPlayerCount(&poker));
poker.players[1].state |= POKER_PLAYER_STATE_HAS_BET_THIS_ROUND;
TEST_ASSERT_EQUAL_UINT8(0x01, pokerBetGetRemainingPlayerCount(&poker));
poker.players[2].chips = 0;
TEST_ASSERT_EQUAL_UINT8(0x00, pokerBetGetRemainingPlayerCount(&poker));
}
void test_pokerBet_should_AddChipsToThePot(void) {
poker_t poker;
pokerpot_t *pot;
pokerplayer_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);
pokerBet(&poker, pot, i, 100);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
TEST_ASSERT_EQUAL_INT32(900, player->chips);
}
void test_pokerBet_should_UpdatePlayerState(void) {
poker_t poker;
uint8_t i;
pokerplayer_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);
pokerBet(&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);
pokerBet(&poker, poker.pots, i, 250);
TEST_ASSERT_EQUAL_INT32(350, player->currentBet);
}
void test_pokerBetForPlayer_should_BetToTheActivePot(void) {
poker_t poker;
pokerpot_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);
pokerBetForPlayer(&poker, i, 100);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
j = pokerPotAdd(&poker);
pokerBetForPlayer(&poker, i, 50);
TEST_ASSERT_EQUAL_INT32(100, pot->chips);
pot = poker.pots + j;
TEST_ASSERT_EQUAL_INT32(50, pot->chips);
}
void test_pokerPlayerCanCheck_should_CompareThePotAndPlayerBet(void) {
poker_t poker;
uint8_t p0, p1, p2;
@ -1613,14 +1407,8 @@ int test_poker() {
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_CheckCallValue);
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet);
RUN_TEST(test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers);
RUN_TEST(test_pokerBetGetRemainingPlayer_should_ReturnRemainingBetters);
RUN_TEST(test_pokerBetGetNextPlayer_should_GetTheNextBetter);
RUN_TEST(test_pokerPlayerGetCallBet_should_GetCallBet);
RUN_TEST(test_pokerInRoundGetCount_should_ReturnCountOfPlayersInRound);
RUN_TEST(test_pokerBetGetRemainingPlayerCount_should_ReturnCountNeedsToBet);
RUN_TEST(test_pokerBet_should_AddChipsToThePot);
RUN_TEST(test_pokerBet_should_UpdatePlayerState);
RUN_TEST(test_pokerBetForPlayer_should_BetToTheActivePot);
RUN_TEST(test_pokerPlayerCanCheck_should_CompareThePotAndPlayerBet);
RUN_TEST(test_pokerTurnFold_should_ReturnAFoldAction);
RUN_TEST(test_pokerTurnBet_should_ReturnACheckAction);