class WheelTests(unittest.TestCase):
def setUp(self):
self.outcome1 = Outcome("Red", 2)
self.outcome2 = Outcome("Red", 2)
self.outcome3 = Outcome("Black", 2)
self.outcome4 = Outcome("Black", 3)
self.bin1 = Bin(self.outcome1)
self.bin2 = Bin(self.outcome1, self.outcome2)
self.bin3 = Bin(self.outcome1, self.outcome3)
def testNonRandomCreation(self):
self.nonrandomOne = NonRandom()
self.nonrandomOne.setSeed(1)
self.nonrandomTwo = NonRandom()
self.nonrandomTwo.setSeed(2)
def testWheelCreation(self):
self.testNonRandomCreation()
self.wheelOne = Wheel(self.nonrandomOne)
self.wheelTwo = Wheel(self.nonrandomTwo)
def testBinModification(self):
self.testWheelCreation()
self.wheelOne.addOutcome(1, self.outcome1)
self.assertEqual(self.wheelOne.next(), self.wheelOne.get(1),
"Wheel returned different bin")
def test_splitBets():
rng = NonRandom()
wheel = Wheel(rng)
binbuilder = BinBuilder(wheel)
binbuilder.splitBets()
two_splits = [1, 3, 34, 36]
for i in two_splits:
wheel.rng.setSeed(i)
returned_bin = wheel.next()
assert len(returned_bin.outcomes) == 2
for i in range(4, 34):
wheel.rng.setSeed(i)
returned_bin = wheel.next()
if (i - 2) % 3 == 0:
assert len(returned_bin.outcomes) == 4
else:
assert len(returned_bin.outcomes) == 3
remaining = [2, 35]
for i in remaining:
wheel.rng.setSeed(i)
returned_bin = wheel.next()
assert len(returned_bin.outcomes) == 3
def getOutcome(self, outcome_name):
"""Query a constructed wheel for getting outcome."""
# create Whell
wheel = Wheel()
return wheel.getOutcome(outcome_name)
def test_cornerBets():
rng = NonRandom()
wheel = Wheel(rng)
binbuilder = BinBuilder(wheel)
binbuilder.cornerBets()
one_corner = [1, 3, 34, 36]
for i in one_corner:
wheel.rng.setSeed(i)
returned_bin = wheel.next()
assert len(returned_bin.outcomes) == 1
for i in range(4, 34):
wheel.rng.setSeed(i)
returned_bin = wheel.next()
if (i - 2) % 3 == 0:
assert len(returned_bin.outcomes) == 4
else:
assert len(returned_bin.outcomes) == 2
remaining = [2, 35]
for i in remaining:
wheel.rng.setSeed(i)
returned_bin = wheel.next()
assert len(returned_bin.outcomes) == 2
def test_streetBets():
rng = NonRandom()
wheel = Wheel(rng)
binbuilder = BinBuilder(wheel)
binbuilder.streetBets()
for i in range(1, 37):
wheel.rng.setSeed(i)
returned_bin = wheel.next()
assert len(returned_bin.outcomes) == 1
def setUp(self):
# create outcomes
self.outcome_5 = Outcome("00-0-1-2-3", 6)
self.outcome_0 = Outcome("0", 35)
self.outcome_00 = Outcome("00", 35)
# create wheel and bin builder
self.wheel = Wheel()
self.bin_builder = BinBuilder()
class Test(unittest.TestCase):
def setUp(self):
self.five = Outcome("00-0-1-2-3", 6)
self.zero = Outcome("0", 35)
self.zerozero = Outcome("00", 35)
rng = NonRandom(0, 1)
rng.set_seed(5);
self.wheel = Wheel(rng)
def test_populate_wheel(self):
self.wheel.add_outcome(5, self.five)
self.wheel.add_outcome(0, self.zero)
self.wheel.add_outcome(37, self.zerozero)
self.assertEqual(len(self.wheel.bins), 38, "Number of bins == %d" % (len(self.wheel.bins)))
bin0 = self.wheel.bins[0]
bin5 = self.wheel.bins[5]
bin00 = self.wheel.bins[37]
self.assertTrue(self.zero in bin0.outcomes, "%s is in %s" % (self.zero, bin0))
self.assertTrue(self.five in bin5.outcomes, "%s is in %s" % (self.five, bin5))
self.assertTrue(self.zerozero in bin00.outcomes, "%s is in %s" % (self.zerozero, bin0))
self.assertTrue(bin0 in self.wheel.bins)
self.assertTrue(bin5 in self.wheel.bins)
self.assertTrue(bin00 in self.wheel.bins)
def test_random_bin(self):
self.wheel.add_outcome(5, self.five)
self.wheel.add_outcome(0, self.zero)
self.wheel.add_outcome(37, self.zerozero)
random_bin = self.wheel.next()
self.assertTrue(self.five in random_bin.outcomes)
def test_bin_addition():
""" testing if we can add/get outcomes to corresponding bins on the wheel"""
outcome1 = Outcome("red", 1)
outcome2 = Outcome("black", 1)
outcome3 = Outcome("low", 5)
outcome4 = Outcome("high", 5)
rng = NonRandom()
wheel = Wheel(rng)
wheel.addOutcome(1, outcome1)
wheel.addOutcome(1, outcome3)
wheel.addOutcome(31, outcome2)
wheel.addOutcome(31, outcome4)
# since we added only two outcomes for each of the two bins,
# the number of outcomes for both bins should be 2 and 0 for all others
wheel.rng.setSeed(1)
returned_bin = wheel.next()
outcomes = returned_bin.outcomes
print outcomes
assert len(outcomes) == 2
assert outcome1 in returned_bin.outcomes
assert outcome3 in returned_bin.outcomes
wheel.rng.setSeed(31)
returned_bin = wheel.next()
assert outcome3, outcome2 in returned_bin.outcomes
assert outcome3, outcome4 in returned_bin.outcomes
for i in range(0, 38):
if i not in [1, 31]:
wheel.rng.setSeed(i)
returned_bin = wheel.next()
assert len(returned_bin.outcomes) == 0
def test_placeBets():
table_limit = 1000
table = Table(table_limit)
rng = NonRandom()
wheel = Wheel(rng)
binbuilder = BinBuilder(wheel)
binbuilder.straightBets()
outcome = wheel.getOutcome("1")
amount = 500
bet = Bet(amount, outcome)
invalid = True
try:
table.placeBet(bet)
invalid = False
except InvalidBet:
print "bet not valid"
invalid = True
assert table.bets[0] == bet
assert len(table.bets) == 1
assert invalid is False
amount = 300
bet = Bet(amount, outcome)
invalid = True
try:
table.placeBet(bet)
invalid = False
except InvalidBet:
print "bet not valid"
invalid = True
assert table.bets[1] == bet
assert len(table.bets) == 2
assert invalid is False
amount = 900
bet = Bet(amount, outcome)
invalid = True
try:
table.placeBet(bet)
invalid = False
except InvalidBet:
print "bet not valid"
invalid = True
assert len(table.bets) == 2
assert invalid is True
def setUp(self):
self.five = Outcome("00-0-1-2-3", 6)
self.zero = Outcome("0", 35)
self.zerozero = Outcome("00", 35)
rng = NonRandom(0, 1)
rng.set_seed(5);
self.wheel = Wheel(rng)
def setUp(self):
# create NonRandom instance with seed
non_random = NonRandom()
non_random.setSeed(1)
# create wheel with NonRandom instance
self.wheel = Wheel(non_random)
def test_win_loseAmount():
rng = NonRandom()
wheel = Wheel(rng)
binbuilder = BinBuilder(wheel)
binbuilder.straightBets()
outcome = wheel.getOutcome("1")
amount = 500
bet = Bet(amount, outcome)
for i in range(0, 38):
wheel.rng.setSeed(i)
returned_bin = wheel.next()
returned_outcomes = returned_bin.outcomes
if outcome in returned_outcomes:
assert bet.winAmount() == 500 + 500 * outcome.odds
else:
assert bet.loseAmount() == 500
def setUp(self):
randomNumberGenerator = randint
self.wheel = Wheel(randomNumberGenerator)
self.binBuilder = BinBuilder()
self.redOutcome = Outcome("RED", 1)
self.blackOutcome = Outcome("BLACK", 1)
self.evenOutcome = Outcome("EVEN", 1)
self.oddOutcome = Outcome("ODD", 1)
self.highOutcome = Outcome("HIGH", 1)
self.lowOutcome = Outcome("LOW", 1)
self.redNums = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36]
def setUp(self):
# create NonRandom instance with seed
non_random = NonRandom()
non_random.setSeed(1)
# create game
self.wheel = Wheel(non_random)
self.table = Table()
self.game = Game(self.wheel, self.table)
# create player
self.player = Passenger57(self.table)
self.player.setStake(1000)
def main():
# create game and player
wheel = Wheel()
table = Table()
game = Game(wheel, table)
player = Martingale(table)
# create simulator instance
simulator = Simulator(game, player)
simulator.gather()
# print results
print("Maximum", simulator.maximum, "\n")
print("Final", simulator.final, "\n")
print("Durations", simulator.durations, "\n")
def test_mapping():
outcome1 = Outcome("red", 1)
outcome2 = Outcome("black", 2)
rng = NonRandom()
wheel = Wheel(rng)
wheel.addOutcome(1, outcome1)
wheel.addOutcome(2, outcome2)
wheel.addOutcome(4, outcome2)
out = wheel.getOutcome("red")
assert out == outcome1
out = wheel.getOutcome("black")
assert out == outcome2
def setUp(self):
# create player
self.table = Table()
self.player = SevenReds(self.table)
self.player.setStake(1000)
# create bets to test them
self.bet1 = Bet(1, self._getOutcome("Black"))
self.bet2 = Bet(2, self._getOutcome("Black"))
self.bet3 = Bet(4, self._getOutcome("Black"))
# create NonRandom instance with seed
non_random = NonRandom()
non_random.setSeed(1)
# create game
self.wheel = Wheel(non_random)
self.game = Game(self.wheel, self.table)
def setUp(self):
# create NonRandom instance with seed
non_random = NonRandom()
non_random.setSeed(1)
# create game and player
wheel = Wheel(non_random)
table = Table()
game = Game(wheel, table)
player = Martingale(table)
# assign default values to prevent future changes on them
player.BASE_AMOUNT = 1
player.BASE_BET = "Black"
# create simulator instance
self.simulator = Simulator(game, player)
self.simulator.SAMPLES = 3
def testWheelCreation(self):
self.testNonRandomCreation()
self.wheelOne = Wheel(self.nonrandomOne)
self.wheelTwo = Wheel(self.nonrandomTwo)
def _getOutcome(self, outcome_name):
# create Whell
wheel = Wheel()
return wheel.getOutcome(outcome_name)
class WheelConstructionTestCase(unittest.TestCase):
def setUp(self):
# create outcomes
self.outcome_5 = Outcome("00-0-1-2-3", 6)
self.outcome_0 = Outcome("0", 35)
self.outcome_00 = Outcome("00", 35)
# create wheel and bin builder
self.wheel = Wheel()
self.bin_builder = BinBuilder()
def test_add_outcome(self):
# Bin 0 outcomes
self.wheel.add_outcome(0, self.outcome_0)
self.wheel.add_outcome(0, self.outcome_5)
# Bin 00 outcomes
self.wheel.add_outcome(37, self.outcome_00)
self.wheel.add_outcome(37, self.outcome_5)
# assert Bin 0 outcomes
self.assertIn(self.outcome_0, self.wheel.get(0))
self.assertIn(self.outcome_5, self.wheel.get(0))
# assert Bin 00 outcomes
self.assertIn(self.outcome_00, self.wheel.get(37))
self.assertIn(self.outcome_5, self.wheel.get(37))
def test_bin_building(self):
# build bins for the wheel
self.bin_builder.buildBins(self.wheel)
sample_bin1 = [
Outcome("Street 1-2-3", RoulettePayout.StreetBet),
Outcome("Number 1", RoulettePayout.StraightBet),
Outcome("Line 1-2-3-4-5-6", RoulettePayout.LineBet),
Outcome("Low", RoulettePayout.EvenBet),
Outcome("Odd", RoulettePayout.EvenBet),
Outcome("Red", RoulettePayout.EvenBet),
Outcome("Corner 1-2-4-5", RoulettePayout.CornerBet),
Outcome("Dozen 1", RoulettePayout.DozenBet),
Outcome("Column 1", RoulettePayout.ColumnBet),
Outcome("Split 1-2", RoulettePayout.SplitBet),
Outcome("Split 1-4", RoulettePayout.SplitBet),
Outcome("00-0-1-2-3", RoulettePayout.FiveBet)
]
sample_bin2 = [
Outcome("Number 00", RoulettePayout.StraightBet),
Outcome("00-0-1-2-3", RoulettePayout.FiveBet)
]
# check number of outcomes to be equal
self.assertEqual(len(sample_bin1), len(self.wheel.get(1)))
self.assertEqual(len(sample_bin2), len(self.wheel.get(37)))
# check outcomes to be in the bin 1
for outcome in sample_bin1:
self.assertIn(outcome, self.wheel.get(1))
# check outcomes to be in the bin 00
for outcome in sample_bin2:
self.assertIn(outcome, self.wheel.get(37))
def test_outcome_mapping(self):
# add outcomes to wheel
self.wheel.add_outcome(0, self.outcome_0)
self.wheel.add_outcome(37, self.outcome_00)
self.wheel.add_outcome(3, self.outcome_5)
# check that they are mapped
self.assertEqual(self.wheel.getOutcome(self.outcome_0.getName()),
self.outcome_0)
self.assertEqual(self.wheel.getOutcome(self.outcome_00.getName()),
self.outcome_00)
self.assertEqual(self.wheel.getOutcome(self.outcome_5.getName()),
self.outcome_5)
def __init__(self):
self.wheel = Wheel(NonRandom())
self.table = Table()
self.player = PassengerFiftySeven(self.table)
self.game = RouletteGame(self.wheel, self.table)
> while no of players>0
>player[i] bet
>roll wheel
>display amount of each player
"""
if __name__ == "__main__":
table_limit = int(raw_input("> Table limit? "))
while (table_limit < 0):
print "table limit should be greater than 0"
table_limit = int(raw_input("> Table limit? "))
table = Table(table_limit)
wheel = Wheel()
bin_builder = BinBuilder(wheel)
bin_builder.buildBins()
game = Game(wheel, table)
num_of_players = raw_input(">How many players (currently just one)?")
while num_of_players.isdigit() is False:
print "number of players should be an integer value"
num_of_players = raw_input(">How many players?")
players = []
player_stakes = 1000
for i in xrange(int(num_of_players)):
player_name = raw_input("> Name for player%d: " % (i+1))
player = Player(table, player_name, player_stakes)
players.append(player)
def setUp(self):
self.wheel = Wheel()
self.bin_builder = BinBuilder()
