示例#1
0
    def _gen_split(self, wheel):
        """Generate all split bets and assign them to bins."""

        # retrieve outcome odds for this bet
        outcome_odds = RoulettePayout.SplitBet

        # create all left-right split bets iterating all rows and first 2 cols
        for row in range(12):
            for col in range(1, 3):

                # create outcome
                left_num = 3 * row + col
                right_num = left_num + 1
                outcome_name = "Split {}-{}".format(left_num, right_num)
                outcome = Outcome(outcome_name, outcome_odds)

                # assign outcome to bins
                wheel.add_outcome(left_num, outcome)
                wheel.add_outcome(right_num, outcome)

        # create all up-down split bets iterating first 11 rows and all cols
        for row in range(11):
            for col in range(1, 4):
                up_num = 3 * row + col
                down_num = up_num + 3
                outcome_name = "Split {}-{}".format(up_num, down_num)
                outcome = Outcome(outcome_name, outcome_odds)

                # assign outcome to bins
                wheel.add_outcome(up_num, outcome)
                wheel.add_outcome(down_num, outcome)
示例#2
0
    def _gen_straight(self, wheel):
        """Generate all straight bets and assign them to bins."""

        # retrieve outcome odds for this bet
        outcome_odds = RoulettePayout.StraightBet

        # create and assign outcomes for numbers from 1 to 36
        for i in range(1, 37):

            # create outcome
            outcome_name = "Number " + str(i)
            outcome = Outcome(outcome_name, outcome_odds)

            # assign to bin
            wheel.add_outcome(i, outcome)

        # create zero outcome and assign it to 0 bin
        outcome_name = "Number 0"
        outcome = Outcome(outcome_name, outcome_odds)
        wheel.add_outcome(0, outcome)

        # create double zero outcome and assign it to 00 bin
        outcome_name = "Number 00"
        outcome = Outcome(outcome_name, outcome_odds)
        wheel.add_outcome(37, outcome)
示例#3
0
    def testSpinWheelUsingNonRandom(self):
        bin = self.wheel.next()

        self.assertIn(Outcome("15", 35), bin.outcomes)
        self.assertIn(Outcome("LOW", 1), bin.outcomes)
        self.assertIn(Outcome("BLACK", 1), bin.outcomes)
        self.assertIn(Outcome("ODD", 1), bin.outcomes)
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_line(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("Line 1-2-3-4-5-6", RoulettePayout.LineBet)
        self.outcome2 = Outcome("Line 31-32-33-34-35-36",
                                RoulettePayout.LineBet)
        self.outcome3 = Outcome("Line 10-11-12-13-14-15",
                                RoulettePayout.LineBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(1))
        self.assertIn(self.outcome1, self.wheel.get(2))
        self.assertIn(self.outcome1, self.wheel.get(3))
        self.assertIn(self.outcome1, self.wheel.get(4))
        self.assertIn(self.outcome1, self.wheel.get(5))
        self.assertIn(self.outcome1, self.wheel.get(6))

        self.assertIn(self.outcome2, self.wheel.get(31))
        self.assertIn(self.outcome2, self.wheel.get(34))
        self.assertIn(self.outcome2, self.wheel.get(36))

        self.assertIn(self.outcome3, self.wheel.get(11))
        self.assertIn(self.outcome3, self.wheel.get(13))
        self.assertIn(self.outcome3, self.wheel.get(14))
示例#5
0
 def setUp(self):
     """
     set up data used in the tests.
     setUp is called before each test function execution.
     """
     self.first = Outcome("red", 1)
     self.second = Outcome("red", 1)
     self.third = Outcome("5 way", 6)
示例#6
0
    def setUp(self):
        self.outcome_5 = Outcome("00-0-1-2-3", RoulettePayout.FiveBet)
        self.outcome_0 = Outcome("Number 0", RoulettePayout.StraightBet)
        self.outcome_00 = Outcome("Number 00", RoulettePayout.StraightBet)

        self.bin_0 = Bin(self.outcome_0, self.outcome_5)
        self.bin_00 = Bin(self.outcome_00, self.outcome_5)

        self.bin_add = Bin()
示例#7
0
    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)
示例#8
0
 def setUp(self):
     self.sampleOutcomeOne = Outcome("1", 1)
     self.sampleOutcomeTwo = Outcome("Red", 17)
     self.outcomeOne = Outcome("0", 35)
     self.outcomeTwo = Outcome("00-0-1-2-3", 6)
     self.binOne = Bin(self.sampleOutcomeOne, self.sampleOutcomeTwo)
     self.binTwo = Bin(self.outcomeOne, self.outcomeTwo)
     self.rng = NonRandom()
     self.rng.setSeed(3)
     self.wheel = createWheel(self.rng)
示例#9
0
class TestOutcome(unittest.TestCase):
    def setUp(self):
        self.outcome1 = Outcome(name="red", odds=17)
        self.outcome2 = Outcome("red", 17)
        self.outcome3 = Outcome("first-12", 2)
        self.outcome4 = Outcome("split-bet", 19)

    def test_setup(self):
        self.assertEqual(self.outcome1, self.outcome2)
        self.assertNotEqual(self.outcome1, self.outcome3)
        self.assertEqual(self.outcome1.getName(), self.outcome2.getName())

    def test___eq__(self):
        self.assertTrue(self.outcome1.__eq__(self.outcome2))
        self.assertFalse(self.outcome1.__eq__(self.outcome3))

    def test___ne__(self):
        self.assertTrue(self.outcome1.__ne__(self.outcome3))
        self.assertFalse(self.outcome1.__ne__(self.outcome1))

    def test___str__(self):
        self.assertEqual(str(self.outcome1), "red (17:1)")
        self.assertEqual(self.outcome1.__str__(), "red (17:1)")

    def test___repr__(self):
        self.assertEqual(self.outcome1.__repr__(), "red (17:1)")

    def test_winAmount(self):
        self.assertEqual(self.outcome1.winAmount(10), 170)

    def test_hash(self):
        self.assertEqual(hash(self.outcome1), hash(self.outcome2))
        self.assertNotEqual(hash(self.outcome1), hash(self.outcome3))
示例#10
0
class OutcomeTest(unittest.TestCase):


    def setUp(self):
        """
        set up data used in the tests.
        setUp is called before each test function execution.
        """
        self.first = Outcome("red", 1)
        self.second = Outcome("red", 1)
        self.third = Outcome("5 way", 6)

    def test_equal(self):
        self.assertEquals(self.first, self.second, "%s is equal to %s" % (self.first, self.second))
        self.assertEquals(self.second, self.first, "%s is equal to %s" % (self.second, self.first))
        
    def test_unequal(self):
        self.assertNotEqual(self.first, self.third, "%s is not equal to %s" % (self.first, self.third))
        self.assertNotEqual(self.second, self.third, "%s is not equal to %s" % (self.second, self.third))

    def test_hash(self):
        self.assertTrue(self.first.__hash__() == self.second.__hash__(), "%d is equal to %d" % (self.first.__hash__(), self.second.__hash__()))
        self.assertFalse(self.first.__hash__() == self.third.__hash__(), "%d is not equals to %d" % (self.first.__hash__(), self.third.__hash__()))
        self.assertFalse(self.second.__hash__() == self.third.__hash__(), "%d is not equals to %d" % (self.second.__hash__(), self.third.__hash__()))
     
    def test_payout(self):
        self.assertTrue(self.first.win_amount(10) == 10);
        self.assertTrue(self.second.win_amount(5) == 5);
        self.assertTrue(self.third.win_amount(10) == 60);
示例#11
0
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_straight(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("Number 0", RoulettePayout.StraightBet)
        self.outcome2 = Outcome("Number 16", RoulettePayout.StraightBet)
        self.outcome3 = Outcome("Number 00", RoulettePayout.StraightBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(0))
        self.assertIn(self.outcome2, self.wheel.get(16))
        self.assertIn(self.outcome3, self.wheel.get(37))
示例#12
0
class TestOutcome(TestCase):
    def setUp(self):
        self.sampleOutcomeOne = Outcome("1", 1)
        self.sampleOutcomeTwo = Outcome("Red", 17)
        self.sampleOutcomeThree = Outcome("Red", 17)

    def test_sameNameReturnsTrue(self):
        self.assertEqual(True,
                         self.sampleOutcomeTwo.__eq__(self.sampleOutcomeThree))
        self.assertEqual(True,
                         self.sampleOutcomeThree.__eq__(self.sampleOutcomeTwo))

    def test_sameNameReturnsSameHash(self):
        self.assertEqual(
            True,
            self.sampleOutcomeTwo.__hash__() ==
            self.sampleOutcomeThree.__hash__())
        self.assertEqual(
            True,
            self.sampleOutcomeThree.__hash__() ==
            self.sampleOutcomeTwo.__hash__())

    def test_winAmount(self):
        self.assertEqual(170, self.sampleOutcomeTwo.winAmount(10))
        self.assertEqual(34, self.sampleOutcomeThree.winAmount(2))
示例#13
0
class OutcomeTests(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)

    def testEquality(self):
        self.assertEqual(self.outcome1, self.outcome2,
                         "Unequal outcomes with the same name")

    def testNonEquality(self):
        self.assertNotEqual(self.outcome1, self.outcome3,
                            "Equal outcomes with the same name")

    def testEqualHash(self):
        self.assertEqual(self.outcome1, self.outcome2,
                         "Unequal hashes of same name outcomes")

    def testUnequalHash(self):
        self.assertNotEqual(self.outcome1, self.outcome3,
                            "Equal hashes of same name outcomes")

    def testWinAmount(self):
        self.assertEqual(self.outcome1.winAmount(10), 20,
                         "Win amount wrong value")
示例#14
0
 def _addDozenBets(self):
     for dozen in range(1, 4):
         outcomeName = str(dozen) + '-' + str(dozen * 12)
         outcome = Outcome(outcomeName, self.DOZEN_VALUE)
         offset = 12 * (dozen - 1) + 1
         for binIndex in range(12):
             self.wheel.addOutcome(binIndex + offset, outcome)
示例#15
0
    def testBetsIterator(self):
        betFour = Bet(3, Outcome("test4", 2))
        betFive = Bet(2, Outcome("test5", 3))
        self.table.placeBet(self.betOne)
        self.table.placeBet(self.betTwo)
        self.table.placeBet(betFour)
        self.table.placeBet(betFive)

        betStrings = []
        for bet in self.table.bets:
            betStrings.append(str(bet))

        self.assertTrue("1 on test1" in betStrings, MISSING_BET_STRINGS_VALUE)
        self.assertTrue("2 on test2" in betStrings, MISSING_BET_STRINGS_VALUE)
        self.assertTrue("3 on test4" in betStrings, MISSING_BET_STRINGS_VALUE)
        self.assertTrue("2 on test5" in betStrings, MISSING_BET_STRINGS_VALUE)
示例#16
0
    def testMartingaleLoss(self):
        bet = Bet(1.0, Outcome("BLACK", 1))

        self.martingale.placeBets()
        self.martingale.lose(bet)

        self.assertEqual(1, self.martingale.lossCount)
        self.assertEqual(2, self.martingale.betMultiple)
示例#17
0
    def _addColumnBets(self):
        for column in range(1, 4):
            outcomeName = 'Column ' + str(column)
            outcome = Outcome(outcomeName, self.COLUMN_VALUE)

            for row in range(12):
                binIndex = 3 * row + column
                self.wheel.addOutcome(binIndex, outcome)
示例#18
0
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_split(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("Split 1-2", RoulettePayout.SplitBet)
        self.outcome2 = Outcome("Split 5-8", RoulettePayout.SplitBet)
        self.outcome3 = Outcome("Split 35-36", RoulettePayout.SplitBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(1))
        self.assertIn(self.outcome1, self.wheel.get(2))

        self.assertIn(self.outcome2, self.wheel.get(5))
        self.assertIn(self.outcome2, self.wheel.get(8))

        self.assertIn(self.outcome3, self.wheel.get(35))
        self.assertIn(self.outcome3, self.wheel.get(36))
示例#19
0
 def generateLeftRightPairsRows(self, wheel):
     for rowIndex in range(0, 12):
         wheel.addOutcome(
             rowIndex * 3 + 1,
             Outcome(
                 str(rowIndex * 3 + 1) + "-" + str(rowIndex * 3 + 2), 17))
         wheel.addOutcome(
             rowIndex * 3 + 2,
             Outcome(
                 str(rowIndex * 3 + 1) + "-" + str(rowIndex * 3 + 2), 17))
         wheel.addOutcome(
             rowIndex * 3 + 2,
             Outcome(
                 str(rowIndex * 3 + 2) + "-" + str(rowIndex * 3 + 3), 17))
         wheel.addOutcome(
             rowIndex * 3 + 3,
             Outcome(
                 str(rowIndex * 3 + 2) + "-" + str(rowIndex * 3 + 3), 17))
示例#20
0
    def _gen_five(self, wheel):
        """Generate five bet and assign them to its bins."""

        # retrieve outcome odds for this bet
        outcome_odds = RoulettePayout.FiveBet
        outcome = Outcome("00-0-1-2-3", outcome_odds)

        # assign to bins
        for num in [0, 37, 1, 2, 3]:
            wheel.add_outcome(num, outcome)
示例#21
0
    def testMartingaleWin(self):
        bet = Bet(1.0, Outcome("BLACK", 1))
        initialStake = self.martingale.stake - bet.amount

        self.martingale.placeBets()
        self.martingale.win(bet)

        winAmount = bet.winAmount() + initialStake
        self.assertEqual(0, self.martingale.lossCount)
        self.assertEqual(1, self.martingale.betMultiple)
        self.assertEqual(winAmount, self.martingale.stake)
示例#22
0
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_street(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("Street 16-17-18", RoulettePayout.StreetBet)
        self.outcome2 = Outcome("Street 1-2-3", RoulettePayout.StreetBet)
        self.outcome3 = Outcome("Street 34-35-36", RoulettePayout.StreetBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(16))
        self.assertIn(self.outcome1, self.wheel.get(17))
        self.assertIn(self.outcome1, self.wheel.get(18))

        self.assertIn(self.outcome2, self.wheel.get(1))
        self.assertIn(self.outcome2, self.wheel.get(2))
        self.assertIn(self.outcome2, self.wheel.get(3))

        self.assertIn(self.outcome3, self.wheel.get(34))
        self.assertIn(self.outcome3, self.wheel.get(35))
        self.assertIn(self.outcome3, self.wheel.get(36))
示例#23
0
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_even(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("Red", RoulettePayout.EvenBet)
        self.outcome2 = Outcome("Odd", RoulettePayout.EvenBet)
        self.outcome3 = Outcome("High", RoulettePayout.EvenBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(3))
        self.assertIn(self.outcome1, self.wheel.get(23))
        self.assertIn(self.outcome1, self.wheel.get(34))

        self.assertIn(self.outcome2, self.wheel.get(1))
        self.assertIn(self.outcome2, self.wheel.get(17))
        self.assertIn(self.outcome2, self.wheel.get(35))

        self.assertIn(self.outcome3, self.wheel.get(19))
        self.assertIn(self.outcome3, self.wheel.get(31))
        self.assertIn(self.outcome3, self.wheel.get(36))
示例#24
0
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_dozen(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("Dozen 1", RoulettePayout.DozenBet)
        self.outcome2 = Outcome("Dozen 2", RoulettePayout.DozenBet)
        self.outcome3 = Outcome("Dozen 3", RoulettePayout.DozenBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(1))
        self.assertIn(self.outcome1, self.wheel.get(7))
        self.assertIn(self.outcome1, self.wheel.get(12))

        self.assertIn(self.outcome2, self.wheel.get(15))
        self.assertIn(self.outcome2, self.wheel.get(16))
        self.assertIn(self.outcome2, self.wheel.get(18))

        self.assertIn(self.outcome3, self.wheel.get(25))
        self.assertIn(self.outcome3, self.wheel.get(30))
        self.assertIn(self.outcome3, self.wheel.get(36))
示例#25
0
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_column(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("Column 1", RoulettePayout.ColumnBet)
        self.outcome2 = Outcome("Column 2", RoulettePayout.ColumnBet)
        self.outcome3 = Outcome("Column 3", RoulettePayout.ColumnBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(1))
        self.assertIn(self.outcome1, self.wheel.get(4))
        self.assertIn(self.outcome1, self.wheel.get(7))

        self.assertIn(self.outcome2, self.wheel.get(11))
        self.assertIn(self.outcome2, self.wheel.get(14))
        self.assertIn(self.outcome2, self.wheel.get(20))

        self.assertIn(self.outcome3, self.wheel.get(24))
        self.assertIn(self.outcome3, self.wheel.get(30))
        self.assertIn(self.outcome3, self.wheel.get(36))
示例#26
0
    def _gen_even(self, wheel):
        """Generate all even bets and assign them to bins."""

        # retrieve outcome odds for this bet
        outcome_odds = RoulettePayout.EvenBet

        outcome_low = Outcome("Low", outcome_odds)
        outcome_high = Outcome("High", outcome_odds)
        outcome_even = Outcome("Even", outcome_odds)
        outcome_odd = Outcome("Odd", outcome_odds)
        outcome_red = Outcome("Red", outcome_odds)
        outcome_black = Outcome("Black", outcome_odds)

        # iterate all numbers assining corresponding even bets
        for num in range(1, 37):

            # assign low-high bets
            if num < 19:
                wheel.add_outcome(num, outcome_low)
            else:
                wheel.add_outcome(num, outcome_high)

            # assign even-odd bets
            if num % 2 == 0:
                wheel.add_outcome(num, outcome_even)
            else:
                wheel.add_outcome(num, outcome_odd)

            # assign even-odd bets
            if num in self.RED_NUMBERS:
                wheel.add_outcome(num, outcome_red)
            else:
                wheel.add_outcome(num, outcome_black)
示例#27
0
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_five(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("00-0-1-2-3", RoulettePayout.FiveBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(0))
        self.assertIn(self.outcome1, self.wheel.get(37))
        self.assertIn(self.outcome1, self.wheel.get(1))
        self.assertIn(self.outcome1, self.wheel.get(2))
        self.assertIn(self.outcome1, self.wheel.get(3))
示例#28
0
    def _gen_dozen(self, wheel):
        """Generate all dozen bets and assign them to bins."""

        # retrieve outcome odds for this bet
        outcome_odds = RoulettePayout.DozenBet

        # create and assign a dozen bet for each number
        for dozen in range(3):

            outcome_name = "Dozen " + str(dozen + 1)
            outcome = Outcome(outcome_name, outcome_odds)

            # assign outcome to bins
            for num in [i + (12 * dozen) for i in range(1, 13)]:
                wheel.add_outcome(num, outcome)
示例#29
0
    def runTest(self):
        # call method to be tested
        self.bin_builder._gen_corner(self.wheel)

        # create some outcomes that should be there
        self.outcome1 = Outcome("Corner 1-2-4-5", RoulettePayout.CornerBet)
        self.outcome2 = Outcome("Corner 2-3-5-6", RoulettePayout.CornerBet)
        self.outcome3 = Outcome("Corner 32-33-35-36", RoulettePayout.CornerBet)

        # check outcomes were created ok
        self.assertIn(self.outcome1, self.wheel.get(1))
        self.assertIn(self.outcome1, self.wheel.get(2))
        self.assertIn(self.outcome1, self.wheel.get(4))
        self.assertIn(self.outcome1, self.wheel.get(5))

        self.assertIn(self.outcome2, self.wheel.get(2))
        self.assertIn(self.outcome2, self.wheel.get(3))
        self.assertIn(self.outcome2, self.wheel.get(5))
        self.assertIn(self.outcome2, self.wheel.get(6))

        self.assertIn(self.outcome3, self.wheel.get(32))
        self.assertIn(self.outcome3, self.wheel.get(33))
        self.assertIn(self.outcome3, self.wheel.get(35))
        self.assertIn(self.outcome3, self.wheel.get(36))
示例#30
0
    def _gen_column(self, wheel):
        """Generate all column bets and assign them to bins."""

        # retrieve outcome odds for this bet
        outcome_odds = RoulettePayout.ColumnBet

        # create and assign a dozen bet for each number
        for col in range(1, 4):

            outcome_name = "Column " + str(col)
            outcome = Outcome(outcome_name, outcome_odds)

            # assign outcome to bins
            for num in [i * 3 + col for i in range(12)]:
                wheel.add_outcome(num, outcome)
示例#31
0
    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()
示例#32
0
 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]
示例#33
0
def test_winAmount():
    outcome = Outcome("red", 1)
    amount = 500
    winnings = outcome.winAmount(amount)
    assert_almost_equal(winnings, 500)