def testCreateHands(self): """Test creating multiple hands.""" deck = Deck() deck.shuffle() hands = deck.createHands(8, handClass=HoldEm.Hand) self.assertEquals(len(hands), 8) for hand in hands: self.assertEquals(len(hand), 2)
def test_Simulator(self):
"""Test basic Simulator construction"""
simulator = Simulator()
self.assertIsNotNone(simulator)
self.assertEqual(simulator.GAME_NAME, "Poker")
simulator = Simulator(number_of_hands=10)
self.assertIsNotNone(simulator)
deck = Deck()
hands = deck.createHands(9)
simulator = Simulator(predefined_hands=hands)
self.assertIsNotNone(simulator)
self.assertEqual(hands, simulator.get_predefined_hands())
def test_record_game(self):
"""Test Stats.record_game() and Stats.reset()"""
# Generate a result
deck = Deck()
hands = deck.createHands(9)
ranker = Ranker()
high_winners, high_rank = ranker.bestHand(hands)
low_ranker = LowRanker()
low_winners, low_rank = low_ranker.bestHand(hands)
result = Result(hands=hands,
high_winners=high_winners,
winning_high_rank=high_rank,
low_winners=low_winners,
winning_low_rank=low_rank)
stats = Stats()
stats.record_game(result)
self.assertEqual(stats.number_of_hands, 9)
self.assertEqual(stats.number_of_games, 1)
self.assertEqual(len(stats.high_winners), stats.number_of_hands)
self.assertEqual(len(stats.low_winners), stats.number_of_hands)
self.assertEqual(len(stats.scoops), stats.number_of_hands)
# Figure out if we have a scooper
if ((len(stats.high_winners) == 1) and
(len(stats.low_winners) == 1) and
(stats.high_winners[0] == stats.low_winners[0])):
scooper = stats.low_winners[0]
else:
scooper = None
for index in range(stats.number_of_hands):
if index in high_winners:
self.assertEqual(1, stats.high_winners[index])
else:
self.assertEqual(0, stats.high_winners[index])
if index in low_winners:
self.assertEqual(1, stats.low_winners[index])
else:
self.assertEqual(0, stats.low_winners[index])
if (scooper is not None) and (scooper == index):
self.assertEqual(1, stats.scoops[index])
else:
self.assertEqual(0, stats.scoops[index])
# OK, now try reseting stats
stats.reset()
self.assertEqual(stats.number_of_games, 0)
self.assertEqual(len(stats.high_winners), stats.number_of_hands)
self.assertEqual(len(stats.low_winners), stats.number_of_hands)
self.assertEqual(len(stats.scoops), stats.number_of_hands)
for index in range(stats.number_of_hands):
self.assertEqual(0, stats.high_winners[index])
self.assertEqual(0, stats.low_winners[index])
self.assertEqual(0, stats.scoops[index])
def test_Simulator_with_predefined(self):
"""Test Simulator with HoldEm hands and board"""
deck = Deck()
board = Board()
deck.dealHands(board)
hands = deck.createHands(9, handClass=HoldEm.Hand)
simulator = HoldEm.Simulator(predefined_hands=hands,
predefined_board=board)
self.assertIsNotNone(simulator)
result = simulator.simulate_game()
self.assertIsNotNone(result)
self.assertIsInstance(result, Result)
stats = simulator.simulate_games(number_of_games=4)
self.assertIsNotNone(stats)
self.assertIsInstance(stats, Stats)
def test_Result(self):
"""Test basic construction and operation of Result instance"""
deck = Deck()
hands = deck.createHands(9)
ranker = Ranker()
high_winners, high_rank = ranker.bestHand(hands)
low_ranker = LowRanker()
low_winners, low_rank = low_ranker.bestHand(hands)
result = Result(hands=hands,
high_winners=high_winners,
winning_high_rank=high_rank,
low_winners=low_winners,
winning_low_rank=low_rank)
self.assertIsNotNone(result)
self.assertListEqual(high_winners, result.high_winners)
self.assertEqual(high_rank, result.winning_high_rank)
self.assertListEqual(low_winners, result.low_winners)
self.assertEqual(low_rank, result.winning_low_rank)
self.assertListEqual(hands, result.hands)
def main(argv=None):
if argv is None:
argv = sys.argv
usage = "usage: %prog [<options>] Card1 Card2 Card3 Card4"
version = "%prog version 1.0"
parser = OptionParser(usage=usage, version=version)
parser.add_option("-n", "--numDeals", type="int", dest="numDeals",
default=1000,
help="number of deals to simulate (Default is 100)")
parser.add_option("-N", "--numHands", type="int", dest="numHands",
default=8, help="number of Hands (Default is 8)")
parser.add_option("-p", "--showProgress", action="store_true",
dest="showProgress", default=False, help="show progress")
(options, args) = parser.parse_args()
total = 0
pointOpeningHands = 0
pointRaisingHands = 0
pointReraisingHands = 0
maxPointOpeners = 0
openingHands = 0
for deal in xrange(options.numDeals):
deck = Deck()
deck.shuffle()
hands = deck.createHands(options.numHands, handClass = Omaha.Hand)
dealOpeners = 0
for h in hands:
value = h.pointValue()
total += value
if value > 25:
dealOpeners += 1
pointOpeningHands += 1
if value > 40:
pointRaisingHands += 1
if value > 50:
pointReraisingHands += 1
if h.openingHand():
openingHands += 1
if dealOpeners > maxPointOpeners:
maxPointOpeners = dealOpeners
# Update progress if so requested
if options.showProgress and (deal % 20 == 0):
sys.stdout.write(".")
sys.stdout.flush()
if options.showProgress:
print
totalHands = options.numDeals * options.numHands
avg = total/totalHands
print "Average point value: %d" % avg
print "\tOpeners: %5.2f%% Raisers: %5.2f%% Reraisers: %5.2f%%" % (
percent(pointOpeningHands, totalHands),
percent(pointRaisingHands, totalHands),
percent(pointReraisingHands, totalHands))
print "\tOpeners in a deal: Average %4.1f Max %d" % (
1.0 * pointOpeningHands / options.numDeals,
maxPointOpeners)
print "Opening Hands by Krieger method: %5.2f%%" % percent(openingHands,
totalHands)
