def test_split_6(self): """Split sixes if dealer's card is two through six.""" expected1 = True expected2 = False hand = cards.Hand([ cards.Card(6, 2), cards.Card(6, 1), ]) player = players.Player((hand, ), 'Graham') dhand = cards.Hand([ cards.Card(6, 3), cards.Card(10, 0, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual1 = willsplit.will_split_recommended(player, hand, g) self.assertEqual(expected1, actual1) hand = cards.Hand([ cards.Card(6, 2), cards.Card(6, 1), ]) player = players.Player((hand, ), 'Graham') dhand = cards.Hand([ cards.Card(7, 3), cards.Card(10, 0, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual2 = willsplit.will_split_recommended(player, hand, g) self.assertEqual(expected2, actual2)
def dealer_only(): ui = LogUI() g = game.Engine(ui=ui) loop = game.main(g) play = next(loop) while play: play = loop.send(play)
def test_has_decision_methods(self): """The players created by make_player() should have the decision methods for Players, such as will_hit and will_insure. """ # As long as no exception is raised, this test passes. phand = cards.Hand([ cards.Card(11, 3), cards.Card(1, 2), ]) dhand = cards.Hand([ cards.Card(11, 3), cards.Card(1, 2), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, None, None, 2) player = players.make_player() methods = [ player.will_hit, player.will_split, player.will_double_down, ] for method in methods: _ = method(phand, g) methods = [ player.will_buyin, player.will_insure, ] for method in methods: _ = method(g)
def test_always_true(self): """will_double_down_always() will always return True.""" g = game.Engine() h = cards.Hand() p = players.Player() actual = willdoubledown.will_double_down_always(p, h, g) self.assertTrue(actual)
def test_always_true(self): """will_buyin_always() will always return True.""" g = game.Engine() p = players.Player() p.will_buyin = partial(willbuyin.will_buyin_always, None) actual = p.will_buyin(g) self.assertTrue(actual)
def test_always_zero(self): """will_double_down_always() will always return the maximum bet, which is half of the game's buy in.""" expected = 10 h = cards.Hand() p = players.Player() g = game.Engine(None, None, (p, ), None, 20) actual = willinsure.will_insure_always(p, g) self.assertEqual(expected, actual)
def test_is_will_hit(self): """A will_hit function should accept a Player, a Hand, and a Game objects. """ player = players.Player() hand = cards.Hand([ cards.Card(11, 0), cards.Card(11, 3), ]) g = game.Engine() _ = willhit.will_hit_dealer(player, hand, g)
def test_stand(self, mock_input): """When the user chooses to split, will_split_user() returns False. """ expected = False mock_input.return_value = model.IsYes(expected) g = game.Engine(None, None, None, None, None) actual = willsplit.will_split_user(None, None, g) mock_input.assert_called() self.assertEqual(expected, actual)
def test_insure(self, mock_input): """When the user chooses to double down, will_insure_user() returns True. """ expected = 10 mock_input.return_value = model.IsYes('y') g = game.Engine(None, None, None, None, expected * 2) actual = willinsure.will_insure_user(None, g) mock_input.assert_called() self.assertEqual(expected, actual)
def test_not_double_down(self, mock_input): """When the user chooses to double down, will_double_down_user() returns False. """ expected = False mock_input.return_value = model.IsYes(expected) g = game.Engine(None, None, None, None, None) actual = willdoubledown.will_double_down_user(None, None, g) mock_input.assert_called() self.assertEqual(expected, actual)
def test_hit(self, mock_input): """When the user chooses to hit, will_hit_user() returns True. """ expected = True mock_input.return_value = model.IsYes(expected) ui = cli.TableUI() g = game.Engine(None, None, None, None, None) actual = willhit.will_hit_user(None, None, g) mock_input.assert_called() self.assertEqual(expected, actual)
def test_parameters(self): """Functions that follow the will_double_down protocol should accept the following parameters: self, hand, game. """ player = players.Player() hand = cards.Hand() g = game.Engine() _ = willdoubledown.will_double_down_always(player, hand, game) # The test was that no exception was raised when will_buyin # was called. self.assertTrue(True)
def test_parameters(self): """Functions that follow the will_insure protocol should accept the following parameters: self, game. """ player = players.Player() hand = cards.Hand() g = game.Engine() _ = willinsure.will_insure_never(player, g) # The test was that no exception was raised when will_buyin # was called. self.assertTrue(True)
def one_player(): ui = LogUI() play = True deck = cards.Deck.build(6) deck.shuffle() deck.random_cut() dealer = players.Dealer(name='Dealer') player = players.AutoPlayer(name='Player', chips=200) g = game.Engine(deck, dealer, (player, ), ui=ui, buyin=2) loop = game.main(g) play = next(loop) while play: play = loop.send(play)
def test_parameters(self): """Functions that follow the will_buyin protocol should accept the following parameter: game. """ player = players.Player() g = game.Engine() player.will_buyin = partial(willbuyin.will_buyin_always, None) player.will_buyin(game) # The test was that no exception was raised when will_buyin # was called. self.assertTrue(True)
def test_random_insure(self, mock_choice): """When called, will_insure_random() should call random.choice() and return the result. """ exp_result = 1 exp_call = call(range(0, 1)) g = game.Engine(buyin=2) act_result = willinsure.will_insure_random(None, g) act_call = mock_choice.mock_calls[-1] self.assertEqual(exp_result, act_result) self.assertEqual(exp_call, act_call)
def test_double_down_on_10(self): """If player's hand is 10 and the dealer's card is a 9 or less, the player should double down. """ expected = False phand = cards.Hand([ cards.Card(4, 0), cards.Card(5, 0), ]) player = players.Player((phand, ), 'Terry') dhand = cards.Hand([ cards.Card(1, 0), cards.Card(8, 3, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual = willdoubledown.will_double_down_recommended(player, phand, g) self.assertEqual(expected, actual) expected = False phand = cards.Hand([ cards.Card(4, 0), cards.Card(5, 0), ]) player = players.Player((phand, ), 'Terry') dhand = cards.Hand([ cards.Card(7, 0), cards.Card(8, 3, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual = willdoubledown.will_double_down_recommended(player, phand, g) self.assertEqual(expected, actual)
def test_split_2_3_or_7(self): """Split twos, threes, and sevens if the dealer's card is seven or less. """ expected1 = True expected2 = False hand = cards.Hand([ cards.Card(2, 2), cards.Card(2, 1), ]) player = players.Player((hand, ), 'Graham') dhand = cards.Hand([ cards.Card(7, 3), cards.Card(10, 0, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual1 = willsplit.will_split_recommended(player, hand, g) self.assertEqual(expected1, actual1) hand = cards.Hand([ cards.Card(2, 2), cards.Card(2, 1), ]) player = players.Player((hand, ), 'Graham') dhand = cards.Hand([ cards.Card(8, 3), cards.Card(10, 0, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual2 = willsplit.will_split_recommended(player, hand, g) self.assertEqual(expected2, actual2)
def test_paramters(self): """Functions that follow the will_split protocol should accept the following parameters: hand, player, dealer, playerlist. """ hand = cards.Hand() player = players.Player((hand, ), 'John Cleese') g = game.Engine() method = MethodType(willsplit.will_split_always, player) player.will_split = partial(willsplit.will_split_always, None) player.will_split(hand, g) # The test was that no exception was raised when will_split # was called. self.assertTrue(True)
def four_player(): p1 = players.AutoPlayer(name='John', chips=200) p2 = players.BetterPlayer(name='Michael', chips=200) p3 = players.NeverPlayer(name='Graham', chips=200) p4 = players.RandomPlayer(name='Terry', chips=200) ui = TableUI(seats=5) play = True deck = cards.Deck.build(6) deck.shuffle() deck.random_cut() dealer = players.Dealer(name='Dealer') g = game.Engine(deck, dealer, (p1, p2, p3, p4), ui=ui, buyin=2) loop = game.main(g) play = next(loop) while play: play = loop.send(play)
def two_player(): p1 = players.AutoPlayer(name='John', chips=200) p2 = players.BetterPlayer(name='Michael', chips=200) ui = LogUI() play = True deck = cards.Deck.build(6) deck.shuffle() deck.random_cut() dealer = players.Dealer(name='Dealer') g = game.Engine(deck, dealer, ( p1, p2, ), ui=ui, buyin=2) loop = game.main(g) play = next(loop) while play: play = loop.send(play)
def test_never_double_down(self): """will_double_down_never should always return False.""" expected = False phand = cards.Hand([ cards.Card(4, 0), cards.Card(6, 0), ]) player = players.Player((phand, ), 'Terry') dhand = cards.Hand([ cards.Card(11, 0), cards.Card(8, 3, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual = willdoubledown.will_double_down_never(player, phand, g) self.assertEqual(expected, actual)
def test_stand(self): """If the situation doesn't match the above criteria, stand.""" expected = False phand = cards.Hand([ cards.Card(10, 1), cards.Card(11, 2), ]) player = players.Player((phand, ), 'John') dhand = cards.Hand([ cards.Card(5, 1), cards.Card(2, 3, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, 20) actual = willhit.will_hit_recommended(None, phand, g) self.assertEqual(expected, actual)
def test_never_split(self): """will_split_never() should return False.""" expected = False hand = cards.Hand([ cards.Card(10, 2), cards.Card(10, 1), ]) player = players.Player((hand, ), 'Graham') dhand = cards.Hand([ cards.Card(7, 3), cards.Card(10, 0, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual = willsplit.will_split_never(player, hand, g) self.assertEqual(expected, actual)
def test_double_down_if_11(self): """If the player's hand is 11, player should double down.""" expected = True phand = cards.Hand([ cards.Card(5, 0), cards.Card(6, 0), ]) player = players.Player((phand, ), 'Terry') dhand = cards.Hand([ cards.Card(11, 0), cards.Card(8, 3), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual = willdoubledown.will_double_down_recommended(player, phand, g) self.assertEqual(expected, actual)
def test_stand(self): """will_hit_never() should never return True.""" expected = False phand = cards.Hand([ cards.Card(10, 1), cards.Card(11, 2), ]) player = players.Player((phand, ), 'John') dhand = cards.Hand([ cards.Card(5, 1), cards.Card(2, 3, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, 20) actual = willhit.will_hit_never(None, phand, g) self.assertEqual(expected, actual)
def test_split_ace_or_8(self): """Always split aces or eights.""" expected = True hand = cards.Hand([ cards.Card(1, 2), cards.Card(1, 1), ]) player = players.Player((hand, ), 'Graham') dhand = cards.Hand([ cards.Card(7, 3), cards.Card(10, 0, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual = willsplit.will_split_recommended(player, hand, g) self.assertEqual(expected, actual)
def test_split_4_5_or_8(self): """Never split fours, fives, or eights.""" expected = False hand = cards.Hand([ cards.Card(10, 2), cards.Card(10, 1), ]) player = players.Player((hand, ), 'Graham') dhand = cards.Hand([ cards.Card(7, 3), cards.Card(10, 0, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, None) actual = willsplit.will_split_recommended(player, hand, g) self.assertEqual(expected, actual)
def test_do_not_hit_soft_19(self): """If the player's hand is a soft 19, don't hit.""" expected = False phand = cards.Hand([ cards.Card(1, 1), cards.Card(6, 2), cards.Card(2, 2), ]) player = players.Player((phand, ), 'John') dhand = cards.Hand([ cards.Card(2, 1), cards.Card(2, 3, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, 20) actual = willhit.will_hit_recommended(None, phand, g) self.assertEqual(expected, actual)
def test_stand_bust(self): """If the hand is bust, stand.""" expected = False phand = cards.Hand(( cards.Card(8, 2), cards.Card(6, 1), cards.Card(2, 1), cards.Card(7, 2), )) player = players.Player((phand, ), 'John') dhand = cards.Hand([ cards.Card(5, 1), cards.Card(2, 3, cards.DOWN), ]) dealer = players.Dealer((dhand, ), 'Dealer') g = game.Engine(None, dealer, (player, ), None, 20) actual = willhit.will_hit_recommended(None, phand, g) self.assertEqual(expected, actual)