/**
 * 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) {
  poker_t poker;
  pokerInit(&poker);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerCount);
  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) {
  poker_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) {
  poker_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_UINT8(0, poker.players[i].timesRaised);
    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_SHOWING, poker.players[i].state);
  }
}

void test_pokerResetBettingRound_should_ResetTheBettingRound(void) {
  poker_t poker;
  uint8_t i;

  pokerInit(&poker);
  poker.better = 0x32;
  pokerPlayerAdd(&poker);
  pokerPlayerAdd(&poker);
  pokerPlayerAdd(&poker);


  for(i = 0; i < poker.playerCount; i++) {
    pokerPlayerChipsAdd(poker.players + i, 1000);
  };

  pokerResetBettingRound(&poker);
  TEST_ASSERT_EQUAL_UINT8(0x01, poker.better);

  for(i = 0; i < poker.playerCount; i++) {
    TEST_ASSERT_BITS_LOW(
      POKER_PLAYER_STATE_HAS_BET_THIS_ROUND, poker.players[i].state
    );
  }
}

void test_pokerDealerNew_should_FindANewDealer(void) {
  poker_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);

  pokerDealerNew(&poker);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(2, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);

  pokerDealerNew(&poker);
  TEST_ASSERT_EQUAL_UINT8(2, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(4, poker.playerBigBlind);

  pokerDealerNew(&poker);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(4, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);

  pokerDealerNew(&poker);
  TEST_ASSERT_EQUAL_UINT8(4, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);
}

void test_pokerDealerSet_should_SetANewSetOfPlayers(void) {
  poker_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);
  
  pokerDealerSet(&poker, 0x00);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(2, poker.playerBigBlind);

  pokerDealerSet(&poker, 0x01);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(2, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);

  pokerDealerSet(&poker, 0x02);
  TEST_ASSERT_EQUAL_UINT8(2, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(4, poker.playerBigBlind);

  pokerDealerSet(&poker, 0x03);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(4, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);

  pokerDealerSet(&poker, 0x04);
  TEST_ASSERT_EQUAL_UINT8(4, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);

  pokerDealerSet(&poker, 0x00);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(2, poker.playerBigBlind);
}

void test_pokerDealerSet_should_SkipOutPlayers(void) {
  poker_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);

  pokerDealerSet(&poker, 0x00);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerBigBlind);
  
  pokerDealerSet(&poker, 0x01);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerBigBlind);
  
  pokerDealerSet(&poker, 0x02);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);

  pokerDealerSet(&poker, 0x03);
  TEST_ASSERT_EQUAL_UINT8(3, poker.playerDealer);
  TEST_ASSERT_EQUAL_UINT8(0, poker.playerSmallBlind);
  TEST_ASSERT_EQUAL_UINT8(1, poker.playerBigBlind);

  pokerDealerSet(&poker, 0x04);
  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) {
  poker_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);

  pokerDealerNew(&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);
  
  pokerDealerNew(&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) {
  poker_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) {
  poker_t poker;
  pokerpot_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_pokerPotHasPlayer_should_DetermineIfPlayerInThePot(void) {
  poker_t poker;
  pokerpot_t *pot;
  uint8_t p0, p1, p2;

  pokerInit(&poker);
  p0 = pokerPlayerAdd(&poker);
  p1 = pokerPlayerAdd(&poker);
  p2 = pokerPlayerAdd(&poker);

  pot = poker.pots + 0;
  TEST_ASSERT_EQUAL(false, pokerPotHasPlayer(pot, p0));
  TEST_ASSERT_EQUAL(false, pokerPotHasPlayer(pot, p1));
  TEST_ASSERT_EQUAL(false, pokerPotHasPlayer(pot, p2));

  pokerPotAddPlayer(pot, p0);
  TEST_ASSERT_EQUAL(true, pokerPotHasPlayer(pot, p0));
  TEST_ASSERT_EQUAL(false, pokerPotHasPlayer(pot, p1));
  TEST_ASSERT_EQUAL(false, pokerPotHasPlayer(pot, p2));

  pokerPotAddPlayer(pot, p2);
  TEST_ASSERT_EQUAL(true, pokerPotHasPlayer(pot, p0));
  TEST_ASSERT_EQUAL(false, pokerPotHasPlayer(pot, p1));
  TEST_ASSERT_EQUAL(true, pokerPotHasPlayer(pot, p2));

  pokerPotAddPlayer(pot, p1);
  TEST_ASSERT_EQUAL(true, pokerPotHasPlayer(pot, p0));
  TEST_ASSERT_EQUAL(true, pokerPotHasPlayer(pot, p1));
  TEST_ASSERT_EQUAL(true, pokerPotHasPlayer(pot, p2));

  pokerPotAdd(&poker);
  pot = poker.pots + 1;

  pokerPotAddPlayer(pot, p1);
  TEST_ASSERT_EQUAL(false, pokerPotHasPlayer(pot, p0));
  TEST_ASSERT_EQUAL(true, pokerPotHasPlayer(pot, p1));
  TEST_ASSERT_EQUAL(false, pokerPotHasPlayer(pot, p2));
}

void test_pokerPotAddPlayer_should_AddAPlayer(void) {
  poker_t poker;
  pokerpot_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) {
  poker_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) {
  poker_t poker;
  pokerplayer_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(0, player->timesRaised);
  TEST_ASSERT_EQUAL_UINT8(POKER_PLAYER_STATE_OUT, player->state);
}

void test_pokerDealerTurn_should_TurnCardsFromTheDeck(void) {
  poker_t poker;
  pokerInit(&poker);

  TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
  TEST_ASSERT_EQUAL_UINT8(0, poker.communitySize);

  pokerDealerTurn(&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]);

  pokerDealerTurn(&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_pokerDealerBurn_should_SendCardsToTheGrave(void) {
  poker_t poker;
  pokerInit(&poker);

  TEST_ASSERT_EQUAL_UINT8(CARD_DECK_SIZE, poker.deckSize);
  TEST_ASSERT_EQUAL_UINT8(0, poker.graveSize);

  pokerDealerBurn(&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]);

  pokerDealerBurn(&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_pokerBetGetCurrentCallValue_should_CalculateTheCallValue(void) {
  poker_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, pokerBetGetCurrentCallValue(&poker));
  pokerBetForPlayer(&poker, first, 100);
  TEST_ASSERT_EQUAL_INT32(100, pokerBetGetCurrentCallValue(&poker));
  pokerBetForPlayer(&poker, second, 150);
  TEST_ASSERT_EQUAL_INT32(150, pokerBetGetCurrentCallValue(&poker));

  pokerPotAdd(&poker);
  TEST_ASSERT_EQUAL_INT32(150, pokerBetGetCurrentCallValue(&poker));
  TEST_ASSERT_EQUAL_INT32(0, poker.pots[1].chips);
  pokerBetForPlayer(&poker, second, 50);
  TEST_ASSERT_EQUAL_INT32(200, pokerBetGetCurrentCallValue(&poker));
  TEST_ASSERT_EQUAL_INT32(50, poker.pots[1].chips);
}

void test_pokerBetGetCurrentCallValue_should_SkipOutPlayers(void) {
  poker_t poker;
  uint8_t i;
  pokerInit(&poker);
  
  i = pokerPlayerAdd(&poker);
  pokerPlayerChipsAdd(poker.players + i, 10000);
  pokerBetForPlayer(&poker, i, 300);
  
  i = pokerPlayerAdd(&poker);
  pokerPlayerChipsAdd(poker.players + i, 10000);
  pokerBetForPlayer(&poker, i, 500);

  i = pokerPlayerAdd(&poker);
  pokerPlayerChipsAdd(poker.players + i, 10000);
  pokerBetForPlayer(&poker, i, 200);
  
  TEST_ASSERT_EQUAL_INT32(500, pokerBetGetCurrentCallValue(&poker));
  poker.players[1].state |= POKER_PLAYER_STATE_OUT;
  TEST_ASSERT_EQUAL_INT32(300, pokerBetGetCurrentCallValue(&poker));
  poker.players[0].state |= POKER_PLAYER_STATE_OUT;
  TEST_ASSERT_EQUAL_INT32(200, pokerBetGetCurrentCallValue(&poker));
}

void test_pokerDeal_should_DealCardsToThePlayer(void) {
  poker_t poker;
  uint8_t playerIndex;
  pokerplayer_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);

  pokerDeal(&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]);

  pokerDeal(&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) {
  poker_t poker;
  uint8_t playerIndex;
  pokerplayer_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) {
  poker_t poker;
  uint8_t playerIndex;
  pokerplayer_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_pokerDealAllPlayers_should_DealCardsToEveryone(void) {
  poker_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);
  
  pokerDealAllPlayers(&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_pokerDealAllPlayers_should_DealMultipleCardsToEveryone(void) {
  poker_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);
  
  pokerDealAllPlayers(&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_pokerDealAllPlayers_should_NotDealToOutPlayers(void) {
  poker_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);
  
  pokerDealAllPlayers(&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_pokerDealAllPlayers_should_NotDealToFoldedPlayers(void) {
  poker_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;

  pokerDealAllPlayers(&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) {
  poker_t poker;
  uint8_t first, second;

  pokerInit(&poker);

  first = pokerPlayerAdd(&poker);
  second = pokerPlayerAdd(&poker);
  pokerPlayerChipsAdd(poker.players + first, 10000);
  pokerPlayerChipsAdd(poker.players + second, 10000);

  pokerBetForPlayer(&poker, first, 100);
  TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
  TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));
  
  pokerBetForPlayer(&poker, second, 200);
  TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, first));
  TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));

  pokerBetForPlayer(&poker, first, 100);
  TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
  TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
}

void test_pokerPlayerDoesNeedToBetThisRound_should_CheckWhetherHasBetYet(void) {
  poker_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));

  pokerBetForPlayer(&poker, first, 100);
  TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
  TEST_ASSERT_EQUAL(true, pokerPlayerDoesNeedToBetThisRound(&poker, second));

  pokerBetForPlayer(&poker, second, 100);
  TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
  TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, second));
}

void test_pokerPlayerDoesNeedToBetThisRound_should_IgnoreFoldedPlayers(void) {
  poker_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));

  pokerBetForPlayer(&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));

  pokerBetForPlayer(&poker, first, 100);
  TEST_ASSERT_EQUAL(false, pokerPlayerDoesNeedToBetThisRound(&poker, first));
  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;

  pokerInit(&poker);
  p0 = pokerPlayerAdd(&poker);
  p1 = pokerPlayerAdd(&poker);
  p2 = pokerPlayerAdd(&poker);

  pokerBetForPlayer(&poker, p0, 100);
  TEST_ASSERT_EQUAL_INT32(0, pokerPlayerGetCallBet(&poker,poker.players+p0));
  TEST_ASSERT_EQUAL_INT32(100, pokerPlayerGetCallBet(&poker,poker.players+p1));
  TEST_ASSERT_EQUAL_INT32(100, pokerPlayerGetCallBet(&poker,poker.players+p2));

  pokerBetForPlayer(&poker, p1, 200);
  TEST_ASSERT_EQUAL_INT32(100, pokerPlayerGetCallBet(&poker,poker.players+p0));
  TEST_ASSERT_EQUAL_INT32(0, pokerPlayerGetCallBet(&poker,poker.players+p1));
  TEST_ASSERT_EQUAL_INT32(200, pokerPlayerGetCallBet(&poker,poker.players+p2));

  pokerBetForPlayer(&poker, p2, 300);
  TEST_ASSERT_EQUAL_INT32(200, pokerPlayerGetCallBet(&poker,poker.players+p0));
  TEST_ASSERT_EQUAL_INT32(100, pokerPlayerGetCallBet(&poker,poker.players+p1));
  TEST_ASSERT_EQUAL_INT32(0, pokerPlayerGetCallBet(&poker,poker.players+p2));
}

void test_pokerInRoundGetCount_should_ReturnCountOfPlayersInRound(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, pokerInRoundGetCount(&poker));

  pokerPlayerChipsAdd(poker.players + p0, 10000);
  TEST_ASSERT_EQUAL_UINT8(0x01, pokerInRoundGetCount(&poker));
  pokerPlayerChipsAdd(poker.players + p1, 10000);
  TEST_ASSERT_EQUAL_UINT8(0x02, pokerInRoundGetCount(&poker));
  pokerPlayerChipsAdd(poker.players + p2, 10000);
  TEST_ASSERT_EQUAL_UINT8(0x03, pokerInRoundGetCount(&poker));

  poker.players[0].state |= POKER_PLAYER_STATE_FOLDED;
  TEST_ASSERT_EQUAL_UINT8(0x02, pokerInRoundGetCount(&poker));
  poker.players[1].state |= POKER_PLAYER_STATE_FOLDED;
  TEST_ASSERT_EQUAL_UINT8(0x01, pokerInRoundGetCount(&poker));
  poker.players[2].state |= POKER_PLAYER_STATE_OUT;
  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;
  pokerInit(&poker);

  p0 = pokerPlayerAdd(&poker);
  p1 = pokerPlayerAdd(&poker);
  p2 = pokerPlayerAdd(&poker);
  pokerPlayerChipsAdd(poker.players + p0, 1000);
  pokerPlayerChipsAdd(poker.players + p1, 1000);
  pokerPlayerChipsAdd(poker.players + p2, 1000);

  pokerBetForPlayer(&poker, p0, 100);
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p0));
  TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p1));
  TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p2));

  pokerBetForPlayer(&poker, p1, 100);
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p0));
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p1));
  TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p2));

  pokerBetForPlayer(&poker, p2, 100);
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p0));
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p1));
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p2));

  pokerBetForPlayer(&poker, p2, 100);
  TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p0));
  TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p1));
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p2));

  pokerBetForPlayer(&poker, p1, 100);
  TEST_ASSERT_EQUAL(false, pokerPlayerCanCheck(&poker, poker.players+p0));
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p1));
  TEST_ASSERT_EQUAL(true, pokerPlayerCanCheck(&poker, poker.players+p2));
}

void test_pokerTurnFold_should_ReturnAFoldAction(void) {
  poker_t poker;
  pokerturn_t turn;
  pokerInit(&poker);
  pokerPlayerAdd(&poker);

  turn = pokerTurnFold(&poker, 0x00);
  TEST_ASSERT_EQUAL_INT32(0, turn.chips);
  TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_FOLD, turn.type);
  TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);
}

void test_pokerTurnBet_should_ReturnACheckAction(void) {
  poker_t poker;
  pokerturn_t turn;
  pokerInit(&poker);
  pokerPlayerAdd(&poker);

  turn = pokerTurnBet(&poker, 0x00, 0);
  TEST_ASSERT_EQUAL_INT32(0, turn.chips);
  TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_CHECK, turn.type);
  TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);
}

void test_pokerTurnBet_should_ReturnAnAllInAction(void) {
  poker_t poker;
  pokerturn_t turn;
  pokerInit(&poker);
  pokerPlayerAdd(&poker);
  pokerPlayerChipsAdd(poker.players, 500);

  turn = pokerTurnBet(&poker, 0x00, 500);
  TEST_ASSERT_EQUAL_INT32(500, turn.chips);
  TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_ALL_IN, turn.type);
  TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);

  pokerPlayerChipsAdd(poker.players, 500);
  turn = pokerTurnBet(&poker, 0x00, 1001);
  TEST_ASSERT_EQUAL_INT32(1000, turn.chips);
  TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_ALL_IN, turn.type);
  TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);
}

void test_pokerTurnBet_should_ReturnACallAction(void) {
  poker_t poker;
  pokerturn_t turn;
  pokerInit(&poker);
  pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
  pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);
  
  pokerBetForPlayer(&poker, 0, 300);
  pokerBetForPlayer(&poker, 1, 500);

  turn = pokerTurnBet(&poker, 0x00, 200);
  TEST_ASSERT_EQUAL_INT32(200, turn.chips);
  TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_CALL, turn.type);
  TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);

  pokerBetForPlayer(&poker, 0, 300);
  turn = pokerTurnBet(&poker, 0x01, 100);
  TEST_ASSERT_EQUAL_INT32(100, turn.chips);
  TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_CALL, turn.type);
  TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);
}

void test_pokerTurnBet_should_ReturnARaiseAction(void) {
  poker_t poker;
  pokerturn_t turn;
  pokerInit(&poker);
  pokerPlayerChipsAdd(poker.players + pokerPlayerAdd(&poker), 1000);

  turn = pokerTurnBet(&poker, 0x00, 300);
  TEST_ASSERT_EQUAL_INT32(300, turn.chips);
  TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_BET, turn.type);
  TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);

  turn = pokerTurnBet(&poker, 0x00, 200);
  TEST_ASSERT_EQUAL_INT32(200, turn.chips);
  TEST_ASSERT_EQUAL_UINT8(POKER_TURN_TYPE_BET, turn.type);
  TEST_ASSERT_EQUAL_FLOAT(1.0f, turn.confidence);
}

void test_pokerPlayerGetFullHand_should_ReturnTheFullHand(void) {
  poker_t poker;
  pokerplayer_t *player;
  uint8_t i;
  card_t cards[POKER_WINNING_FULL_SIZE];

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;
  
  pokerDeal(&poker, player, POKER_PLAYER_HAND_SIZE_MAX);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, player->cards[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, player->cards[1]);

  pokerDealerTurn(&poker, POKER_COMMUNITY_SIZE_MAX);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, poker.community[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, poker.community[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TEN, poker.community[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_NINE, poker.community[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_EIGHT, poker.community[4]);

  pokerPlayerGetFullHand(&poker, player, cards);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, cards[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, cards[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TEN, cards[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_NINE, cards[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_EIGHT, cards[4]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, cards[5]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, cards[6]);

  poker.community[0] = CARD_CLUBS_THREE;
  poker.community[1] = CARD_DIAMONDS_TWO;
  poker.community[2] = CARD_SPADES_EIGHT;
  poker.community[3] = CARD_DIAMONDS_ACE;
  poker.community[4] = CARD_SPADES_FIVE;
  player->cards[0] = CARD_DIAMONDS_KING;
  player->cards[1] = CARD_HEARTS_QUEEN;

  pokerPlayerGetFullHand(&poker, player, cards);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_THREE, cards[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_TWO, cards[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_EIGHT, cards[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_ACE, cards[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_FIVE, cards[4]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_KING, cards[5]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_QUEEN, cards[6]);
}

void test_pokerWinnerFillRemaining_should_FillTheRestOfTheArray(void) {
  pokerplayerwinning_t winning;
  winning.fullSize = 7;
  winning.full[0]  = CARD_CLUBS_ACE;
  winning.full[1]  = CARD_CLUBS_TWO;
  winning.full[2]  = CARD_CLUBS_THREE;
  winning.full[3]  = CARD_CLUBS_FOUR;
  winning.full[4]  = CARD_CLUBS_FIVE;
  winning.full[5]  = CARD_CLUBS_SIX;
  winning.full[6]  = CARD_CLUBS_SEVEN;

  cardHandSort(winning.full, 7);

  winning.setSize = 1;
  winning.set[0] = CARD_CLUBS_ACE;
  
  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]);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_SIX, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_FIVE, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_FOUR, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculateHighCard(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_HEARTS_QUEEN;
  poker.community[1] = CARD_CLUBS_TWO;
  poker.community[2] = CARD_DIAMONDS_ACE;
  poker.community[3] = CARD_SPADES_NINE;
  poker.community[4] = CARD_HEARTS_SIX;

  player->cardCount = 2;
  player->cards[0] = CARD_CLUBS_FOUR;
  player->cards[1] = CARD_DIAMONDS_SEVEN;

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_FULL_SIZE, winning.fullSize);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_HIGH_CARD, winning.type);

  TEST_ASSERT_EQUAL_UINT8(0x05, winning.setSize);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_ACE, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_SEVEN, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_QUEEN, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_SIX, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_NINE, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculatePair(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_HEARTS_QUEEN;
  poker.community[1] = CARD_CLUBS_TWO;
  poker.community[2] = CARD_DIAMONDS_ACE;
  poker.community[3] = CARD_SPADES_QUEEN;
  poker.community[4] = CARD_HEARTS_SIX;

  player->cardCount = 2;
  player->cards[0] = CARD_CLUBS_FOUR;
  player->cards[1] = CARD_DIAMONDS_SEVEN;

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_FULL_SIZE, winning.fullSize);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_PAIR, winning.type);

  TEST_ASSERT_EQUAL_UINT8(0x05, winning.setSize);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_ACE, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_SEVEN, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_QUEEN, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_SIX, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, winning.set[4]);

  poker.community[3] = CARD_SPADES_NINE;
  player->cards[0] = CARD_HEARTS_TWO;
  
  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_PAIR, winning.type);
  TEST_ASSERT_EQUAL_UINT8(0x05, winning.setSize);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_TWO, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_ACE, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_QUEEN, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_TWO, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_NINE, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculateTwoPair(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_HEARTS_ACE;
  poker.community[1] = CARD_CLUBS_THREE;
  poker.community[2] = CARD_SPADES_ACE;
  poker.community[3] = CARD_SPADES_QUEEN;
  poker.community[4] = CARD_HEARTS_SIX;
  player->cardCount = 2;
  player->cards[0] = CARD_CLUBS_TWO;
  player->cards[1] = CARD_DIAMONDS_TWO;

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_TWO_PAIR, winning.type);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_TWO, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_TWO, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_ACE, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculateThreeOfAKind(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_HEARTS_ACE;
  poker.community[1] = CARD_CLUBS_THREE;
  poker.community[2] = CARD_SPADES_TWO;
  poker.community[3] = CARD_SPADES_QUEEN;
  poker.community[4] = CARD_HEARTS_SIX;
  player->cardCount = 2;
  player->cards[0] = CARD_CLUBS_TWO;
  player->cards[1] = CARD_DIAMONDS_TWO;

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_THREE_OF_A_KIND, winning.type);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_TWO, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_TWO, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_ACE, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TWO, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculateAStraight(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_HEARTS_ACE;//0 - 3
  poker.community[1] = CARD_CLUBS_THREE;//2 - 1
  poker.community[2] = CARD_SPADES_THREE;//Hmm?
  poker.community[3] = CARD_SPADES_QUEEN;
  poker.community[4] = CARD_HEARTS_FOUR;//3 - 4
  player->cardCount = 2;
  player->cards[0] = CARD_CLUBS_TWO;//1 - 0
  player->cards[1] = CARD_DIAMONDS_FIVE;//4 - 2

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_STRAIGHT, winning.type);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_THREE, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_TWO, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_FIVE, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_ACE, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_FOUR, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculateAFlush(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_HEARTS_ACE;
  poker.community[1] = CARD_SPADES_SIX;//+2
  poker.community[2] = CARD_SPADES_THREE;//+3
  poker.community[3] = CARD_SPADES_QUEEN;//+1
  poker.community[4] = CARD_HEARTS_NINE;
  player->cardCount = 2;
  player->cards[0] = CARD_SPADES_TWO;//+4
  player->cards[1] = CARD_SPADES_KING;//+0

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_FLUSH, winning.type);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_SIX, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_THREE, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TWO, winning.set[4]);
}

void test_pokerWinnerGet_should_CalculateFullHouse(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_HEARTS_ACE;
  poker.community[1] = CARD_SPADES_SIX;
  poker.community[2] = CARD_SPADES_ACE;
  poker.community[3] = CARD_SPADES_QUEEN;
  poker.community[4] = CARD_DIAMONDS_TWO;
  player->cardCount = 2;
  player->cards[0] = CARD_SPADES_TWO;
  player->cards[1] = CARD_CLUBS_TWO;

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_FULL_HOUSE, winning.type);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_TWO, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_TWO, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_ACE, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TWO, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculateFourOfAKind(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_HEARTS_TWO;
  poker.community[1] = CARD_DIAMONDS_TWO;
  poker.community[2] = CARD_SPADES_TWO;
  poker.community[3] = CARD_SPADES_QUEEN;
  poker.community[4] = CARD_SPADES_ACE;
  player->cardCount = 2;
  player->cards[0] = CARD_CLUBS_TWO;
  player->cards[1] = CARD_SPADES_KING;

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_FOUR_OF_A_KIND, winning.type);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_TWO, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_DIAMONDS_TWO, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_TWO, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TWO, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculateStraightFlush(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_DIAMONDS_ACE;
  poker.community[1] = CARD_HEARTS_SIX;
  poker.community[2] = CARD_HEARTS_THREE;
  poker.community[3] = CARD_SPADES_QUEEN;
  poker.community[4] = CARD_HEARTS_FOUR;
  player->cardCount = 2;
  player->cards[0] = CARD_HEARTS_TWO;
  player->cards[1] = CARD_HEARTS_FIVE;

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_STRAIGHT_FLUSH, winning.type);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_SIX, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_FIVE, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_FOUR, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_THREE, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_HEARTS_TWO, winning.set[4]);
}

void test_pokerWinnerGetForPlayer_should_CalculateRoyalFlush(void) {
  poker_t poker;
  uint8_t i;
  pokerplayer_t *player;
  pokerplayerwinning_t winning;

  pokerInit(&poker);
  i = pokerPlayerAdd(&poker);
  player = poker.players + i;

  poker.communitySize = 5;
  poker.community[0] = CARD_DIAMONDS_ACE;
  poker.community[1] = CARD_HEARTS_SIX;
  poker.community[2] = CARD_SPADES_TEN;
  poker.community[3] = CARD_SPADES_QUEEN;
  poker.community[4] = CARD_SPADES_JACK;
  player->cardCount = 2;
  player->cards[0] = CARD_SPADES_KING;
  player->cards[1] = CARD_SPADES_ACE;

  pokerWinnerGetForPlayer(&poker, player, &winning);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_ROYAL_FLUSH, winning.type);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_ACE, winning.set[0]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_KING, winning.set[1]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_QUEEN, winning.set[2]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_JACK, winning.set[3]);
  TEST_ASSERT_EQUAL_UINT8(CARD_SPADES_TEN, winning.set[4]);
}

void test_pokerWinnerCompare_should_CompareWinningHands(void) {
  poker_t poker;
  uint8_t p0i, p1i;
  pokerplayer_t *p0;
  pokerplayer_t *p1;
  pokerplayerwinning_t w0, w1;
  card_t kicker;

  // Construct two hands of the same type (pairs of eights)
  pokerInit(&poker);
  p0i = pokerPlayerAdd(&poker);
  p1i = pokerPlayerAdd(&poker);
  p0 = poker.players + p0i;
  p1 = poker.players + p1i;

  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[4] = CARD_HEARTS_EIGHT;

  p0->cardCount = 2;
  p0->cards[0] = CARD_CLUBS_EIGHT;
  p0->cards[1] = CARD_CLUBS_KING;//Higher, Kicker

  p1->cardCount = 2;
  p1->cards[0] = CARD_SPADES_EIGHT;
  p1->cards[1] = CARD_CLUBS_QUEEN;//Low, not

  // Confirm both hands are pairs.
  pokerWinnerGetForPlayer(&poker, p0, &w0);
  pokerWinnerGetForPlayer(&poker, p1, &w1);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_PAIR, w0.type);
  TEST_ASSERT_EQUAL_UINT8(POKER_WINNING_TYPE_PAIR, w1.type);
  TEST_ASSERT_EQUAL_UINT8(w0.type, w1.type);

  // Get the kicker, should be the king.
  kicker = pokerWinnerCompare(&w0, &w1);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_KING, kicker);

  // Change the kickers
  p0->cards[1] = CARD_HEARTS_ACE;
  p1->cards[1] = CARD_CLUBS_KING;
  pokerWinnerGetForPlayer(&poker, p0, &w0);
  pokerWinnerGetForPlayer(&poker, p1, &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 = pokerWinnerCompare(&w0, &w1);
  TEST_ASSERT_EQUAL_UINT8(0xFF, kicker);
}

void test_pokerWinnerDetermine_should_DecideTheWinnerCorrectly(void) {
  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];
  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_DIAMONDS_SIX;
  poker.community[4] = CARD_HEARTS_EIGHT;

  // Set up the player hands
  p0->cardCount = 2;
  p0->cards[0] = CARD_CLUBS_EIGHT;
  p0->cards[1] = CARD_CLUBS_KING;//Higher, Kicker

  p1->cardCount = 2;
  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,
    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_PAIR, winners[1].type);
  TEST_ASSERT_EQUAL_UINT8(CARD_CLUBS_KING, winners[0].kicker);
  TEST_ASSERT_EQUAL_UINT8(0, winnerPlayers[0]);
  TEST_ASSERT_EQUAL_UINT8(0, participants[0]);
  TEST_ASSERT_EQUAL_UINT8(1, participants[1]);

  // ----- //
  // Test a difference in hands.
  p1->cards[1] = CARD_CLUBS_NINE;// Makes p1 have two pair.
  pokerWinnerDetermineForPot(
    &poker, poker.pots + 0,
    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]);

  // 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_poker() {
  UNITY_BEGIN();

  RUN_TEST(test_pokerInit_should_InitializePokerGame);
  RUN_TEST(test_pokerResetRound_should_ResetTheRound);
  RUN_TEST(test_pokerResetRound_should_ResetThePlayers);
  RUN_TEST(test_pokerResetBettingRound_should_ResetTheBettingRound);
  RUN_TEST(test_pokerPotAdd_should_AddAPot);
  RUN_TEST(test_pokerPotAdd_should_ResetThePot);
  RUN_TEST(test_pokerPotHasPlayer_should_DetermineIfPlayerInThePot);
  RUN_TEST(test_pokerDealerNew_should_FindANewDealer);
  RUN_TEST(test_pokerDealerSet_should_SetANewSetOfPlayers);
  RUN_TEST(test_pokerDealerSet_should_SkipOutPlayers);
  RUN_TEST(test_pokerTakeBlinds_should_TakeTheBlinds);
  RUN_TEST(test_pokerPotAddPlayer_should_AddAPlayer);
  RUN_TEST(test_pokerPlayerAdd_should_ResetThePlayer);
  RUN_TEST(test_pokerDealerTurn_should_TurnCardsFromTheDeck);
  RUN_TEST(test_pokerDealerBurn_should_SendCardsToTheGrave);
  RUN_TEST(test_pokerBetGetCurrentCallValue_should_CalculateTheCallValue);
  RUN_TEST(test_pokerDeal_should_DealCardsToThePlayer);
  RUN_TEST(test_pokerPlayerChipsAdd_should_AddChipsToThePlayer);
  RUN_TEST(test_pokerPlayerChipsAdd_should_TurnOutStateOff);
  RUN_TEST(test_pokerDealAllPlayers_should_DealCardsToEveryone);
  RUN_TEST(test_pokerDealAllPlayers_should_DealMultipleCardsToEveryone);
  RUN_TEST(test_pokerDealAllPlayers_should_NotDealToOutPlayers);
  RUN_TEST(test_pokerDealAllPlayers_should_NotDealToFoldedPlayers);
  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);
  RUN_TEST(test_pokerTurnBet_should_ReturnAnAllInAction);
  RUN_TEST(test_pokerTurnBet_should_ReturnACallAction);
  RUN_TEST(test_pokerTurnBet_should_ReturnARaiseAction);
  RUN_TEST(test_pokerPlayerGetFullHand_should_ReturnTheFullHand);
  RUN_TEST(test_pokerWinnerFillRemaining_should_FillTheRestOfTheArray);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculateHighCard);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculatePair);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculateTwoPair);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculateThreeOfAKind);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculateAStraight);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculateAFlush);
  RUN_TEST(test_pokerWinnerGet_should_CalculateFullHouse);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculateFourOfAKind);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculateStraightFlush);
  RUN_TEST(test_pokerWinnerGetForPlayer_should_CalculateRoyalFlush);
  RUN_TEST(test_pokerWinnerCompare_should_CompareWinningHands);
  RUN_TEST(test_pokerWinnerDetermine_should_DecideTheWinnerCorrectly);

  return UNITY_END();
}