Dawn/test/poker/bet.c

/**
 * 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();
}