def test_preflop_state1(self):
        strategy = 'snowie1'

        # preflop
        t, p, gui_signals, h, logger = init_table('tests/screenshots/76s.png',
                                                  strategy=strategy)
        p = StrategyHandler()
        p.read_strategy(strategy)
        l = MagicMock()
        t.totalPotValue = 0.5
        t.equity = 0.5
        t.checkButton = False
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "PreFlop"
        d.__init__(t, h, p, l)
        d.preflop_override(t, logger, h, p)
        preflop_state = CurrentHandPreflopState()
        bot_preflop_decision = 'Call'
        d = MagicMock()
        preflop_state.update_values(t, bot_preflop_decision, h, d)

        self.assertEqual(t.preflop_sheet_name, '6R4')

        # flop
        t, p, gui_signals, h, logger = init_table('tests/screenshots/76ss.png',
                                                  strategy=strategy)
        for abs_pos in range(5):
            if t.other_players[abs_pos]['status'] == 1:
                sheet_name = preflop_state.get_reverse_sheetname(abs_pos, t, h)

        self.assertEqual('4', sheet_name)
    def test_ranges(self):
        # preflop
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/709250829_PreFlop_0.png')
        d = reverse_init(t, h, p, logger)
        d.preflop_override(t, logger, h, p)

        self.assertEqual('3R1', t.preflop_sheet_name)

        preflop_state = CurrentHandPreflopState()
        bot_preflop_decision = 'Call'
        d = MagicMock()
        preflop_state.update_values(t, bot_preflop_decision, h, d)

        # river round 2
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/709250829_Flop_0.png')
        for abs_pos in range(5):
            if t.other_players[abs_pos]['status'] == 1:
                sheet_name = preflop_state.get_reverse_sheetname(abs_pos, t, h)
                ranges = preflop_state.get_rangecards_from_sheetname(
                    abs_pos, sheet_name, t, h, p)

        self.assertEqual('1', sheet_name)
        self.assertEqual(38, len(ranges))
    def test_ranges_call_column(self):
        # preflop
        t, p, gui_signals, h, logger = init_table('tests/screenshots/KQ2.png')
        reverse_init(t, h, p, logger)
        preflop_state = CurrentHandPreflopState()
        bot_preflop_decision = 'Bet'
        d = MagicMock()
        preflop_state.update_values(t, bot_preflop_decision, h, d)
        t, p, gui_signals, h, logger = init_table('tests/screenshots/KQ.png')
        for abs_pos in range(5):
            if t.other_players[abs_pos]['status'] == 1:
                sheet_name = preflop_state.get_reverse_sheetname(abs_pos, t, h)
                ranges = preflop_state.get_rangecards_from_sheetname(
                    abs_pos, sheet_name, t, h, p)

        self.assertEqual('42R5', sheet_name)
        self.assertEqual("Call", preflop_state.range_column_name)
    def test_reversetable_88(self):
        strategy = 'Snowie3'
        # preflop
        t, p, gui_signals, h, logger = init_table('tests/screenshots/88.png',
                                                  strategy=strategy)
        d = reverse_init(t, h, p, logger)
        preflop_state = CurrentHandPreflopState()
        bot_preflop_decision = 'Bet'
        d = MagicMock()
        preflop_state.update_values(t, bot_preflop_decision, h, d)

        # river round 2
        t, p, gui_signals, h, logger = init_table('tests/screenshots/88F.png',
                                                  strategy=strategy)
        for abs_pos in range(5):
            if t.other_players[abs_pos]['status'] == 1:
                sheet_name = preflop_state.get_reverse_sheetname(abs_pos, t, h)

        self.assertEqual('6R1', sheet_name)
    def test_preflop_state2(self):
        strategy = 'snowie1'

        # preflop
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/458770525_PreFlop_0.png', strategy=strategy)
        d = reverse_init(t, h, p, logger)
        preflop_state = CurrentHandPreflopState()
        bot_preflop_decision = 'Call'
        d = MagicMock()
        preflop_state.update_values(t, bot_preflop_decision, h, d)

        # flop
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/458770525_Flop_0.png', strategy=strategy)
        for abs_pos in range(5):
            if t.other_players[abs_pos]['status'] == 1:
                sheet_name = preflop_state.get_reverse_sheetname(abs_pos, t, h)

        self.assertEqual('3', sheet_name)
    def test_incorrect_second_round(self):
        # preflop
        t, p, gui_signals, h, logger = init_table('tests/screenshots/3R12.png')
        reverse_init(t, h, p, logger)
        preflop_state = CurrentHandPreflopState()
        bot_preflop_decision = 'Bet'
        d = MagicMock()
        d = MagicMock()
        preflop_state.update_values(t, bot_preflop_decision, h, d)
        t, p, gui_signals, h, logger = init_table('tests/screenshots/3R1.png')
        reverse_sheet_names = []
        for abs_pos in range(5):
            if t.other_players[abs_pos]['status'] == 1:
                sheet_name = preflop_state.get_reverse_sheetname(abs_pos, t, h)
                ranges = preflop_state.get_rangecards_from_sheetname(
                    abs_pos, sheet_name, t, h, p)
                reverse_sheet_names.append(sheet_name)

        self.assertEqual('3R1', reverse_sheet_names[0])
        self.assertEqual('6R1', reverse_sheet_names[1])
        self.assertEqual("Call", preflop_state.range_column_name)
Esempio n. 7
0
    def first_round_98h(self):
        t, p, gui_signals, h, logger = init_table('tests/screenshots/98h.png',
                                                  strategy='Snowie3',
                                                  round_number=0)
        t.checkButton = False
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "PreFlop"
        d.__init__(t, h, p, l)
        d.preflop_table_analyser(t, h, p)

        self.assertEqual(t.preflop_sheet_name, '4R3')
Esempio n. 8
0
    def sheet_12R4R6(self):
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/12R4R6.png', round_number=1)
        l = MagicMock()
        t.checkButton = False
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "PreFlop"
        d.__init__(t, h, p, l)
        d.preflop_table_analyser(t, h, p)

        self.assertEqual(t.preflop_sheet_name, '12R4R6')
Esempio n. 9
0
    def incorrect_preflop_table2(self):
        t, p, gui_signals, h, logger = init_table('tests/screenshots/3Ts.png',
                                                  strategy='Snowie3')
        l = MagicMock()
        t.checkButton = False
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "PreFlop"
        d.__init__(t, h, p, l)
        d.preflop_table_analyser(t, h, p)

        self.assertEqual(t.preflop_sheet_name, '6R1C2')
Esempio n. 10
0
    def second_round_with_raiser(self):
        t, p, gui_signals, h, logger = init_table('tests/screenshots/QQ.png',
                                                  strategy='Snowie3',
                                                  round_number=1)
        l = MagicMock()
        t.checkButton = False
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "PreFlop"
        d.__init__(t, h, p, l)
        d.preflop_table_analyser(t, h, p)

        self.assertEqual(t.preflop_sheet_name, '22R6')
Esempio n. 11
0
    def test_preflop_round2_3(self):
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/897376414_PreFlop_1.png', round_number=1)
        p = StrategyHandler()
        p.read_strategy('Pokemon4')
        l = MagicMock()
        t.checkButton = False
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "PreFlop"

        d.__init__(t, h, p, l)
        d.preflop_table_analyser(t, h, p)
        self.assertEqual(t.first_raiser_utg, 2)
Esempio n. 12
0
    def incorrect_preflop_table1(self):
        t, p, gui_signals, h, logger = init_table('tests/screenshots/K9o.png',
                                                  strategy='Snowie3')
        l = MagicMock()
        t.checkButton = False
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "PreFlop"
        d.__init__(t, h, p, l)
        d.preflop_table_analyser(t, h, p)

        self.assertEqual(t.first_raiser_utg, 4)
        self.assertEqual(np.isnan(t.second_raiser_utg), True)
        self.assertEqual(t.preflop_sheet_name, '6R5')
Esempio n. 13
0
    def test_position_adjustment(self):
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/467381034_PreFlop_0.png', strategy='Pokemon4')
        t.gameStage = "PreFlop"
        p = StrategyHandler()
        p.read_strategy('Nickpick12')
        l = MagicMock()
        t.checkButton = True
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "Flop"
        p.selected_strategy['FlopBluffMinEquity'] = 0.3
        p.selected_strategy['FlopBluff'] = "1"
        p.selected_strategy['pre_flop_equity_reduction_by_position'] = 0.02

        d.__init__(t, h, p, l)
        self.assertAlmostEqual(d.preflop_adjustment, 0.1, delta=0.01)
Esempio n. 14
0
    def test_preflop_call_before_raise(self):
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/1791526_PreFlop_0.png', round_number=0)
        p = StrategyHandler()
        p.read_strategy('Pokemon4')
        l = MagicMock()
        t.checkButton = False
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "PreFlop"

        d.__init__(t, h, p, l)
        d.preflop_table_analyser(t, h, p)

        self.assertEqual(t.first_raiser, 2)
        self.assertEqual(t.second_raiser, 4)

        self.assertEqual(t.preflop_sheet_name, '6R5C3')
Esempio n. 15
0
    def test_bluff(self):
        t, p, gui_signals, h, logger = init_table(
            'tests/screenshots/751235173_PreFlop_0.png')
        p = StrategyHandler()
        p.read_strategy('Pokemon')
        l = MagicMock()
        t.totalPotValue = 0.5
        t.equity = 0.7
        t.checkButton = True
        d = Decision(t, h, p, l)
        t.isHeadsUp = True
        t.gameStage = "Flop"
        p.selected_strategy['FlopBluffMinEquity'] = 0.3
        p.selected_strategy['FlopBluff'] = "1"

        d.decision = DecisionTypes.check
        t.playersAhead = 0
        d.bluff(t, p, h)
        self.assertEqual(d.decision, DecisionTypes.bet_bluff)

        d.decision = DecisionTypes.check
        t.playersAhead = 1
        d.bluff(t, p, h)
        self.assertEqual(d.decision, DecisionTypes.check)