class TestOutcome(unittest.TestCase):
def setUp(self):
self.outcome1 = Outcome("abc", 1)
self.outcome2 = Outcome("abc", 2)
self.outcome3 = Outcome("bcd", 1)
def test_equality(self):
self.assertEqual(
self.outcome1,
self.outcome2,
"Outcomes with same names should be considered equal.",
)
def test_inequality(self):
self.assertNotEqual(
self.outcome1,
self.outcome3,
"Outcomes with different names should be considered unequal.",
)
def test_hash_equality(self):
self.assertEqual(
hash(self.outcome1),
hash(self.outcome2),
"Outcomes with the same name should have equal hash values.",
)
def test_win_amount(self):
self.assertEqual(self.outcome1.win_amount(10), 10,
"Wrong outcome win amount.")
self.assertEqual(self.outcome2.win_amount(10), 20,
"Wrong outcome win amount.")
def setUp(self):
table = Table(100)
rng = NonRandom()
wheel = Wheel(rng)
self.game = Game(wheel, table)
self.player = MartingalePlayer(table)
self.player.stake = 1000
self.player.rounds_to_go = 10
self.outcomes = [Outcome("Black", 1), Outcome("Red", 1)]
def test_bet_waits(self):
red = Bin(Outcome("Red", 1))
black = Bin(Outcome("Black", 1))
for i in range(7):
self.player.winners(red)
self.assertEqual(self.player.stake, self.inital_player_stake)
self.player.place_bets()
self.assertEqual(self.player.stake,
self.inital_player_stake - self.table.min_limit)
def test_outcome(self):
o1 = Outcome("Red", 1)
o2 = Outcome("Red", 1)
o3 = Outcome("Black", 2)
assert str(o1) == "Red 1:1"
assert repr(o2) == "Outcome(name='Red', odds=1)"
assert o1 == o2
assert o1.odds == 1
assert o1.name == "Red"
assert o1 != o3
assert o2 != o3
def setUp(self):
table = Table(100)
rng_wheel = NonRandom()
wheel = Wheel(rng_wheel)
self.initial_player_stake = 1000
self.table = table
self.game = Game(wheel, table)
self.player = PlayerFibonacci(table)
self.player.stake = self.initial_player_stake
self.player.rounds_to_go = 1
self.outcomes = [Outcome("Black", 1), Outcome("Red", 1)]
def setUp(self):
self.outcome1 = Outcome("abc", 2)
self.outcome2 = Outcome("def", 3)
self.outcome3 = Outcome("ghi", 4)
self.outcome4 = Outcome("jkl", 5)
self.bin1 = Bin(self.outcome1, self.outcome2, self.outcome3)
self.bin2 = Bin(self.outcome2, self.outcome3, self.outcome4)
self.wheel = Wheel(NonRandom())
self.wheel.set_bin(0, self.bin1)
self.wheel.set_bin(1, self.bin2)
def test_bet_multiple(self):
red = Bin(Outcome("Red", 1))
black = Bin(Outcome("Black", 1))
for i in range(4):
for i in range(2):
self.player.win(
Bet(Outcome("Black", 1), self.player.bet_multiple))
print(self.player.bet_multiple)
for j in range(3):
self.player.lose(
Bet(Outcome("Black", 1), self.player.bet_multiple))
print(self.player.bet_multiple)
def generate_straight_bet(self, n):
"""Generates a straight bet for the given bin
Args:
n (int): label of the bin
"""
n = str(n)
return Outcome(f"Straight {n}", 35)
def generate_split_bet(self, n, increment):
"""Generate a split bet for the given bin
Args:
n (int): label of the lower bin
increment (int): difference between two labels
"""
return Outcome(f"{n}, {n+increment}", 17)
def test_choose(self):
randomizer = random.Random()
randomizer.seed(5)
randomizeds = [randomizer.randint(0, 37) for _ in range(5)]
self.wheel.random_generator.seed(5)
for random_num in randomizeds:
chosen_bin = self.wheel.choose()
self.assertEqual(
Bin([Outcome(f"some outcome{random_num}", random_num)]),
chosen_bin)
def setUp(self):
table = Table(100)
rng = NonRandom()
wheel = Wheel(rng)
self.inital_player_stake = 1000
self.table = table
self.game = Game(wheel, table)
self.player = SevenRedsPlayer(table)
self.player.stake = self.inital_player_stake
self.player.rounds_to_go = 10
self.outcomes = Outcome("Black", 1)
class MartingalePlayer(Player):
"""Player that plays with Martingale strategy
Attrs:
loss_count (int): Number of losses of the player
bet_multiple (int): Multiplier for the bet. It is 2^(loss_count)
base_bet (int): lowest bet the player makes
"""
outcome = Outcome("Black", 1)
def __init__(self, a_table):
super().__init__(a_table)
self.loss_count = 0
self.bet_multiple = 1
def place_bets(self):
"""Updates the table with a bet on black. The amount bet is bet_multiple"""
bet_amount = self.base_bet * self.bet_multiple
if not self.can_place_bet(bet_amount):
return
self.table.place_bet(Bet(MartingalePlayer.outcome, bet_amount))
self.stake -= bet_amount
def win(self, bet):
"""
loss_count will be set to 0 and bet_multiple will be reset to 1.
"""
super().win(bet)
self.loss_count = 0
self.bet_multiple = 1
def lose(self, bet):
"""Increments loss count by 1 and doubles bet_multiple"""
self.loss_count += 1
self.bet_multiple *= 2
def playing(self):
return self.stake >= self.bet_multiple * self.base_bet and self.rounds_to_go > 0
def test_add_outcome(self):
new_outcome = Outcome("new add", 10)
self.wheel.add_outcome(1, new_outcome)
self.assertEqual(2, len(self.wheel.get(1)))
def setUp(self):
self.wheel = Wheel()
for i in range(38):
outcome = Outcome(f"some outcome{i}", i)
self.wheel.add_outcome(i, outcome)
def setUp(self):
self.outcome1 = Outcome("abc", 1)
self.outcome2 = Outcome("abc", 2)
self.outcome3 = Outcome("bcd", 1)
def __init__(self, a_table):
super().__init__(a_table)
self.reset()
self.outcome = Outcome("Black", 1)
def generate_even_money_bet(self, name):
"""Generate an even money bet with the given name"""
return Outcome(name, 1)
def generate_dozen_bet(self, n):
"""Generate a dozen bet for the given dozen
Args:
n (int): dozen number
"""
return Outcome(f"Dozen {n}", 2)
def generate_street_bet(self, n):
"""Generate a street bet for the given bin
Args:
n (int): label of the lowest bin"""
return Outcome(f"{n}, {n+1}, {n+2}", 11)
def setUp(self):
self.outcome_black1 = Outcome("Black", 2)
self.outcome_black2 = Outcome("Black", 2)
self.outcome_straight5 = Outcome("Straight 5", 30)
def generate_line_bet(self, n):
"""Generate a corner bet for the given bin
Args:
n (int): label of the lowest bin"""
return Outcome(f"{n}, {n+1}, {n+2}, {n+3}, {n+4}, {n+5}", 5)
def setUp(self):
self.outcome1 = Outcome("test1", 2)
self.outcome2 = Outcome("test2", 3)
def generate_column_bet(self, n):
"""Generate a column bet for the given column
Args:
n (int): column number
"""
return Outcome(f"Column {n}", 2)
def setUp(self):
self.bet1 = Bet(Outcome("test1", 2), 100)
self.bet2 = Bet(Outcome("test2", 3), 200)
self.table1 = Table(250)
self.table2 = Table(300)
def build_bins(self, wheel):
for i in range(0, len(wheel.bins)):
wheel.set_bin(i, Bin())
for i in range(1, 37):
outcome = (self.generate_straight_bet(i), )
wheel.add_outcome(i, outcome)
for r in range(0, 12):
# generate split bets
first_col_no = 3 * r + 1
outcome = (self.generate_split_bet(first_col_no, 1), )
wheel.add_outcome(first_col_no, outcome)
wheel.add_outcome(first_col_no + 1, outcome)
second_col_no = 3 * r + 2
outcome = (self.generate_split_bet(second_col_no, 1), )
wheel.add_outcome(second_col_no, outcome)
wheel.add_outcome(second_col_no + 1, outcome)
# generate street bets
n = 3 * r + 1
outcome = (self.generate_street_bet(n), )
wheel.add_outcome(n, outcome)
wheel.add_outcome(n + 1, outcome)
wheel.add_outcome(n + 2, outcome)
for i in range(1, 34):
# generate split bets
outcome = (self.generate_split_bet(i, 3), )
wheel.add_outcome(i, outcome)
wheel.add_outcome(i + 3, outcome)
for r in range(0, 11):
# generate corner bets
first_col_no = 3 * r + 1
outcome = (self.generate_corner_bet(first_col_no), )
wheel.add_outcome(first_col_no, outcome)
wheel.add_outcome(first_col_no + 1, outcome)
wheel.add_outcome(first_col_no + 3, outcome)
wheel.add_outcome(first_col_no + 4, outcome)
second_col_no = 3 * r + 2
outcome = (self.generate_corner_bet(second_col_no), )
wheel.add_outcome(second_col_no, outcome)
wheel.add_outcome(second_col_no + 1, outcome)
wheel.add_outcome(second_col_no + 3, outcome)
wheel.add_outcome(second_col_no + 4, outcome)
# generate line bets
n = 3 * r + 1
outcome = (self.generate_line_bet(n), )
wheel.add_outcome(n, outcome)
wheel.add_outcome(n + 1, outcome)
wheel.add_outcome(n + 2, outcome)
wheel.add_outcome(n + 3, outcome)
wheel.add_outcome(n + 4, outcome)
wheel.add_outcome(n + 5, outcome)
for i in range(0, 3):
# generate dozen bets
outcome = (self.generate_dozen_bet(i + 1), )
for j in range(0, 12):
wheel.add_outcome(12 * i + j + 1, outcome)
for i in range(0, 3):
# generate column bets
outcome = (self.generate_column_bet(r + 1), )
for r in range(0, 12):
wheel.add_outcome(3 * r + i + 1, outcome)
# generate even money bets
even_bets = {
"Red": (self.generate_even_money_bet("Red"), ),
"Black": (self.generate_even_money_bet("Black"), ),
"Even": (self.generate_even_money_bet("Even"), ),
"Odd": (self.generate_even_money_bet("Odd"), ),
"High": (self.generate_even_money_bet("High"), ),
"Low": (self.generate_even_money_bet("Low"), ),
}
for i in range(1, 37):
if i < 19:
wheel.add_outcome(i, even_bets["Low"])
else:
wheel.add_outcome(i, even_bets["High"])
if i % 2 == 0:
wheel.add_outcome(i, even_bets["Even"])
else:
wheel.add_outcome(i, even_bets["Odd"])
if i in [
1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32,
34, 36
]:
wheel.add_outcome(i, even_bets["Red"])
else:
wheel.add_outcome(i, even_bets["Black"])
# generate 0 bets
five_bet = (Outcome("Five Bet", 6), )
wheel.add_outcome(0, (self.generate_straight_bet("0"), ))
wheel.add_outcome(0, five_bet)
wheel.add_outcome(-1, (self.generate_straight_bet("00"), ))
wheel.add_outcome(-1, five_bet)
def __init__(self, a_table):
super().__init__(a_table)
self.state = Player1326NoWins(self)
self.outcome = Outcome("Black", 1)
