Пример #1
0
 def test_payoffs_1(self):
     game = Game()
     game.init_game()
     game.step(Action.CALL)
     game.step(Action.RAISE_HALF_POT)
     game.step(Action.FOLD)
     self.assertTrue(game.is_over())
     self.assertEqual(2, len(game.get_payoffs()))
Пример #2
0
    def test_auto_step(self):
        game = Game()

        game.init_game()
        self.assertEqual(Stage.PREFLOP, game.stage)
        game.step(Action.ALL_IN)
        game.step(Action.CALL)

        self.assertEqual(Stage.RIVER, game.stage)
Пример #3
0
 def test_all_in_to_call(self):
     game = Game()
     game.init_chips = [50, 100]
     game.dealer_id = 0
     game.init_game()
     game.step(Action.CALL)
     game.step(Action.ALL_IN)
     game.step(Action.CALL)
     self.assertTrue(game.is_over())
Пример #4
0
 def test_payoffs_1(self):
     game = Game()
     np.random.seed(0)
     game.init_game()
     game.step('call')
     game.step(4)
     game.step('fold')
     self.assertTrue(game.is_over())
     self.assertListEqual([-2.0, 2.0], game.get_payoffs())
Пример #5
0
 def test_payoffs_2(self):
     game = Game()
     np.random.seed(0)
     game.init_game()
     game.step(Action.CALL)
     game.step(Action.RAISE_POT)
     game.step(Action.ALL_IN)
     game.step(Action.FOLD)
     self.assertTrue(game.is_over())
     self.assertEqual(2, len(game.get_payoffs()))
Пример #6
0
    def test_bet_more_than_chips(self):
        game = Game()

        # test check
        game.init_game()
        player = game.players[0]
        in_chips = player.in_chips
        player.bet(50)
        self.assertEqual(50 + in_chips, player.in_chips)

        player.bet(150)
        self.assertEqual(100, player.in_chips)
Пример #7
0
    def test_all_in_rounds(self):
        game = Game()

        game.init_game()
        game.step(Action.CHECK_CALL)
        game.step(Action.CHECK_CALL)
        self.assertEqual(game.round_counter, 1)

        game.step(Action.CHECK_CALL)
        game.step(Action.ALL_IN)
        self.assertListEqual([Action.FOLD, Action.CHECK_CALL],
                             game.get_legal_actions())
        game.step(Action.CHECK_CALL)
        self.assertEqual(game.round_counter, 4)
        self.assertEqual(200, game.dealer.pot)
Пример #8
0
    def test_step(self):
        game = Game()

        # test raise
        _, player_id = game.init_game()
        init_raised = game.round.raised[player_id]
        game.step(10)
        step_raised = game.round.raised[player_id]
        self.assertEqual(init_raised+10, step_raised)

        # test call
        game.init_game()
        init_not_raise_num = game.round.not_raise_num
        game.step('call')
        step_not_raise_num = game.round.not_raise_num
        self.assertEqual(init_not_raise_num+1, step_not_raise_num)

        # test fold
        game.init_game()
        game.step('fold')
        self.assertTrue(game.round.player_folded)

        # test check
        game.init_game()
        game.step('call')
        game.step('check')
        self.assertEqual(game.round_counter, 1)
Пример #9
0
    def test_all_in(self):
        game = Game()

        _, player_id = game.init_game()
        game.step(Action.ALL_IN)
        step_raised = game.round.raised[player_id]
        self.assertEqual(100, step_raised)
        self.assertEqual(100, game.players[player_id].in_chips)
        self.assertEqual(0, game.players[player_id].remained_chips)
Пример #10
0
    def test_step(self):
        game = Game()

        # test call
        game.init_game()
        init_not_raise_num = game.round.not_raise_num
        game.step(Action.CHECK_CALL)
        step_not_raise_num = game.round.not_raise_num
        self.assertEqual(init_not_raise_num + 1, step_not_raise_num)

        # test fold
        _, player_id = game.init_game()
        game.step(Action.FOLD)

        self.assertEqual(PlayerStatus.FOLDED, game.players[player_id].status)

        # test check
        game.init_game()
        game.step(Action.CHECK_CALL)
Пример #11
0
    def test_init_game(self):

        game = Game()
        state, player_id = game.init_game()
        test_id = game.get_player_id()
        self.assertEqual(test_id, player_id)
        self.assertIn('call', state['legal_actions'])
        self.assertIn('fold', state['legal_actions'])
        for i in range(3,100):
            self.assertIn(i , state['legal_actions'])
Пример #12
0
    def test_step_2(self):
        game = Game()

        # test check
        game.init_game()
        self.assertEqual(Stage.PREFLOP, game.stage)
        game.step(Action.CALL)
        game.step(Action.RAISE_POT)
        game.step(Action.CALL)

        self.assertEqual(Stage.FLOP, game.stage)
        game.step(Action.CHECK)
        game.step(Action.CHECK)

        self.assertEqual(Stage.TURN, game.stage)
        game.step(Action.CHECK)
        game.step(Action.CHECK)

        self.assertEqual(Stage.RIVER, game.stage)
Пример #13
0
    def test_raise_half_pot(self):
        game = Game()

        _, player_id = game.init_game()
        game.step(Action.RAISE_HALF_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(2, step_raised)

        player_id = game.round.game_pointer
        game.step(Action.RAISE_HALF_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(4, step_raised)

        player_id = game.round.game_pointer
        game.step(Action.RAISE_HALF_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(5, step_raised)
Пример #14
0
    def test_raise_half_pot(self):
        game = Game()

        _, player_id = game.init_game()
        self.assertNotIn(Action.RAISE_HALF_POT,
                         game.get_legal_actions())  # Half pot equals call
        game.step(Action.CALL)
        step_raised = game.round.raised[player_id]
        self.assertEqual(2, step_raised)

        player_id = game.round.game_pointer
        game.step(Action.RAISE_HALF_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(4, step_raised)

        player_id = game.round.game_pointer
        game.step(Action.RAISE_HALF_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(5, step_raised)
Пример #15
0
    def test_raise_pot(self):
        game = Game()

        _, player_id = game.init_game()
        game.step(Action.RAISE_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(4, step_raised)

        player_id = game.round.game_pointer
        game.step(Action.RAISE_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(8, step_raised)

        player_id = game.round.game_pointer
        game.step(Action.RAISE_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(16, step_raised)

        game.step(Action.CALL)
        player_id = game.round.game_pointer
        game.step(Action.RAISE_POT)
        step_raised = game.round.raised[player_id]
        self.assertEqual(32, step_raised)
Пример #16
0
    def test_step_3_players(self):
        game = Game(num_players=3)

        # test check
        _, first_player_id = game.init_game()
        self.assertEqual(Stage.PREFLOP, game.stage)
        game.step(Action.CALL)
        game.step(Action.CALL)
        game.step(Action.RAISE_POT)
        game.step(Action.FOLD)
        game.step(Action.CALL)

        self.assertEqual(Stage.FLOP, game.stage)
        self.assertEqual((first_player_id - 2) % 3, game.round.game_pointer)
        game.step(Action.CHECK)
        game.step(Action.RAISE_POT)
        game.step(Action.CALL)

        self.assertEqual(Stage.TURN, game.stage)
        self.assertEqual((first_player_id - 2) % 3, game.round.game_pointer)
        game.step(Action.CHECK)
        game.step(Action.CHECK)

        self.assertEqual(Stage.RIVER, game.stage)
Пример #17
0
 def test_init_game(self):
     game = Game()
     state, player_id = game.init_game()
     test_id = game.get_player_id()
     self.assertEqual(test_id, player_id)
Пример #18
0
    def test_wrong_steps(self):
        game = Game()

        game.init_game()
        self.assertRaises(Exception, game.step, Action.CHECK)