def _cornerBets(self):
"""
Generating Corner Bets
"""
for r in range(11):
# First Column Number
n = 3 * r + 1
# Column 1-2 Corner
corner = "{0}, {0} + 1, {0} + 3, {0} + 4".format(n)
# Assign to Bins.
for i in range(n, n + 5):
self.wheel.bins[n].addOutcome(
Outcome(corner, RouletteGame.cornerBet))
# self.wheel.bins[n+1].addOutcome(Outcome(corner, RouletteGame.cornerBet))
# self.wheel.bins[n+3].addOutcome(Outcome(corner, RouletteGame.cornerBet))
# self.wheel.bins[n+4].addOutcome(Outcome(corner, RouletteGame.cornerBet))
self.wheel.add(Outcome(corner, RouletteGame.cornerBet))
# Second Column Number
n = 3 * r + 2
# Column 2-3 Corner
corner = "{0}, {0} + 1, {0} + 3, {0} + 4".format(n)
# Assign to Bins
for i in range(n, n + 5):
self.wheel.bins[i].addOutcome(
Outcome(corner, RouletteGame.cornerBet))
# self.wheel.bins[n+1].addOutcome(Outcome(corner, RouletteGame.cornerBet))
# self.wheel.bins[n+3].addOutcome(Outcome(corner, RouletteGame.cornerBet))
# self.wheel.bins[n+4].addOutcome(Outcome(corner, RouletteGame.cornerBet))
self.wheel.add(Outcome(corner, RouletteGame.cornerBet))
def setUp(self):
self.first = Outcome('one', 17)
self.second = Outcome('one', 17)
self.third = Outcome('two', 32)
self.fbin = Bin(self.first)
self.sbin = Bin(self.second)
def test_streets_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_streets_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([Outcome("1, 2, 3", 17)])
assert wheel.get_bin(2).outcomes == frozenset([Outcome("1, 2, 3", 17)])
assert wheel.get_bin(3).outcomes == frozenset([Outcome("1, 2, 3", 17)])
def test_dozen_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_dozen_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([Outcome("Dozen 1", 2)])
assert wheel.get_bin(13).outcomes == frozenset([Outcome("Dozen 2", 2)])
assert wheel.get_bin(36).outcomes == frozenset([Outcome("Dozen 3", 2)])
def test_straight_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_straight_bets(wheel)
assert wheel.get_bin(0).outcomes == frozenset([Outcome("0", 35)])
assert wheel.get_bin(37).outcomes == frozenset([Outcome("00", 35)])
assert wheel.get_bin(3).outcomes == frozenset([Outcome("3", 35)])
def test_column_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_column_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([Outcome("Column 1", 2)])
assert wheel.get_bin(28).outcomes == frozenset([Outcome("Column 1", 2)])
assert wheel.get_bin(27).outcomes == frozenset([Outcome("Column 3", 2)])
def test_line_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_line_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset(
[Outcome("1, 2, 3, 4, 5, 6", 5)])
assert wheel.get_bin(4).outcomes == frozenset(
[Outcome("1, 2, 3, 4, 5, 6", 5),
Outcome("4, 5, 6, 7, 8, 9", 5)])
def test_place_bet():
wheel = create_wheel()
table = Table(wheel)
zerozero = Outcome("00", 35)
zerozero_bet = Bet(900, zerozero)
red_bet = Bet(60, Outcome("Red", 1))
table.place_bet(zerozero_bet)
table.place_bet(red_bet)
assert [x.bet_amount for x in table] == [900, 60]
with pytest.raises(InvalidBet):
table.place_bet(red_bet)
def test(self):
oc1 = Outcome('1', 35)
oc2 = Outcome('1', 17)
oc3 = Outcome('2', 2)
self.assertEqual(oc1, oc2)
self.assertEqual(oc1.__hash__(), oc2.__hash__())
self.assertEqual(oc3.winAmount(50), 100)
def test_bin_has_outcomes():
outcome_0 = Outcome("0", 35)
outcome_5 = Outcome("Five", 6)
outcome_00 = Outcome("00", 35)
bin_0 = Bin(0)
bin_0.add(outcome_0)
bin_0.add(outcome_5)
bin_00 = Bin(37)
bin_00.add(outcome_00)
bin_00.add(outcome_5)
assert bin_0.outcomes == frozenset([outcome_0, outcome_5])
assert bin_00.outcomes == frozenset([outcome_00, outcome_5])
def test_split_bet(self):
bb.split_bet()
for count, i in enumerate(bb.bins):
udstart = count % 3 + 1
lrstart = udstart
if udstart % 3 == 0:
lrstart -= 1
self.assertTrue(
Outcome(("%d-%d split" % (udstart, (udstart + 3))), 17), i)
self.assertTrue(
Outcome(("%d-%d split" % (lrstart, (lrstart + 1))), 17), i)
def _lineBets(self):
"""
Generating Line Bets
"""
for r in range(11):
# First Column Number
n = 3 * r + 1
line = "{0}, {0} + 1, {0} + 2, {0} + 3, {0} + 4, {0} + 5".format(n)
# Assign to Bins
for i in range(n, n + 6):
self.wheel.bins[n].addOutcome(
Outcome(line, RouletteGame.lineBet))
self.wheel.add(Outcome(line, RouletteGame.lineBet))
def _streetBets(self):
"""
Generating Street Bets
"""
street = "{0}, {0} + 1, {0} + 2"
for r in range(12):
n = 3 * r + 1
for i in range(n, n + 3):
self.wheel.bins[n].addOutcome(
Outcome(street.format(n), RouletteGame.streetBet))
# self.wheel.bins[n+1].addOutcome(Outcome(street.format(n), RouletteGame.streetBet))
# self.wheel.bins[n+2].addOutcome(Outcome(street.format(n), RouletteGame.streetBet))
self.wheel.add(Outcome(street.format(n), RouletteGame.streetBet))
class TestOutcome(unittest.TestCase):
def setUp(self):
self.first = Outcome('one', 17)
self.second = Outcome('one', 17)
self.third = Outcome('two', 32)
def test___eq__(self):
# outcome = Outcome(name, odds)
# self.assertEqual(expected, outcome.__eq__(other))
self.assertTrue(self.first == self.second)
def test___ne__(self):
# outcome = Outcome(name, odds)
# self.assertEqual(expected, outcome.__ne__(other))
self.assertTrue(self.first != self.third)
def test___id_comparision(self):
# outcome = Outcome(name, odds)
# self.assertEqual(expected, outcome.__str__())
print id(self.first)
print id(self.second)
print hash(self.first)
print hash(self.second)
self.assertTrue(self.first is self.second)
def test_win_amount(self):
# outcome = Outcome(name, odds)
# self.assertEqual(expected, outcome.winAmount(amount))
self.assertTrue((2 * 32) == self.third.win_amount(2))
def tearDown(self):
first = second = third = None
pass
def gen_streets_bets(self, wheel):
for r in range(12):
n = 3 * r + 1
outcome = Outcome("%i, %i, %i" % (n, (n + 1), (n + 2)), 11)
wheel.add_outcome(n, outcome)
wheel.add_outcome(n + 1, outcome)
wheel.add_outcome(n + 2, outcome)
def test_run_the_wheel():
nrg = NonRandom([0, 37])
wheel = Wheel(nrg)
outcome_0 = Outcome("0", 35)
outcome_5 = Outcome("Five", 6)
outcome_00 = Outcome("00", 35)
wheel.add_outcome(0, outcome_0)
wheel.add_outcome(0, outcome_5)
wheel.add_outcome(37, outcome_00)
wheel.add_outcome(37, outcome_5)
bin = wheel.next()
assert bin.outcomes == frozenset([outcome_0, outcome_5])
bin = wheel.next()
assert bin.outcomes == frozenset([outcome_00, outcome_5])
def get_outcome(self, name):
if name in self.outcomes:
return self.outcomes[name]
elif name in self.AVAILABALE_OUTCOMES:
self.outcomes[name] = Outcome(name, self.AVAILABALE_OUTCOMES[name])
return self.outcomes[name]
else:
raise Exception(name + ' outcome is not found')
def gen_line_bets(self, wheel):
for r in range(10):
line = list()
for i in range(6):
line.append(3 * r + 1 + i)
outcome = Outcome(", ".join([str(x) for x in line]), 5)
for bin in line:
wheel.add_outcome(bin, outcome)
def _columnBets(self):
"""
Generating Column Bets
"""
for c in range(3):
column = "{} + 1".format(c)
outcome = Outcome(column, 2)
self.wheel.add(outcome)
for r in range(12):
self.wheel.bins[3 * r + c + 1].addOutcome(outcome)
def _dozenBets(self):
"""
Generating Dozen Bets
"""
for d in range(3):
dozen = "{} + 1".format(d)
outcome = Outcome(dozen, RouletteGame.dozenBet)
self.wheel.add(outcome)
for m in range(12):
self.wheel.bins[(12 * d) + m + 1].addOutcome(outcome)
def gen_split_bets(self, wheel):
# Horizontal splits:
for r in range(12):
# First column number:
n = 3 * r + 1
# Column 1-2 split
outcome = Outcome("%s, %s" % (n, n + 1), 17)
wheel.add_outcome(n, outcome)
wheel.add_outcome(n + 1, outcome)
# Second column number:
n = 3 * r + 2
# Column 2-3 split
outcome = Outcome("%s, %s" % (n, n + 1), 17)
wheel.add_outcome(n, outcome)
wheel.add_outcome(n + 1, outcome)
# Vertical splits:
for i in range(1, 33):
outcome = Outcome("%s, %s" % (i, i + 3), 17)
wheel.add_outcome(i, outcome)
wheel.add_outcome(i + 3, outcome)
def test_split_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_split_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset(
[Outcome("1, 2", 17), Outcome("1, 4", 17)])
assert wheel.get_bin(20).outcomes == frozenset([
Outcome("17, 20", 17),
Outcome("19, 20", 17),
Outcome("20, 21", 17),
Outcome("20, 23", 17),
])
assert wheel.get_bin(18).outcomes == frozenset([
Outcome("15, 18", 17),
Outcome("17, 18", 17),
Outcome("18, 21", 17),
])
class TestOutcome(unittest.TestCase):
oc1 = Outcome("0", 35)
oc2 = Outcome("1", 5)
oc3 = Outcome("2", 1)
oc4 = Outcome("red", 1)
oc5 = Outcome("even", 1)
oc6 = Outcome("odd", 1)
def test_eq(self):
self.assertEqual(TestOutcome.oc1.__eq__(TestOutcome.oc2), False,
"Should be false.")
def test_winAmount(self):
self.assertEqual(TestOutcome.oc1.winAmount(2), 70, "Should be 70")
def test_ne(self):
self.assertEqual(TestOutcome.oc3.__ne__(TestOutcome.oc2), True,
"Should be false.")
def test_eq2(self):
self.assertNotEqual(TestOutcome.oc1.__eq__(TestOutcome.oc3), True,
"Should be not equal.")
def test_str(self):
self.assertEqual(TestOutcome.oc1.__str__(), "0 (35:1)",
"Should be 0 (35:1)")
def _evenMoneyBets(self):
"""
Generating Even-Money Bets
"""
evenMoneyBets = {
"RED": Outcome("red", 1),
"BLACK": Outcome("black", 1),
"EVEN": Outcome("even", 1),
"ODD": Outcome("odd", 1),
"HIGH": Outcome("high", 1),
"LOW": Outcome("low", 1)
}
bets = evenMoneyBets.values()
for bet in bets:
self.wheel.add(bet)
RED_NUMS = frozenset({
1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36
})
for n in range(1, 37):
if n < 19:
self.wheel.bins[n].addOutcome(evenMoneyBets["LOW"])
else:
self.wheel.bins[n].addOutcome(evenMoneyBets["HIGH"])
if n % 2 == 0:
self.wheel.bins[n].addOutcome(evenMoneyBets["EVEN"])
else:
self.wheel.bins[n].addOutcome(evenMoneyBets["ODD"])
if n in RED_NUMS:
self.wheel.bins[n].addOutcome(evenMoneyBets["RED"])
else:
self.wheel.bins[n].addOutcome(evenMoneyBets["BLACK"])
def test_corner_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_corner_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([Outcome("1, 2, 4, 5", 8)])
assert wheel.get_bin(4).outcomes == frozenset([
Outcome("1, 2, 4, 5", 8),
Outcome("4, 5, 7, 8", 8),
])
assert wheel.get_bin(7).outcomes == frozenset([
Outcome("4, 5, 7, 8", 8),
Outcome("7, 8, 10, 11", 8),
])
assert wheel.get_bin(8).outcomes == frozenset([
Outcome("4, 5, 7, 8", 8),
Outcome("5, 6, 8, 9", 8),
Outcome("7, 8, 10, 11", 8),
Outcome("8, 9, 11, 12", 8),
])
def test_state(self):
noWins = Player1326NoWins(self.player)
print(noWins.currentBet())
self.assertEqual(noWins.currentBet().__repr__(),
Bet(1, Outcome('black', 1)).__repr__())
oneWin = noWins.nextWon()
print(oneWin.currentBet())
twoWins = oneWin.nextWon()
print(twoWins.currentBet())
threeWins = twoWins.nextWon()
print(threeWins.currentBet())
def _splitBets(self):
"""
Generating Split Bets
"""
left_right = "{0}, {0} + 1"
splitBet = RouletteGame.splitBet
# Left-Right Pairs
for r in range(12):
n = 3 * r + 1
self.wheel.bins[n].addOutcome(
Outcome(left_right.format(n), RouletteGame.splitBet))
self.wheel.bins[n + 1].addOutcome(
Outcome(left_right.format(n), RouletteGame.splitBet))
self.wheel.add(Outcome(left_right.format(n),
RouletteGame.splitBet))
n = 3 * r + 2
## print("{} = 3 * {} + 2".format(n, r))
self.wheel.bins[n].addOutcome(
Outcome(left_right.format(n), RouletteGame.splitBet))
self.wheel.bins[n + 1].addOutcome(
Outcome(left_right.format(n), RouletteGame.splitBet))
self.wheel.add(Outcome(left_right.format(n),
RouletteGame.splitBet))
n = 3 * r + 1
## print("{} = 3 * {} + 1".format(n, r))
up_down = "{0}, {0} + 3"
# Up-Down Pairs
for n in range(1, 34):
self.wheel.bins[n].addOutcome(
Outcome(up_down.format(n), RouletteGame.splitBet))
self.wheel.bins[n + 3].addOutcome(
Outcome(up_down.format(n), RouletteGame.splitBet))
self.wheel.add(Outcome(up_down.format(n), RouletteGame.splitBet))
def test_even_money_bets():
bin_builder = BinBuilder()
wheel = Wheel()
bin_builder.gen_even_money_bets(wheel)
assert wheel.get_bin(1).outcomes == frozenset([
Outcome("Low", 1),
Outcome("Odd", 1),
Outcome("Red", 1),
])
assert wheel.get_bin(24).outcomes == frozenset([
Outcome("High", 1),
Outcome("Even", 1),
Outcome("Black", 1),
])
class TestOutcome(unittest.TestCase):
def setUp(self):
self.output = Outcome("Red", 11)
self.same = Outcome("Red", 11)
self.different = Outcome("Black", 11)
def testWinAmount(self):
payout = self.output.winAmount(3)
self.assertEqual(payout, 3 * 11)
def testEquality(self):
self.assertEqual(self.output, self.same)
self.assertNotEqual(self.output, self.different)
def testHashEquality(self):
self.assertEqual(hash(self.output), hash(self.same))
self.assertNotEqual(hash(self.output), hash(self.different))
def testStr(self):
self.assertEqual("%s" % self.output, "Red (11:1)")
class TestOutcome(unittest.TestCase):
def setUp(self):
self.output = Outcome("Red", 11)
self.same = Outcome("Red", 11)
self.different = Outcome("Black", 11)
def testWinAmount(self):
payout = self.output.winAmount(3)
self.assertEqual(payout, 3*11)
def testEquality(self):
self.assertEqual(self.output, self.same)
self.assertNotEqual(self.output, self.different)
def testHashEquality(self):
self.assertEqual(hash(self.output), hash(self.same))
self.assertNotEqual(hash(self.output), hash(self.different))
def testStr(self):
self.assertEqual("%s" % self.output, "Red (11:1)")
class TestOutcome(unittest.TestCase):
def setUp(self):
self.outcome1 = Outcome("1", 37)
self.outcome2 = Outcome("1", 37)
self.outcome3 = Outcome("2", 37)
def test_equal(self):
self.assertEqual(self.outcome1, self.outcome2)
def test_unequal(self):
self.assertNotEqual(self.outcome1, self.outcome3)
def test_win_amount(self):
self.assertEqual(self.outcome1.win_amount(10), 370)
def test_print(self):
self.assertEqual(str(self.outcome1), "1 (37:1)")
def test_hash(self):
self.assertEqual(hash(self.outcome1), hash(self.outcome2))
def _straighBets(self):
"""
Generating Straight Bets
"""
betOdds = RouletteGame.straightBet
straight = "{}"
self.wheel.add(Outcome(straight.format(0), betOdds))
self.wheel.bins[0].addOutcome(Outcome(straight.format(0), betOdds))
for n in range(1, 37):
self.wheel.bins[n].addOutcome(Outcome(straight.format(n), betOdds))
self.wheel.add(Outcome(straight.format(n), betOdds))
self.wheel.bins[37].addOutcome(Outcome(straight.format("00"), betOdds))
self.wheel.add(Outcome(straight.format("00"), betOdds))
def test_outcome_winAmount():
black = Outcome("Black", 10)
assert black.winAmount(5) == 50
def setUp(self):
self.output = Outcome("Red", 11)
self.same = Outcome("Red", 11)
self.different = Outcome("Black", 11)
def setUp(self):
self.outcome1 = Outcome("1", 37)
self.outcome2 = Outcome("1", 37)
self.outcome3 = Outcome("2", 37)
