def test_deal_cards(self):
players = [Player('Player 1', []), Player('Player 2', [])]
cards = [Card(1, 1), Card(2, 2), Card(3, 3), Card(4, 4)]
dealer = Dealer(cards)
dealer.deal_to(players)
self.assertEqual(players[0].cards, [Card(1, 1), Card(3, 3)])
self.assertEqual(players[1].cards, [Card(2, 2), Card(4, 4)])
def test_1000_random_tactic_executions(self):
cards = CardGenerator.generate([1, 2], [1, 2, 3, 4, 5])
player1 = Player('Player 1', cards=[], tactic=tactic_play_random_card)
player2 = Player('Player 2', cards=[], tactic=tactic_play_random_card)
tactics_analyser = TacticsAnalyser(cards, [player1, player2])
results = tactics_analyser.run(1000)
self.assertEqual(len(results), 2)
def test_has_better_cards(self):
player1 = Player(0)
player2 = Player(0)
card = Card(0, 'A')
player1.add_card(card)
player1._compare_cards = MagicMock()
player1.has_better_cards(player2)
player1._compare_cards.assert_called_with([[card], [], [], [], [], [], [], [], [
], [], [], []], [[], [], [], [], [], [], [], [], [], [], [], []])
def __init__(self, sid, names):
self.player = Player(names[0], auto=True)
self.opponent_names = names[1:]
self.sid = sid # session id from socketio
self.round_number = 0
self.trick_number = 0
self.state = STATE_READY
def test_get_winning_player(self):
self.player1 = Player('Player 1', [Card(1, 4), Card(1, 3)])
self.player2 = Player('Player 2', [Card(1, 2), Card(1, 1)])
self.game.round_start()
self.game.apply_action(Action(self.player1, Card(1, 4)))
self.game.apply_action(Action(self.player2, Card(1, 2)))
self.game.round_end()
self.assertEqual(self.game.get_winner(), self.player1)
self.game.round_start()
self.game.apply_action(Action(self.player1, Card(1, 3)))
self.game.apply_action(Action(self.player2, Card(1, 1)))
self.game.round_end()
self.assertEqual(self.game.get_winner(), self.player1)
def test_compare_cards_when_equal_cards(self):
player = Player(0)
cards = [[Card(0, 'A')]]
player._check_count = MagicMock()
player._check_sequence = MagicMock()
self.assertEqual(player._compare_cards(cards, cards), 0)
player._check_count.assert_not_called()
player._check_sequence.assert_not_called()
def test_compare_cards_when_cards_not_equal(self):
player = Player(0)
cards1 = [[Card(0, 'A')], []]
cards2 = [[], [Card(1, 'K')]]
mock = Mock(return_value=0)
player._check_count = mock
player._check_sequence = mock
self.assertEqual(player._compare_cards(cards1, cards2), 1)
card_param1 = [['A'], []]
card_param2 = [[], ['K']]
calls = [call(card_param1, card_param2, 3), call(
card_param1, card_param2), call(card_param1, card_param2, 2)]
mock.assert_has_calls(calls)
def test_apply_action_with_different_types(self):
self.player1 = Player('Player 1', [Card(2, 1), Card(1, 3)])
self.player2 = Player('Player 2', [Card(2, 2), Card(1, 4)])
self.game.round_start()
self.game.apply_action(Action(self.player1, Card(2, 1)))
self.game.apply_action(Action(self.player2, Card(1, 4)))
self.game.round_end()
completed_round = self.game.completed_rounds[0]
self.assertEqual(completed_round.winning_action,
Action(self.player1, Card(2, 1)))
self.game.round_start()
self.game.apply_action(Action(self.player1, Card(1, 3)))
self.game.apply_action(Action(self.player2, Card(2, 2)))
self.game.round_end()
completed_round = self.game.completed_rounds[1]
self.assertEqual(completed_round.winning_action,
Action(self.player2, Card(2, 2)))
self.assertEqual(self.player1.cards, [])
self.assertEqual(self.player2.cards, [])
def test_remove_player(self):
card_game = CardGame([0, 1])
card_game._remove_player(Player(1))
self.assertTrue(1 not in card_game._available_players)
def setUp(self):
self.player = Player()
def test_check_count_when_triplet_and_sequence(self):
player = Player(0)
self.assertEqual(player._check_count(
[[], ['K', 'K', 'K']], [['A'], ['K'], ['Q']], 3), 1)
def test_show_cards(self):
player = Player(0)
try:
player.show_cards()
except Exception:
self.fail("show_cards() raised Exception unexpectedly!")
def setUp(self):
self.player1 = Player('Player 1')
self.player2 = Player('Player 2')
self.game = MultiValCardGame([self.player1, self.player2])
def setUp(self):
self.player = Player()
self.cards = [Card('red', 1), Card('green', 3)]
self.deck = Deck(self.cards)
self.emptyDeck = Deck([])
self.player_with_cards = Player(self.cards)
def test_init(self):
"""Test Player initial instance variables. """
player = Player(0)
self.assertEqual(player.get_id(), 0)
self.assertIsInstance(player.get_cards(), list)
def test_add_card(self):
player = Player(0)
init_count = len(player.get_cards()[0])
player.add_card(Card(0, 'A'))
self.assertEqual(len(player.get_cards()[0]), init_count + 1)
return total
# Loop that runs to start a new hand.
while True:
# Initialize and shuffle new deck.
deck = Deck()
deck.shuffle()
# Initialize player and dealer then deals cards to them. Set values to determine if beginning of hand and if player
# chose to stand or not.
player = Player()
dealer = Player()
player.draw(deck)
dealer.draw(deck)
player.draw(deck)
dealer.draw(deck)
first_hand = True
player_stand = False
# Loop that runs while player is playing current hand. Once player stands the dealer will finish drawing cards as
# needed, calculate hands and determine whether it was a win loss or draw for the player.
while True:
def test_reset_card(self):
player = Player(0)
init_cards = player.get_cards()
player.add_card(Card(0, 'A'))
player.reset_card()
self.assertEqual(player.get_cards(), init_cards)
def test_check_sequence_when_sequece_and_pair(self):
player = Player(0)
self.assertEqual(player._check_sequence(
[['A'], ['K'], ['Q']], [['A'], ['K', 'K']]), 1)
def test_check_count_when_two_triplet(self):
player = Player(0)
self.assertEqual(player._check_count(
[[], ['K', 'K', 'K']], [['A', 'A', 'A'], []], 3), -1)
def test_check_sequence_when_two_sequece(self):
player = Player(0)
self.assertEqual(player._check_sequence(
[['A'], ['K'], ['Q'], []], [[], ['K'], ['Q'], ['10']]), 1)
def setUp(self):
self.player1 = Player('Player 1', [Card(4, 1), Card(2, 1)])
self.player2 = Player('Player 2', [Card(1, 1), Card(3, 1)])
self.players = [self.player1, self.player2]
self.game = MultiValCardGame(self.players)
def main():
hearts = Hearts([Player("ID1","A"), Player("ID2","B"), Player("ID3","C"), Player("ID4","D")])
