def test_rainbow(self):
self.assertTrue(rainbow(()))
self.assertTrue(rainbow(parse_cards('Ac')))
self.assertTrue(rainbow(parse_cards('AhJsQc')))
self.assertTrue(rainbow(parse_cards('AhAsJdQc')))
self.assertFalse(rainbow(parse_cards('AhAsJsQhAh')))
self.assertFalse(rainbow(parse_cards('AhAsJsQh')))
def test_suited(self):
self.assertTrue(suited(()))
self.assertTrue(suited((parse_card('Ah'), )))
self.assertTrue(suited(parse_cards('AhKhQhJhTh')))
self.assertFalse(suited(parse_cards('AhKhQhJhTs')))
self.assertFalse(suited(parse_cards('AsKc')))
self.assertFalse(suited(parse_cards('AsKcQdJhTs')))
def test_lowballA5_hand(self):
self.assertRaises(ValueError, LowballA5Hand,
parse_cards('9sTsJsQsKsAs'))
self.assertRaises(ValueError, LowballA5Hand,
parse_cards('4c5dThJsAcKh2h'))
self.assertRaises(ValueError, LowballA5Hand, parse_cards('AcAdAhAsAc'))
hands = tuple(
map(
LowballA5Hand,
map(parse_cards, (
'Ac2c3c4c5c',
'6c4d3h2sAc',
'6c5d3h2sAc',
'6c5c4c2cAc',
'6c5d4h3sAc',
'6c5d4h3s2c',
'7c4d3h2sAc',
'7c5d3h2sAc',
'7c6d5h4s3c',
'8c5d4h3sAc',
'8c5d4h3s2c',
'9c7d6h4s3c',
'KcJd8h6s4c',
'AcAd9h5s3c',
'2c2d5h4s3c',
'3c3d6h4s2c',
'3c3d6h5sAc',
'2s2c3s3cAh',
'AcAdAsKhQs',
'KhKsKcAcAd',
'KhKsKcKdAc',
))))
self.assertSequenceEqual(hands, sorted(hands, reverse=True))
def test_lowball27_hand(self):
self.assertRaises(ValueError, Lowball27Hand,
parse_cards('9sTsJsQsKsAs'))
self.assertRaises(ValueError, Lowball27Hand,
parse_cards('4c5dThJsAcKh2h'))
self.assertRaises(ValueError, Lowball27Hand, parse_cards('AcAdAhAsAc'))
hands = tuple(
map(
Lowball27Hand,
map(parse_cards, (
'7c5d4h3s2c',
'7c6d4h3s2c',
'7c6d5h3s2c',
'7c6d5h4s2c',
'8c5d4h3s2c',
'8c6d4h3s2c',
'8c6d5h3s2c',
'8c6d5h4s2c',
'8c6d5h4s3c',
'8c7d4h3s2c',
'8c7d5h3s2c',
'8c7d5h4s2c',
'8c7d5h4s3c',
'8c7d6h3s2c',
'8c7d6h4s2c',
'8c7d6h4s3c',
'8c7d6h5s2c',
'8c7d6h5s3c',
'9c5d4h3s2c',
'KsKcAhQsJs',
'AhAc2c3c4c',
'AhAc2c3c5c',
'2c2d3s3c4s',
'AcAdKsKcTs',
'AcAdKsKcJs',
'QcQsQhAhKh',
'AcAsAd2s4s',
'AcAsAd3s4s',
'Ac2s3d4s5s',
'2c3s4d5s6s',
'TcJsQdKsAs',
'9c5c4c3c2c',
'Kc5c4c3c2c',
'KhKsKdAhAc',
'AcAdAsKhKs',
'2c2d2h2sQs',
'2c2d2h2sKs',
'AcAdAhAsKs',
'2c3c4c5c6c',
'3d4d5d6d7d',
'9sTsJsQsKs',
'TsJsQsKsAs',
))))
self.assertSequenceEqual(hands, sorted(hands, reverse=True))
def test_draw(self):
deck = StandardDeck()
self.assertEqual(len(deck), 52)
self.assertIn(parse_card('4h'), deck)
self.assertEqual(deck.draw(parse_cards('4h4c4s')), tuple(parse_cards(
'4h4c4s'
)))
self.assertEqual(len(deck), 49)
self.assertNotIn(parse_card('4h'), deck)
self.assertEqual(len(deck.draw(1)), 1)
self.assertEqual(len(deck), 48)
self.assertRaises(ValueError, deck.draw, 49)
def test_total_ordering(self):
quad = StandardHand(parse_cards('AcAdAhAsKs'))
straight_flush = StandardHand(parse_cards('TsJsQsKsAs'))
wheel = Lowball27Hand(parse_cards('2c3d4h5s7c'))
self.assertLess(quad, straight_flush)
self.assertLessEqual(quad, straight_flush)
self.assertGreater(straight_flush, quad)
self.assertGreaterEqual(straight_flush, quad)
self.assertEqual(quad, quad)
self.assertEqual(straight_flush, straight_flush)
self.assertNotEqual(quad, straight_flush)
self.assertNotEqual(straight_flush, wheel)
self.assertRaises(TypeError, le, quad, wheel)
def test_parse_cards(self):
self.assertCountEqual(
parse_cards('AcAdAhAs'),
map(partial(Card, Rank.ACE), Suit),
)
self.assertCountEqual(parse_cards('Kh???sJhA?????2c'), (
Card(Rank.KING, Suit.HEART),
Card(None, None),
Card(None, Suit.SPADE),
Card(Rank.JACK, Suit.HEART),
Card(Rank.ACE, None),
Card(None, None),
Card(None, None),
Card(Rank.TWO, Suit.CLUB),
))
def test_standard_deck(self):
self.assertCountEqual(StandardDeck(), parse_cards(
'2c3c4c5c6c7c8c9cTcJcQcKcAc'
'2d3d4d5d6d7d8d9dTdJdQdKdAd'
'2h3h4h5h6h7h8h9hThJhQhKhAh'
'2s3s4s5s6s7s8s9sTsJsQsKsAs'
))
def test_short_deck(self):
self.assertCountEqual(ShortDeck(), parse_cards(
'6c7c8c9cTcJcQcKcAc'
'6d7d8d9dTdJdQdKdAd'
'6h7h8h9hThJhQhKhAh'
'6s7s8s9sTsJsQsKsAs'
))
def test_greek_evaluator_evaluate_hand(self):
self.assertEqual(
GreekEvaluator.evaluate_hand(
parse_cards('Ac2d'),
parse_cards('QdJdTh2sKs'),
), StandardHand(parse_cards('2s2dAcKsQd')))
self.assertEqual(
GreekEvaluator.evaluate_hand(
parse_cards('AsKs'),
parse_cards('QdJdTh2s2d'),
), StandardHand(parse_cards('AsKsQdJdTh')))
self.assertEqual(
GreekEvaluator.evaluate_hand(
parse_cards('Ac9c'),
parse_cards('AhKhQhJhTh'),
), StandardHand(parse_cards('AcAhKhQh9c')))
def test_rank_evaluator_evaluate_hand(self):
self.assertEqual(
RankEvaluator.evaluate_hand(
parse_cards('AcKs'),
parse_cards('AhAsKcJsTs'),
), LowIndexedHand(Rank.ACE.index))
self.assertEqual(
RankEvaluator.evaluate_hand(
parse_cards('9c6c'),
parse_cards('9h9sKcJcTc'),
), LowIndexedHand(Rank.KING.index))
self.assertEqual(
RankEvaluator.evaluate_hand(
parse_cards('Tc2d'),
(),
), LowIndexedHand(Rank.TEN.index))
self.assertEqual(RankEvaluator.evaluate_hand(
parse_cards('3c'),
(),
), LowIndexedHand(Rank.THREE.index))
def test_omaha_evaluator_evaluate_hand(self):
self.assertEqual(
OmahaEvaluator.evaluate_hand(
parse_cards('6c7c8c9c'),
parse_cards('8s9sTc'),
), StandardHand(parse_cards('6c7c8s9sTc')))
self.assertEqual(
OmahaEvaluator.evaluate_hand(
parse_cards('6c7c8s9s'),
parse_cards('8c9cTc'),
), StandardHand(parse_cards('6c7c8c9cTc')))
self.assertEqual(
OmahaEvaluator.evaluate_hand(
parse_cards('6c7c8c9c'),
parse_cards('8s9sTc9hKs'),
), StandardHand(parse_cards('8c8s9c9s9h')))
self.assertEqual(
OmahaEvaluator.evaluate_hand(
parse_cards('6c7c8sAh'),
parse_cards('As9cTc2sKs'),
), StandardHand(parse_cards('AhAsKsTc8s')))
self.assertEqual(
OmahaEvaluator.evaluate_hand(
parse_cards('Ac9cKs9s'),
parse_cards('AhKhQhJhTh'),
), StandardHand(parse_cards('AcKsQhJhTh')))
def test_standard_evaluator_evaluate_hand(self):
self.assertRaises(ValueError, StandardEvaluator.evaluate_hand, (), ())
self.assertEqual(
StandardEvaluator.evaluate_hand(
parse_cards('AcAd'),
parse_cards('AhAsKcQdQh'),
), StandardHand(parse_cards('AcAdAhAsKc')))
self.assertEqual(
StandardEvaluator.evaluate_hand(
parse_cards('AcKs'),
parse_cards('AhAsQsJsTs'),
), StandardHand(parse_cards('AsKsQsJsTs')))
self.assertEqual(
StandardEvaluator.evaluate_hand(
parse_cards('AcAd'),
parse_cards('AhAsKcQd'),
), StandardHand(parse_cards('AcAdAhAsKc')))
self.assertEqual(
StandardEvaluator.evaluate_hand(
parse_cards('AcKs'),
parse_cards('AhAsQsJs'),
), StandardHand(parse_cards('AcAhAsKsQs')))
self.assertEqual(
StandardEvaluator.evaluate_hand(
parse_cards('AcKs'),
parse_cards('AhAsQs'),
), StandardHand(parse_cards('AcAhAsKsQs')))
self.assertEqual(
StandardEvaluator.evaluate_hand(
parse_cards('Ac2d'),
parse_cards('QdJdTh2sKs'),
), StandardHand(parse_cards('AcKsQdJdTh')))
self.assertEqual(
StandardEvaluator.evaluate_hand(
parse_cards('AsKs'),
parse_cards('QsJdTs2c2s'),
), StandardHand(parse_cards('AsKsQsTs2s')))
self.assertEqual(
StandardEvaluator.evaluate_hand(
parse_cards('Ac9c'),
parse_cards('AhKhQhJhTh'),
), StandardHand(parse_cards('AhKhQhJhTh')))
def test_badugi_evaluator_evaluate_hand(self):
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('2s4c5d6h'),
(),
), BadugiHand(parse_cards('2s4c5d6h')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('As2d3d7h'),
(),
), BadugiHand(parse_cards('As2d7h')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('4s4c4dKh'),
(),
), BadugiHand(parse_cards('4sKh')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('2s3s4d7h'),
(),
), BadugiHand(parse_cards('2s4d7h')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('As2d3s4h'),
(),
), BadugiHand(parse_cards('As2d4h')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('KcKdKhKs'),
(),
), BadugiHand(parse_cards('Ks')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('2s2c4d4h'),
(),
), BadugiHand(parse_cards('2s4d')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('4s5s6dKh'),
(),
), BadugiHand(parse_cards('4s6dKh')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('As2c3d3s'),
(),
), BadugiHand(parse_cards('As2c3d')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('Ad2hKc3c'),
(),
), BadugiHand(parse_cards('Ad2h3c')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('5d7cKcKh'),
(),
), BadugiHand(parse_cards('5d7cKh')))
self.assertEqual(
BadugiEvaluator.evaluate_hand(
parse_cards('2s3dKsKd'),
(),
), BadugiHand(parse_cards('2s3d')))
def test_short_deck_evaluator_evaluate_hand(self):
self.assertRaises(
ValueError,
ShortDeckEvaluator.evaluate_hand,
parse_cards('AcKs'),
parse_cards('4hAsKcJsTs'),
)
self.assertEqual(
ShortDeckEvaluator.evaluate_hand(
parse_cards('AcKs'),
parse_cards('AhAsKcJsTs'),
), ShortDeckHand(parse_cards('AcAhAsKcKs')))
self.assertEqual(
ShortDeckEvaluator.evaluate_hand(
parse_cards('Ac6s'),
parse_cards('AhAsKcJcTc'),
), ShortDeckHand(parse_cards('AcAhAsKcJc')))
self.assertEqual(
ShortDeckEvaluator.evaluate_hand(
parse_cards('Ac6c'),
parse_cards('AhAsKcJcTc'),
), ShortDeckHand(parse_cards('AcKcJcTc6c')))
self.assertEqual(
ShortDeckEvaluator.evaluate_hand(
parse_cards('AcAd'),
parse_cards('6s7cKcKd'),
), ShortDeckHand(parse_cards('AcAdKcKd7c')))
self.assertEqual(
ShortDeckEvaluator.evaluate_hand(
parse_cards('Ac9d'),
parse_cards('6s7s8c'),
), ShortDeckHand(parse_cards('Ac9d8c7s6s')))
self.assertEqual(
ShortDeckEvaluator.evaluate_hand(
parse_cards('Ac9c'),
parse_cards('AhKhQhJhTh'),
), ShortDeckHand(parse_cards('AhKhQhJhTh')))
def test_lowballA5_evaluator_evaluate_hand(self):
self.assertEqual(
LowballA5Evaluator.evaluate_hand(
parse_cards('AcAd'),
parse_cards('AhAsKcQdQh'),
), LowballA5Hand(parse_cards('AcAsQdQhKc')))
self.assertEqual(
LowballA5Evaluator.evaluate_hand(
parse_cards('AcKs'),
parse_cards('AhAsQsJsTs'),
), LowballA5Hand(parse_cards('KsAsQsJsTs')))
self.assertEqual(
LowballA5Evaluator.evaluate_hand(
parse_cards('AcAd'),
parse_cards('AhAsKcQd'),
), LowballA5Hand(parse_cards('AdAhAsKcQd')))
self.assertEqual(
LowballA5Evaluator.evaluate_hand(
parse_cards('AcKs'),
parse_cards('AhAsQsJs'),
), LowballA5Hand(parse_cards('AhAsKsQsJs')))
self.assertEqual(
LowballA5Evaluator.evaluate_hand(
parse_cards('AcKs'),
parse_cards('AhAsQs'),
), LowballA5Hand(parse_cards('AcAhAsKsQs')))
self.assertEqual(
LowballA5Evaluator.evaluate_hand(
parse_cards('Ac2d'),
parse_cards('QdJdTh2sKs'),
), LowballA5Hand(parse_cards('AcQdJdTh2d')))
self.assertEqual(
LowballA5Evaluator.evaluate_hand(
parse_cards('AsKs'),
parse_cards('QsJsTs2c2s'),
), LowballA5Hand(parse_cards('AsQsJsTs2s')))
self.assertEqual(
LowballA5Evaluator.evaluate_hand(
parse_cards('Ac9c'),
parse_cards('AhKhQhJhTh'),
), LowballA5Hand(parse_cards('AhQhJhTh9c')))
def test_draw_muck(self):
game = PotLimitTripleDrawLowball27(
Stakes(0, (1, 2)),
(100, ) * 4,
).act(
'dh AcKcQcJcTc',
'dh AdKdQdJdTd',
'dh AhKhQhJhTh',
'dh AsKsQsJsTs',
'cc',
'cc',
'cc',
'cc',
'dd AcKcQcJcTc 9c8c7c6c5c',
'dd AdKdQdJdTd 9d8d7d6d5d',
'dd AhKhQhJhTh 9h8h7h6h5h',
'dd AsKsQsJsTs 9s8s7s6s5s',
'cc',
'cc',
'cc',
'cc',
'dd 9c8c7c6c5c 4c4d4h4s2c',
)
self.assertTrue(game.actor.can_discard_draw())
self.assertTrue(game.actor.can_discard_draw(()))
self.assertTrue(game.actor.can_discard_draw((), ()))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9d'),
parse_cards('3c'),
))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9d8d7d'),
parse_cards('3c3d3h'),
))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9d8d7d6d5d'),
parse_cards('3c3d3h3s2d'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9d'),
parse_cards('9c'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9d8d7d'),
parse_cards('9c8c7c'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9d8d7d6d5d'),
parse_cards('9c8c7c6c5c'),
))
game.actor.discard_draw(
parse_cards('9d8d7d6d5d'),
parse_cards('3c3d3h3s2d'),
)
self.assertTrue(game.actor.can_discard_draw())
self.assertTrue(game.actor.can_discard_draw(()))
self.assertTrue(game.actor.can_discard_draw((), ()))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9h'),
parse_cards('2s'),
))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9h8h'),
parse_cards('2s2h'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9h'),
parse_cards('Ac'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9h8h'),
parse_cards('AcKc'),
))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9h8h7h'),
parse_cards('AcKcQc'),
))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9h8h7h6h5h'),
parse_cards('AcKcQcJcTc'),
))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9h8h7h'),
parse_cards('2s2hQc'),
))
self.assertTrue(
game.actor.can_discard_draw(
parse_cards('9h8h7h6h5h'),
parse_cards('2s2hQcJcTc'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9h'),
parse_cards('Ah'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9h8h'),
parse_cards('AhKh'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9h8h7h'),
parse_cards('AhKhQh'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9h8h7h6h5h'),
parse_cards('AhKhQhJhTh'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9h8h7h'),
parse_cards('2s2hQh'),
))
self.assertFalse(
game.actor.can_discard_draw(
parse_cards('9h8h7h6h5h'),
parse_cards('2s2hQhJhTh'),
))
game.actor.discard_draw(
parse_cards('9h8h7h6h5h'),
parse_cards('AcKcQcJcTc'),
)
def test_short_deck_hand(self):
self.assertRaises(ValueError, ShortDeckHand,
parse_cards('9sTsJsQsKsAs'))
self.assertRaises(ValueError, ShortDeckHand,
parse_cards('6c7dThJsAcKh8h'))
self.assertRaises(ValueError, ShortDeckHand, parse_cards('AcAdAhAsAc'))
self.assertRaises(ValueError, ShortDeckHand, parse_cards('Ac2c3c4c5c'))
hands = tuple(
map(
ShortDeckHand,
map(parse_cards, (
'6c7d8h9sJc',
'6c7d8h9sQc',
'6c7d8h9sKc',
'6c7d8hTsAc',
'6c7d9hTsAc',
'6c8d9hTsAc',
'9cJdQhKsAc',
'6c6dThJsQc',
'7c7dThJsQc',
'7c7dThJsKc',
'7c7dJhQsKc',
'7c7d6hKsAc',
'AcAd6hJsQc',
'AcAdKhQsJc',
'6c6dThTsQc',
'7c7dThTsQc',
'7c7dThTsKc',
'7c7dQhQsKc',
'6c6dKhKsAc',
'AcAd6h6sQc',
'AcAdKhKsQc',
'6c6d6hTsJc',
'7c7d7hTsQc',
'7c7d7hTsKc',
'7c7d7hQsKc',
'KcKdKh6sAc',
'AcAdAh6sQc',
'AcAdAhKsQc',
'Ac6d7h8s9c',
'6c7d8h9sTc',
'7c8d9hTsJc',
'8c9dThJsQc',
'9cTdJhQsKc',
'TcJdQhKsAc',
'6c6d6hTsTc',
'7c7d7hTsTc',
'7c7d7hKsKc',
'7c7d7hAsAc',
'KcKdKhAsAc',
'AcAdAhQsQc',
'AcAdAhKsKc',
'6c7c8c9cJc',
'6d7d9dJdKd',
'6h7hThJhKh',
'6s7sTsJsAs',
'6c8cTcJcAc',
'9dTdJdQdAd',
'9sTsJsKsAs',
'6c6d6h6s7c',
'6c6d6h6sTc',
'7c7d7h7sKc',
'7c7d7h7sAc',
'KcKdKhKsAc',
'AcAdAhAsQc',
'AcAdAhAsKc',
'Ac6c7c8c9c',
'6d7d8d9dTd',
'7h8h9hThJh',
'8s9sTsJsQs',
'9cTcJcQcKc',
'TdJdQdKdAd',
))))
self.assertSequenceEqual(hands, sorted(hands))
def test_badugi_hand(self):
self.assertRaises(ValueError, BadugiHand, parse_cards('Ac2d3c4s5c'))
self.assertRaises(ValueError, BadugiHand, parse_cards('AcAc'))
self.assertRaises(ValueError, BadugiHand, parse_cards('Ac2d3c'))
self.assertRaises(ValueError, BadugiHand, parse_cards('As2s'))
self.assertRaises(ValueError, BadugiHand, parse_cards('Ad2d3d4d'))
self.assertRaises(ValueError, BadugiHand, parse_cards('Ad2d3c4h'))
self.assertRaises(ValueError, BadugiHand, parse_cards('AcAd'))
self.assertRaises(ValueError, BadugiHand, parse_cards('AcAd3h4s'))
hands = tuple(
map(
BadugiHand,
map(parse_cards, (
'Ac2d3h4s',
'Ac2d3h5s',
'Ac2d4h5s',
'Ac3d4h5s',
'Ac3d6h9s',
'Ac3d6hTs',
'7c8d9hTs',
'7c8d9hJs',
'TcJdQhKs',
'Ac2d3h',
'As2c4d',
'Ah3s4c',
'2d3h4s',
'4c5d6h',
'4s5c8d',
'4h5sTc',
'4d8hTs',
'4c8dKh',
'JsQcKd',
'Ac2d',
'Ah3s',
'2c3d',
'2h4s',
'2c5d',
'2h8s',
'7c8d',
'2hJs',
'3cJd',
'ThJs',
'TcKd',
'JhKs',
'QhKs',
'Ac',
'2d',
'3h',
'4s',
'5c',
'6d',
'7h',
'8s',
'9c',
'Td',
'Jh',
'Qs',
'Kc',
))))
self.assertSequenceEqual(hands, sorted(hands, reverse=True))
def test_standard_hand(self):
self.assertRaises(ValueError, StandardHand,
parse_cards('9sTsJsQsKsAs'))
self.assertRaises(ValueError, StandardHand,
parse_cards('4c5dThJsAcKh2h'))
self.assertRaises(ValueError, StandardHand, parse_cards('AcAdAhAsAc'))
hands = tuple(
map(
StandardHand,
map(parse_cards, (
'6c7d8h9sJc',
'4c5d9hJsKc',
'4c5dThJsKc',
'4c5dThJsAc',
'4c6dThJsAc',
'9cTdJhQsAc',
'9cTdJhKsAc',
'2c2dThJsQc',
'3c3dThJsQc',
'3c3dThJsKc',
'3c3dJhQsKc',
'3c3d2hKsAc',
'AcAd2hJsQc',
'AcAdKhQsJc',
'2c2dThTsQc',
'3c3dThTsQc',
'3c3dThTsKc',
'3c3dQhQsKc',
'2c2dKhKsAc',
'AcAd2h2sQc',
'AcAdKhKsQc',
'2c2d2hTsJc',
'3c3d3hTsQc',
'3c3d3hTsKc',
'3c3d3hQsKc',
'KcKdKh2sAc',
'AcAdAh2sQc',
'AcAdAhKsQc',
'Ac2d3h4s5c',
'2c3d4h5s6c',
'3c4d5h6s7c',
'4c5d6h7s8c',
'5c6d7h8s9c',
'9cTdJhQsKc',
'TcJdQhKsAc',
'6c7c8c9cJc',
'4d5d9dJdKd',
'4h5hThJhKh',
'4s5sTsJsAs',
'4c6cTcJcAc',
'9dTdJdQdAd',
'9sTsJsKsAs',
'2c2d2hTsTc',
'3c3d3hTsTc',
'3c3d3hKsKc',
'3c3d3hAsAc',
'KcKdKhAsAc',
'AcAdAhQsQc',
'AcAdAhKsKc',
'2c2d2h2s3c',
'2c2d2h2sTc',
'3c3d3h3sKc',
'3c3d3h3sAc',
'KcKdKhKsAc',
'AcAdAhAsQc',
'AcAdAhAsKc',
'Ac2c3c4c5c',
'2d3d4d5d6d',
'3h4h5h6h7h',
'4s5s6s7s8s',
'5c6c7c8c9c',
'9dTdJdQdKd',
'TsJsQsKsAs',
))))
self.assertSequenceEqual(hands, sorted(hands))
def test_parse(self):
self.assertSetEqual(
Range('QJs'),
set(
map(frozenset, (
parse_cards('QcJc'),
parse_cards('QdJd'),
parse_cards('QhJh'),
parse_cards('QsJs'),
))))
self.assertSetEqual(Range('2s3s'),
set(map(frozenset, (parse_cards('2s3s'), ))))
self.assertSetEqual(
Range('4s5h', '2s3s'),
set(map(frozenset, (
parse_cards('4s5h'),
parse_cards('2s3s'),
))))
self.assertSetEqual(
Range(parse_cards('7s8s'), '27', 'AK', 'ATs+'),
set(
map(frozenset, (
parse_cards('7s8s'),
parse_cards('2c7d'),
parse_cards('2c7h'),
parse_cards('2c7s'),
parse_cards('2d7c'),
parse_cards('2d7h'),
parse_cards('2d7s'),
parse_cards('2h7c'),
parse_cards('2h7d'),
parse_cards('2h7s'),
parse_cards('2s7c'),
parse_cards('2s7d'),
parse_cards('2s7h'),
parse_cards('2c7c'),
parse_cards('2d7d'),
parse_cards('2h7h'),
parse_cards('2s7s'),
parse_cards('AcKd'),
parse_cards('AcKh'),
parse_cards('AcKs'),
parse_cards('AdKc'),
parse_cards('AdKh'),
parse_cards('AdKs'),
parse_cards('AhKc'),
parse_cards('AhKd'),
parse_cards('AhKs'),
parse_cards('AsKc'),
parse_cards('AsKd'),
parse_cards('AsKh'),
parse_cards('AcKc'),
parse_cards('AdKd'),
parse_cards('AhKh'),
parse_cards('AsKs'),
parse_cards('AcQc'),
parse_cards('AdQd'),
parse_cards('AhQh'),
parse_cards('AsQs'),
parse_cards('AcJc'),
parse_cards('AdJd'),
parse_cards('AhJh'),
parse_cards('AsJs'),
parse_cards('AcTc'),
parse_cards('AdTd'),
parse_cards('AhTh'),
parse_cards('AsTs'),
))),
)
self.assertSetEqual(
Range('99+', (parse_card('2h'), parse_card('7s'))),
set(
map(frozenset, (
parse_cards('9c9d'),
parse_cards('9c9h'),
parse_cards('9c9s'),
parse_cards('9d9h'),
parse_cards('9d9s'),
parse_cards('9h9s'),
parse_cards('TcTd'),
parse_cards('TcTh'),
parse_cards('TcTs'),
parse_cards('TdTh'),
parse_cards('TdTs'),
parse_cards('ThTs'),
parse_cards('JcJd'),
parse_cards('JcJh'),
parse_cards('JcJs'),
parse_cards('JdJh'),
parse_cards('JdJs'),
parse_cards('JhJs'),
parse_cards('QcQd'),
parse_cards('QcQh'),
parse_cards('QcQs'),
parse_cards('QdQh'),
parse_cards('QdQs'),
parse_cards('QhQs'),
parse_cards('KcKd'),
parse_cards('KcKh'),
parse_cards('KcKs'),
parse_cards('KdKh'),
parse_cards('KdKs'),
parse_cards('KhKs'),
parse_cards('AcAd'),
parse_cards('AcAh'),
parse_cards('AcAs'),
parse_cards('AdAh'),
parse_cards('AdAs'),
parse_cards('AhAs'),
parse_cards('2h7s'),
))),
)
self.assertSetEqual(
Range('QTs'),
set(
map(frozenset, (
parse_cards('QcTc'),
parse_cards('QdTd'),
parse_cards('QhTh'),
parse_cards('QsTs'),
))))
self.assertSetEqual(
Range('AKo'),
set(
map(frozenset, (
parse_cards('AcKd'),
parse_cards('AcKh'),
parse_cards('AcKs'),
parse_cards('AdKc'),
parse_cards('AdKh'),
parse_cards('AdKs'),
parse_cards('AhKc'),
parse_cards('AhKd'),
parse_cards('AhKs'),
parse_cards('AsKc'),
parse_cards('AsKd'),
parse_cards('AsKh'),
))))
self.assertSetEqual(
Range('AK'),
set(
map(frozenset, (
parse_cards('AcKd'),
parse_cards('AcKh'),
parse_cards('AcKs'),
parse_cards('AdKc'),
parse_cards('AdKh'),
parse_cards('AdKs'),
parse_cards('AhKc'),
parse_cards('AhKd'),
parse_cards('AhKs'),
parse_cards('AsKc'),
parse_cards('AsKd'),
parse_cards('AsKh'),
parse_cards('AcKc'),
parse_cards('AdKd'),
parse_cards('AhKh'),
parse_cards('AsKs'),
))))
self.assertSetEqual(
Range('JJ'),
set(
map(frozenset, (
parse_cards('JcJd'),
parse_cards('JcJh'),
parse_cards('JcJs'),
parse_cards('JdJh'),
parse_cards('JdJs'),
parse_cards('JhJs'),
))))
self.assertSetEqual(Range('AsKh'), {frozenset(parse_cards('AsKh'))})
self.assertSetEqual(
Range('JJ+'),
set(
map(frozenset, (
parse_cards('JcJd'),
parse_cards('JcJh'),
parse_cards('JcJs'),
parse_cards('JdJh'),
parse_cards('JdJs'),
parse_cards('JhJs'),
parse_cards('QcQd'),
parse_cards('QcQh'),
parse_cards('QcQs'),
parse_cards('QdQh'),
parse_cards('QdQs'),
parse_cards('QhQs'),
parse_cards('KcKd'),
parse_cards('KcKh'),
parse_cards('KcKs'),
parse_cards('KdKh'),
parse_cards('KdKs'),
parse_cards('KhKs'),
parse_cards('AcAd'),
parse_cards('AcAh'),
parse_cards('AcAs'),
parse_cards('AdAh'),
parse_cards('AdAs'),
parse_cards('AhAs'),
))))
self.assertSetEqual(
Range('JTo+'),
set(
map(frozenset, (
parse_cards('JcTd'),
parse_cards('JcTh'),
parse_cards('JcTs'),
parse_cards('JdTc'),
parse_cards('JdTh'),
parse_cards('JdTs'),
parse_cards('JhTc'),
parse_cards('JhTd'),
parse_cards('JhTs'),
parse_cards('JsTc'),
parse_cards('JsTd'),
parse_cards('JsTh'),
))))
self.assertSetEqual(
Range('QT+'),
set(
map(frozenset, (
parse_cards('QcTd'),
parse_cards('QcTh'),
parse_cards('QcTs'),
parse_cards('QdTc'),
parse_cards('QdTh'),
parse_cards('QdTs'),
parse_cards('QhTc'),
parse_cards('QhTd'),
parse_cards('QhTs'),
parse_cards('QsTc'),
parse_cards('QsTd'),
parse_cards('QsTh'),
parse_cards('QcTc'),
parse_cards('QdTd'),
parse_cards('QhTh'),
parse_cards('QsTs'),
parse_cards('QcJd'),
parse_cards('QcJh'),
parse_cards('QcJs'),
parse_cards('QdJc'),
parse_cards('QdJh'),
parse_cards('QdJs'),
parse_cards('QhJc'),
parse_cards('QhJd'),
parse_cards('QhJs'),
parse_cards('QsJc'),
parse_cards('QsJd'),
parse_cards('QsJh'),
parse_cards('QcJc'),
parse_cards('QdJd'),
parse_cards('QhJh'),
parse_cards('QsJs'),
))))
self.assertSetEqual(Range('9T+'), set())
self.assertSetEqual(
Range('AsKsQsJsT?'),
set(
map(frozenset, (
parse_cards('AsKsQsJsTc'),
parse_cards('AsKsQsJsTd'),
parse_cards('AsKsQsJsTh'),
parse_cards('AsKsQsJsTs'),
))))
self.assertSetEqual(Range('9?T?'), Range('9T'))
self.assertSetEqual(Range('A???'), Range('A2+') | Range('AA'))