def test_corner_bets_for_top_edge(self):
ocs = [
Outcome(self.corner_bet_name + ' 1-2-4-5', self.corner_bet_odds),
Outcome(self.corner_bet_name + ' 2-3-5-6', self.corner_bet_odds)
]
for exp in ocs:
self.assertTrue(exp in self.wheel.get_bin(2))
def test_is_valid_with_bets_exceeding_limit(self):
bet1 = Bet(291, Outcome("Red", 1))
bet2 = Bet(10, Outcome("Red", 1))
self.table.place_bet(bet1)
self.assertTrue(self.table.is_valid())
self.table.place_bet(bet2)
self.assertRaises(InvalidBet, self.table.is_valid)
def test_get_outcome(self):
self.assertEqual(self.test_wheel.get_outcome("Red"),
Outcome(Game.RED_BET_NAME, Game.EVEN_MONEY_BET_ODDS))
self.assertEqual(self.test_wheel.get_outcome("Five 00-0-1-2-3"),
Outcome(Game.FIVE_BET_NAME, Game.FIVE_BET_ODDS))
self.assertEqual(
self.test_wheel.get_outcome("Split 32-33"),
Outcome(Game.SPLIT_BET_NAME + " 32-33", Game.SPLIT_BET_ODDS))
def test_corner_bets_for_bottom_edge(self):
ocs = [
Outcome(self.corner_bet_name + ' 31-32-34-35',
self.corner_bet_odds),
Outcome(self.corner_bet_name + ' 32-33-35-36',
self.corner_bet_odds)
]
for exp in ocs:
self.assertTrue(exp in self.wheel.get_bin(35))
def test_zero_bin_outcomes(self):
outcomes = [
Outcome(Game.FIVE_BET_NAME, Game.FIVE_BET_ODDS),
Outcome(Game.STRAIGHT_BET_NAME + ' 0', Game.STRAIGHT_BET_ODDS)
]
actual_bin = self.test_wheel.get_bin(0)
for exp in outcomes:
self.assertTrue(exp in actual_bin,
'{} not in {}'.format(exp, actual_bin))
def test_is_valid_with_bets_below_limit(self):
bet1 = Bet(280, Outcome("Red", 1))
bet2 = Bet(10, Outcome("Red", 1))
bet3 = Bet(10, Outcome("Red", 1))
self.table.place_bet(bet1)
self.assertTrue(self.table.is_valid())
self.table.place_bet(bet2)
self.assertTrue(self.table.is_valid())
self.table.place_bet(bet3)
self.assertTrue(self.table.is_valid())
def add_straight_bets(cls, wheel):
"""Add all Straight Bet outcomes to the corresponding bins."""
for n in range(0, 37):
wheel.add_outcome(
n,
Outcome('{} {}'.format(Game.STRAIGHT_BET_NAME, n),
Game.STRAIGHT_BET_ODDS))
# special case for double zero, at index 37
wheel.add_outcome(
37,
Outcome('{} {}'.format(Game.STRAIGHT_BET_NAME, '00'),
Game.STRAIGHT_BET_ODDS))
def test_corner_bets_for_all_corners(self):
self.assertTrue(
Outcome(self.corner_bet_name +
' 1-2-4-5', self.corner_bet_odds) in self.wheel.get_bin(1))
self.assertTrue(
Outcome(self.corner_bet_name +
' 2-3-5-6', self.corner_bet_odds) in self.wheel.get_bin(3))
self.assertTrue(
Outcome(self.corner_bet_name + ' 31-32-34-35',
self.corner_bet_odds) in self.wheel.get_bin(34))
self.assertTrue(
Outcome(self.corner_bet_name + ' 32-33-35-36',
self.corner_bet_odds) in self.wheel.get_bin(36))
def helper_add_split_bets(cls, wheel, n_bin, inc):
"""Helper function to add Split Bet outcomes."""
oc = Outcome(
'{} {}-{}'.format(Game.SPLIT_BET_NAME, n_bin, n_bin + inc),
Game.SPLIT_BET_ODDS)
wheel.add_outcome(n_bin, oc)
wheel.add_outcome(n_bin + inc, oc)
def test_straight_bets_for_dbl_zero(self):
bin_number = 37
actual_bin = self.wheel.get_bin(bin_number)
expected = Outcome('{} {}'.format(self.straight_bet_name, '00'),
self.straight_bet_odds)
self.assertTrue(expected in actual_bin,
'{} is not in {}'.format(expected, actual_bin))
def add_dozen_bets(cls, wheel):
"""Add all Dozen Bet outcomes to the corresponding bins."""
for dozen in range(0, 3):
oc = Outcome('{} {}'.format(Game.DOZEN_BET_NAME, dozen + 1),
Game.DOZEN_BET_ODDS)
for n in range(0, 12):
bin_number = 12 * dozen + n + 1
wheel.add_outcome(bin_number, oc)
def test_straight_bets_for_all_except_double_zero(self):
for bin_number in range(0, 37):
actual_bin = self.wheel.get_bin(bin_number)
expected = Outcome(
'{} {}'.format(self.straight_bet_name, bin_number),
self.straight_bet_odds)
self.assertTrue(expected in actual_bin,
'{} is not in {}'.format(expected, actual_bin))
def add_column_bets(cls, wheel):
"""Add all Column Bet outcomes to the corresponding bins."""
for col in range(0, 3):
oc = Outcome('{} {}'.format(Game.COLUMN_BET_NAME, col + 1),
Game.DOZEN_BET_ODDS)
for row in range(0, 12):
bin_number = 3 * row + col + 1
wheel.add_outcome(bin_number, oc)
def add_street_bets(cls, wheel):
"""Add all Street Bet outcomes to the corresponding bins."""
for row in range(0, 12):
n = 3 * row + 1
oc = Outcome(
'{} {}-{}-{}'.format(Game.STREET_BET_NAME, n, n + 1, n + 2),
Game.STREET_BET_ODDS)
for i in range(0, 3):
wheel.add_outcome(n + i, oc)
def test_all_dozen_bets(self):
for dozen in range(0, 3):
exp = Outcome('{} {}'.format(self.dozen_bet_name, dozen + 1),
self.dozen_bet_odds)
for n in range(0, 12):
bin_number = 12 * dozen + n + 1
actual_bin = self.wheel.get_bin(bin_number)
self.assertTrue(exp in actual_bin,
'{} is not in {}'.format(exp, actual_bin))
def test_all_column_bets(self):
for col in range(0, 3):
exp = Outcome('{} {}'.format(self.column_bet_name, col + 1),
self.dozen_bet_odds)
for row in range(0, 12):
bin_number = 3 * row + col + 1
actual_bin = self.wheel.get_bin(bin_number)
self.assertTrue(exp in actual_bin,
'{} is not in {}'.format(exp, actual_bin))
def helper_split_bets_test(self, n, inc):
actual_bin1 = self.wheel.get_bin(n)
actual_bin2 = self.wheel.get_bin(n + inc)
expected = Outcome('{} {}-{}'.format(self.split_bet_name, n, n + inc),
self.split_bet_odds)
self.assertTrue(expected in actual_bin1,
'{} is not in {}'.format(expected, actual_bin1))
self.assertTrue(expected in actual_bin2,
'{} is not in {}'.format(expected, actual_bin2))
def test_street_bets(self):
for row in range(0, 12):
n = 3 * row + 1
exp_oc = Outcome(
'{} {}-{}-{}'.format(self.street_bet_name, n, n + 1, n + 2),
self.street_bet_odds)
for i in range(0, 3):
actual_bin = self.wheel.get_bin(n + i)
self.assertTrue(exp_oc in actual_bin,
'{} is not in {}'.format(exp_oc, actual_bin))
def test_all_line_bets(self):
for row in range(0, 11):
n = 3 * row + 1
exp = Outcome(
self.line_bet_name + ' {:d}-{:d}-{:d}-{:d}-{:d}-{:d}'.format(
n, n + 1, n + 2, n + 3, n + 4, n + 5), self.line_bet_odds)
for i in range(n, n + 6):
actual_bin = self.wheel.get_bin(n)
self.assertTrue(exp in actual_bin,
'{} is not in {}'.format(exp, actual_bin))
def add_line_bets(cls, wheel):
"""Add all Line Bet outcomes to the corresponding bins."""
for row in range(0, 11):
n = 3 * row + 1
oc = Outcome(
'{:s} {:d}-{:d}-{:d}-{:d}-{:d}-{:d}'.format(
Game.LINE_BET_NAME, n, n + 1, n + 2, n + 3, n + 4, n + 5),
Game.LINE_BET_ODDS)
for i in range(0, 6):
wheel.add_outcome(n + i, oc)
def add_corner_bets(cls, wheel):
"""Add all Corner Bet outcomes to the corresponding bins."""
for row in range(0, 11):
for i in range(1, 3):
n = 3 * row + i
oc = Outcome(
'{} {}-{}-{}-{}'.format(Game.CORNER_BET_NAME, n, n + 1,
n + 3, n + 4),
Game.CORNER_BET_ODDS)
for j in [n, n + 1, n + 3, n + 4]:
wheel.add_outcome(j, oc)
class OutcomeTest(unittest.TestCase):
"""Test the implementation of the class Outcome."""
def setUp(self):
self.oc1 = Outcome("Red", 1)
self.oc2 = Outcome("Red", 1)
self.oc3 = Outcome("Split 1-2", 17)
def test_can_create_outcome(self):
self.assertIsNotNone(self.oc1)
def test_same_outcomes_are_equal(self):
self.assertEqual(self.oc1, self.oc2)
def test_different_outcomes_are_not_equal(self):
self.assertNotEqual(self.oc1, self.oc3)
def test_same_outcomes_have_same_hash(self):
self.assertEqual(hash(self.oc1), hash(self.oc2))
def test_different_outcomes_have_different_hash(self):
self.assertNotEqual(hash(self.oc1), hash(self.oc3))
def test_outcome_str_representation_is_correct(self):
self.assertEqual(self.oc1.__str__(), "Red (1:1)")
self.assertEqual(self.oc3.__str__(), "Split 1-2 (17:1)")
def test_outcome_repr_is_correct(self):
self.assertEqual(self.oc1.__repr__(), "Outcome('Red', 1)")
self.assertEqual(self.oc3.__repr__(), "Outcome('Split 1-2', 17)")
def test_win_amount_returns_correct_value(self):
self.assertEqual(self.oc1.win_amount(13), 13)
self.assertEqual(self.oc3.win_amount(5), 85)
def add_even_money_bets(cls, wheel):
"""Add all Even Money Bet outcomes to the corresponding bins."""
red = Outcome(Game.RED_BET_NAME, Game.EVEN_MONEY_BET_ODDS)
black = Outcome(Game.BLACK_BET_NAME, Game.EVEN_MONEY_BET_ODDS)
even = Outcome(Game.EVEN_BET_NAME, Game.EVEN_MONEY_BET_ODDS)
odd = Outcome(Game.ODD_BET_NAME, Game.EVEN_MONEY_BET_ODDS)
high = Outcome(Game.HIGH_BET_NAME, Game.EVEN_MONEY_BET_ODDS)
low = Outcome(Game.LOW_BET_NAME, Game.EVEN_MONEY_BET_ODDS)
for bin_number in range(1, 37):
if bin_number < 19:
wheel.add_outcome(bin_number, low)
else:
wheel.add_outcome(bin_number, high)
if bin_number % 2 == 0:
wheel.add_outcome(bin_number, even)
else:
wheel.add_outcome(bin_number, odd)
if bin_number in Game.RED_BINS:
wheel.add_outcome(bin_number, red)
else:
wheel.add_outcome(bin_number, black)
def test_bin_one_outcomes(self):
outcomes = [
Outcome(Game.STRAIGHT_BET_NAME + ' 1', Game.STRAIGHT_BET_ODDS),
Outcome(Game.RED_BET_NAME, Game.EVEN_MONEY_BET_ODDS),
Outcome(Game.ODD_BET_NAME, Game.EVEN_MONEY_BET_ODDS),
Outcome(Game.LOW_BET_NAME, Game.EVEN_MONEY_BET_ODDS),
Outcome(Game.COLUMN_BET_NAME + " 1", Game.COLUMN_BET_ODDS),
Outcome(Game.DOZEN_BET_NAME + " 1", Game.DOZEN_BET_ODDS),
Outcome(Game.SPLIT_BET_NAME + " 1-2", Game.SPLIT_BET_ODDS),
Outcome(Game.SPLIT_BET_NAME + " 1-4", Game.SPLIT_BET_ODDS),
Outcome(Game.STREET_BET_NAME + " 1-2-3", Game.STREET_BET_ODDS),
Outcome(Game.CORNER_BET_NAME + " 1-2-4-5", Game.CORNER_BET_ODDS),
Outcome(Game.FIVE_BET_NAME, Game.FIVE_BET_ODDS),
Outcome(Game.LINE_BET_NAME + " 1-2-3-4-5-6", Game.LINE_BET_ODDS)
]
actual_bin = self.test_wheel.get_bin(1)
self.assertEqual(len(outcomes), len(actual_bin), actual_bin)
for exp in outcomes:
self.assertTrue(exp in actual_bin,
'{} not in {}'.format(exp, actual_bin))
def test_no_other_five_bets(self):
five_bet = Outcome(self.five_bet_name, self.five_bet_odds)
for i in range(4, self.dbl_zero_bin):
actual_bin = self.wheel.get_bin(i)
self.assertTrue(five_bet not in actual_bin,
'{} is in {}'.format(five_bet, actual_bin))
def test_five_bets_for_one_two_three(self):
expected = Outcome(self.five_bet_name, self.five_bet_odds)
for i in range(1, 4):
actual_bin = self.wheel.get_bin(i)
self.assertTrue(expected in actual_bin,
'{} is not in {}'.format(expected, actual_bin))
def test_five_bets_for_dbl_zero(self):
actual_bin = self.wheel.get_bin(self.dbl_zero_bin)
expected = Outcome(self.five_bet_name, self.five_bet_odds)
self.assertTrue(expected in actual_bin,
'{} is not in {}'.format(expected, actual_bin))
def test_some_black_bets(self):
black = Outcome(self.black_bet_name, self.even_money_bet_odds)
self.assertTrue(black in self.wheel.get_bin(6))
self.assertTrue(black in self.wheel.get_bin(31))
def test_some_red_bets(self):
red = Outcome(self.red_bet_name, self.even_money_bet_odds)
self.assertTrue(red in self.wheel.get_bin(9))
self.assertTrue(red in self.wheel.get_bin(18))
def test_bin_twenty_outcomes(self):
outcomes = [
Outcome(Game.STRAIGHT_BET_NAME + ' 20', Game.STRAIGHT_BET_ODDS),
Outcome(Game.BLACK_BET_NAME, Game.EVEN_MONEY_BET_ODDS),
Outcome(Game.EVEN_BET_NAME, Game.EVEN_MONEY_BET_ODDS),
Outcome(Game.HIGH_BET_NAME, Game.EVEN_MONEY_BET_ODDS),
Outcome(Game.COLUMN_BET_NAME + " 2", Game.COLUMN_BET_ODDS),
Outcome(Game.DOZEN_BET_NAME + " 2", Game.DOZEN_BET_ODDS),
Outcome(Game.SPLIT_BET_NAME + " 17-20", Game.SPLIT_BET_ODDS),
Outcome(Game.SPLIT_BET_NAME + " 19-20", Game.SPLIT_BET_ODDS),
Outcome(Game.SPLIT_BET_NAME + " 20-21", Game.SPLIT_BET_ODDS),
Outcome(Game.SPLIT_BET_NAME + " 20-23", Game.SPLIT_BET_ODDS),
Outcome(Game.STREET_BET_NAME + " 19-20-21", Game.STREET_BET_ODDS),
Outcome(Game.CORNER_BET_NAME + " 16-17-19-20",
Game.CORNER_BET_ODDS),
Outcome(Game.CORNER_BET_NAME + " 17-18-20-21",
Game.CORNER_BET_ODDS),
Outcome(Game.CORNER_BET_NAME + " 19-20-22-23",
Game.CORNER_BET_ODDS),
Outcome(Game.CORNER_BET_NAME + " 20-21-23-24",
Game.CORNER_BET_ODDS),
Outcome(Game.LINE_BET_NAME + " 16-17-18-19-20-21",
Game.LINE_BET_ODDS),
Outcome(Game.LINE_BET_NAME + " 19-20-21-22-23-24",
Game.LINE_BET_ODDS)
]
actual_bin = self.test_wheel.get_bin(20)
self.assertEqual(len(outcomes), len(actual_bin), actual_bin)
for exp in outcomes:
self.assertTrue(exp in actual_bin,
'{} not in {}'.format(exp, actual_bin))
