def testHistory2messagesShowdown(self):
"""Test Poker Game History to message showdown"""
board = pokercards.PokerCards(['Ad', 'As'])
hand1 = pokercards.PokerCards(['4d', 'Ts'])
hand2 = pokercards.PokerCards(['3h', 'Kc'])
nocards = pokercards.PokerCards(
[pokercards.PokerCards.NOCARD, pokercards.PokerCards.NOCARD])
history = [
('showdown', board, {
1: hand1,
2: hand2
}),
('showdown', pokercards.PokerCards(), {
1: hand1,
2: nocards
}),
]
subject, message = self.GetMessagesFromHistory(history, str, True)
self.failUnlessEqual(subject, '')
self.failUnlessEqual(message, [
'Board: Ad As', 'Cards player 1: 4d Ts', 'Cards player 2: 3h Kc',
'Cards player 1: 4d Ts'
])
def testAreAllNocard(self):
"""Test PokerCards : Are all no card"""
cards = pokercards.PokerCards([12, 26])
self.failIf(cards.areAllNocard())
cards = pokercards.PokerCards([cards.nocard(), 26])
self.failIf(cards.areAllNocard())
cards = pokercards.PokerCards([cards.nocard(), cards.nocard()])
self.failUnless(cards.areAllNocard())
def testAddInvisible(self):
"""Test PokerCards : Add invisible card"""
cards = pokercards.PokerCards()
cards.add(12, False)
self.failUnless(cards.hasCard(12))
self.failUnlessEqual(cards.getVisible(), [])
cards = pokercards.PokerCards()
cards.add('3s', False)
self.failUnless(cards.hasCard(40))
self.failUnlessEqual(cards.getVisible(), [])
def testOperatorEqu(self):
"""Test PokerCards : Cards operator equ and ne"""
cards1 = pokercards.PokerCards([12, 26])
cards2 = pokercards.PokerCards([26, 12])
cards3 = pokercards.PokerCards([26, 12, 50])
self.failIf(cards1 == [12, 26])
self.failUnless(cards1 != [12, 26])
self.failUnless(cards1 == cards2)
self.failIf(cards1 == cards3)
self.failUnless(cards1 != cards3)
def testAddVisible(self):
"""Test PokerCards : Add visible card"""
cards = pokercards.PokerCards()
cards.add(12, True)
self.failUnless(cards.hasCard(12))
self.failUnlessEqual(cards.getVisible(), [12])
cards = pokercards.PokerCards()
cards.add('3s', True)
self.failUnless(cards.hasCard(40))
self.failUnlessEqual(cards.getVisible(), [40])
cards.add(cards.nocard(), True)
self.failUnless(cards.hasCard(cards.nocard()))
def testPokerGameMessage(self):
"""Test Poker game messages"""
game_time = time.time()
board = pokercards.PokerCards()
hand1 = pokercards.PokerCards(['4d', 'Ts'])
hand2 = pokercards.PokerCards(['3h', 'Kc'])
history = [
('game', 1, 2, 3, game_time, 'variant','betting_structure', [1, 2], 7, { 1 : 500, 2 : 1000}),
('wait_for', 1, 'first_round'),
('player_list', [1, 2]),
('round', 'round1', board, { 1 : hand1, 2 : hand2}),
('showdown', board, {1 : hand1, 2 : hand2}),
('position', 1, 1),
('blind_request', 1, 1000, 100, 'big_and_dead'),
('wait_blind', 1),
('blind', 1, 1000, 0),
('ante_request', 1, 100),
('ante', 1, 500),
('all-in', 1),
('call', 1, 500),
('check', 1),
('fold', 1),
('raise', 1, 500),
('canceled', 1, 10),
('end', [1], [{ 'serial2share': { 1: 500 } }]),
('sitOut', 1),
('leave', [(1, 2), (2, 7)]),
('finish', 1),
('muck', (1,2)),
('rebuy', 1, 500),
('unknown',)
]
# Register the callback function
self.game.registerCallback(Callback)
# Generate all the type of messages managed
for message in history:
self.game.historyAdd(*message)
# All the messages are stored
self.failUnlessEqual(self.game.historyGet(), history)
# Check the callback calls
self.failUnlessEqual(CallbackArgs, history)
def testAddInvalid(self):
"""Test PokerCards : Invalid card adding"""
cards = pokercards.PokerCards()
self.failUnlessRaises(UserWarning, cards.add, 52, True)
self.failUnlessRaises(UserWarning, cards.add, -1, True)
self.failUnlessRaises(UserWarning, cards.add, 'Aa', True)
def testIsEmpty(self):
"""Test PokerCards : Is empty"""
cards = pokercards.PokerCards()
self.failUnless(cards.isEmpty())
cards.add(12, True)
self.failIf(cards.isEmpty())
def testLen(self):
"""Test PokerCards : Cards lenght"""
cards = pokercards.PokerCards()
self.failUnlessEqual(cards.len(), 0)
cards.add(12, True)
self.failUnlessEqual(cards.len(), 1)
def testCopy(self):
"""Test PokerCards : Cards copy"""
cards1 = pokercards.PokerCards([12, 26])
cards2 = cards1.copy()
self.failUnless(cards1 == cards2)
cards2.add(13, True)
self.failIf(cards1 == cards2)
def testOperatorStr(self):
"""Test PokerCards : Operator str"""
cards = pokercards.PokerCards()
cards.add(12, True)
cards.add(26, False)
self.failUnlessEqual(
str(cards), str(['Card(12, visible)', 'Card(26, not visible)']))
def testInit(self):
"""Test PokerCards : Creation of cards"""
empty = pokercards.PokerCards()
self.failUnlessEqual(empty.toRawList(), [])
cards = pokercards.PokerCards(12)
self.failUnlessEqual(cards.toRawList(), [12])
self.failUnless(cards.areVisible())
cards = pokercards.PokerCards(
[12, 25, 37, pokercards.PokerCards.NOCARD])
self.failUnlessEqual(cards.toRawList(),
[12, 25, 37, pokercards.PokerCards.NOCARD])
self.failIf(cards.areVisible())
cards = pokercards.PokerCards('Ah')
self.failUnlessEqual(cards.toRawList(), [12])
self.failUnless(cards.areVisible())
cards = pokercards.PokerCards(['Ah', 'Ad', 'Kc'])
self.failUnlessEqual(cards.toRawList(), [12, 25, 37])
self.failUnless(cards.areVisible())
cards = pokercards.PokerCards(['Ah', 25, 'Kc'])
self.failUnlessEqual(cards.toRawList(), [12, 25, 37])
self.failUnless(cards.areVisible())
cards2 = pokercards.PokerCards(cards)
self.failUnlessEqual(cards2, cards)
def TestGetValue(self):
"""Test PokerCards : Get value"""
cards = pokercards.PokerCards()
self.failUnlessEqual(cards.getValue(12), 12)
self.failUnlessEqual(cards.getValue('Ah'), 12)
self.failUnlessEqual(cards.getValue(PokerCards.NOCARD))
self.failUnlessRaises(UserWarning, cards.add, 52, True)
self.failUnlessRaises(UserWarning, cards.add, -1, True)
self.failUnlessRaises(UserWarning, cards.add, 'Aa', True)
def testAllVisible(self):
"""Test PokerCards : All cards visible"""
cards = pokercards.PokerCards()
cards.add(12, False)
cards.add(25, False)
cards.add(45, False)
self.failUnlessEqual(cards.getVisible(), [])
cards.allVisible()
self.failUnless(cards.areVisible())
def testAllHidden(self):
"""Test PokerCards : All cards hidden"""
cards = pokercards.PokerCards()
cards.add(12, True)
cards.add(25, False)
cards.add(45, True)
self.failUnlessEqual(cards.getVisible(), [12, 45])
self.failIf(cards.areHidden())
cards.allHidden()
self.failUnless(cards.areHidden())
def testPokerPlayerCopy(self):
"""Test Poker Player : Copy"""
for attribute in PokerPlayerTestCase.PokerPlayerAttributes:
setattr(self.player, attribute, random.randint(0, RAND_MAX))
self.player.hand = pokercards.PokerCards()
copy = self.player.copy()
for attribute in PokerPlayerTestCase.PokerPlayerAttributes:
try:
self.failUnlessEqual(getattr(self.player, attribute),
getattr(copy, attribute))
except:
self.fail('Exception during accessing attribute ' + attribute)
def testToList(self):
"""Test PokerCards : Cards to list"""
cards = pokercards.PokerCards([12, 26])
self.failUnlessEqual(cards.tolist(False), [12, 26])
self.failUnlessEqual(cards.tolist(True), [12, 26])
cards.setVisible(26, False)
self.failUnlessEqual(cards.tolist(False), [12, cards.nocard()])
self.failUnlessEqual(cards.tolist(True), [12, 26])
cards.allHidden()
self.failUnlessEqual(cards.tolist(False),
[cards.nocard(), cards.nocard()])
self.failUnlessEqual(cards.tolist(True), [12, 26])
def testLoseNotVisible(self):
"""Test PokerCards : Lose not visible"""
cards = pokercards.PokerCards([12, 26])
cards.loseNotVisible()
self.failUnlessEqual(cards.toRawList(), [12, 26])
cards.add(33, False)
cards.loseNotVisible()
self.failUnlessEqual(cards.toRawList(), [12, 26, cards.nocard()])
cards.add(43, True)
cards.loseNotVisible()
self.failUnlessEqual(cards.toRawList(), [12, 26, cards.nocard(), 43])
cards.add(cards.nocard(), True)
cards.loseNotVisible()
self.failUnlessEqual(
cards.toRawList(),
[12, 26, cards.nocard(), 43,
cards.nocard()])
def testSetVisible(self):
"""Test PokerCards : Set card visible"""
cards = pokercards.PokerCards()
cards.add(12, True)
self.failUnlessEqual(cards.getVisible(), [12])
cards.setVisible(12, False)
self.failUnlessEqual(cards.getVisible(), [])
cards.setVisible(12, True)
self.failUnlessEqual(cards.getVisible(), [12])
cards.setVisible(15, True)
self.failUnlessEqual(cards.getVisible(), [12])
cards.setVisible(cards.nocard(), False)
self.failUnlessEqual(cards.getVisible(), [12])
def testBeginTurn(self):
"""Test Poker Player : Begin turn"""
Attributes = {
'bet': 0,
'dead': 0,
'fold': False,
'hand': pokercards.PokerCards(),
'side_pot_index': 0,
'all_in': False,
'blind': False,
'ante': False
}
for key in Attributes.keys():
setattr(self.player, key, random.random())
self.player.beginTurn()
for key, value in Attributes.items():
self.failUnlessEqual(getattr(self.player, key), value)
def testHistory2messagesEnd(self):
"""Test Poker Game History to end message"""
self.game.variant = 'holdem'
# The player 1 wins because all the other players are fold
game_state = {'serial2share': {1: 500}, 'foldwin': True}
history = [('end', [1], [game_state])]
subject, message = self.GetMessagesFromHistory(history)
self.failUnlessEqual(subject, '')
message1 = '1 receives 5 (everyone else folded)'
self.failUnlessEqual(message, [message1])
# Invalid frame
invalid_frame = {'type': 'invalid'}
hand1 = pokercards.PokerCards(['Ad', 'As'])
board = pokercards.PokerCards(['9d', '6s', 'Td', '4d', '4h'])
game_state = {
'serial2best': {
1: {
'hi':
self.game.eval.best(
'hi',
hand1.tolist(True) + board.tolist(True), []),
'low':
self.game.eval.best(
'low',
hand1.tolist(True) + board.tolist(True), [])
}
},
'foldwin': False
}
history = [('end', [1], [game_state, invalid_frame])]
subject, message = self.GetMessagesFromHistory(history)
self.failUnlessEqual(subject, '')
self.failUnlessEqual(message, [])
# Left over frame
frame = {'type': 'left_over', 'serial': 1, 'chips_left': 10}
history = [('end', [1], [game_state, frame])]
subject, message = self.GetMessagesFromHistory(history)
self.failUnlessEqual(subject, '')
self.failUnlessEqual(message, ['1 receives 10 odd chips'])
# uncalled frame
frame = {'type': 'uncalled', 'serial': 1, 'uncalled': 10}
history = [('end', [1], [game_state, frame])]
subject, message = self.GetMessagesFromHistory(history)
self.failUnlessEqual(subject, '')
self.failUnlessEqual(message, ['returning uncalled bet 0.10 to 1'])
# Resolve frame 1
frame = {
'type': 'resolve',
'serials': [1, 2, 3],
'serial2share': {
1: 300,
2: 200
},
'hi': [1, 2],
'low': [1],
'pot': 500,
'chips_left': 3
}
hand1 = pokercards.PokerCards(['8h', '2s'])
hand2 = pokercards.PokerCards(['Ac', '2c'])
board = pokercards.PokerCards(['9d', '5s', '3h', '4d', '5s'])
game_state = {
'serial2best': {
1: {
'hi':
self.game.eval.best(
'hi',
hand1.tolist(True) + board.tolist(True), []),
'low':
self.game.eval.best(
'low',
hand1.tolist(True) + board.tolist(True), [])
},
2: {
'hi':
self.game.eval.best(
'hi',
hand2.tolist(True) + board.tolist(True), []),
'low':
self.game.eval.best(
'low',
hand2.tolist(True) + board.tolist(True), [])
}
},
'foldwin': False
}
history = [('end', [1], [game_state, frame])]
subject, message = self.GetMessagesFromHistory(history)
self.failUnlessEqual(subject, '')
self.failUnlessEqual(message, [
'1 shows High card Nine for hi ', '1 shows 8, 5, 4, 3, 2 for low ',
'2 shows Straight Five to Ace for hi ', '1 2 tie for hi ',
'1 wins low ', 'winners share a pot of 5 (minus 3 odd chips)',
'1 receives 3', '2 receives 2'
])
# Resolve frame 2
frame = {
'type': 'resolve',
'serials': [1, 2],
'serial2share': {
1: 300,
2: 200
},
'hi': [1, 2],
'pot': 500,
'chips_left': 3
}
hand1 = pokercards.PokerCards(['Ad', 'As'])
hand2 = pokercards.PokerCards(['Kd', '3c'])
board = pokercards.PokerCards(['9d', '6s', 'Td', '4d', '4h'])
game_state = {
'serial2best': {
1: {
'hi':
self.game.eval.best(
'hi',
hand1.tolist(True) + board.tolist(True), []),
'low':
self.game.eval.best(
'low',
hand1.tolist(True) + board.tolist(True), [])
},
2: {
'hi':
self.game.eval.best(
'hi',
hand2.tolist(True) + board.tolist(True), [])
}
},
'foldwin': False
}
history = [('end', [1], [game_state, frame])]
subject, message = self.GetMessagesFromHistory(history)
self.failUnlessEqual(subject, '')
self.failUnlessEqual(message, [
'1 shows Two pairs Aces and Fours, Ten kicker for hi ',
'2 mucks loosing hand', '1 2 tie for hi ',
'winners share a pot of 5 (minus 3 odd chips)', '1 receives 3',
'2 receives 2'
])
def testOperatorRepr(self):
"""Test PokerCards : Operator repr"""
cards = pokercards.PokerCards([12, 26])
self.failUnlessEqual(repr(cards), '%s(%s)' % ('PokerCards', [12, 26]))
def testNoCard(self):
"""Test PokerCards : No card value"""
cards = pokercards.PokerCards()
self.failUnlessEqual(cards.nocard(), pokercards.PokerCards.NOCARD)
def testHasCard(self):
"""Test PokerCards : Has card"""
cards = pokercards.PokerCards([12, 26])
self.failUnless(cards.hasCard(12))
self.failIf(cards.hasCard(27))
