def test_find_melds_one_run_of_four(self):
hand = Card.from_str_list('2c,3c,4c,5c,6d,7h,8s,9c,10d,jc')
all_melds = set(tuple(x) for x in score.find_all_melds(hand))
self.assertEqual(3, len(all_melds))
self.assertTrue(tuple(Card.from_str_list('2c,3c,4c')) in all_melds)
self.assertTrue(tuple(Card.from_str_list('3c,4c,5c')) in all_melds)
self.assertTrue(tuple(Card.from_str_list('2c,3c,4c,5c')) in all_melds)
def test_best_hand_single_match_your_box(self):
best = player.best_hand_count_box(
Card.from_str_list('2d, 3d, 4d, 5d, 8c, 9s'), 4, False)
self.assertEqual(1, len(best))
self.assertEqual(8, best[0][0])
self.assertTrue(
set(Card.from_str_list('2d, 3d, 4d, 5d')) in
[set(x[1]) for x in best])
def test_best_hand_ignore_box_single_match(self):
best = player.best_hand_ignore_box(
Card.from_str_list('2d, 3d, 4d, 5d, 9c, 9s'), 4)
self.assertEqual(1, len(best))
self.assertEqual(8, best[0][0])
self.assertTrue(
set(Card.from_str_list('2d, 3d, 4d, 5d')) in
[set(x[1]) for x in best])
def test_best_hand_multiple_matches_your_box(self):
best = player.best_hand_count_box(
Card.from_str_list('4d, 4s, 6d, 6s, 10h, 10s'), 4, False)
self.assertEqual(15, len(best))
self.assertEqual(2, best[0][0])
self.assertTrue(
set(Card.from_str_list('4D, 4S, 6D, 6S')) in
[set(x[1]) for x in best])
def test_nob(self):
self.assertEqual(
1,
score.score_hand(Card.from_str_list('Jc, 2c, Qc, 6h'),
Card.from_str('4c')))
self.assertEqual(
0,
score.score_hand(Card.from_str_list('Jc, 2c, Qc, 6h'),
Card.from_str('4s')))
def test_card_constructor_throws_appropriate_exceptions(self):
with self.assertRaises(ValueError):
Card('15', 'S')
with self.assertRaises(ValueError):
Card('xx', 'S')
with self.assertRaises(ValueError):
Card('10', 'NotExist')
with self.assertRaises(ValueError):
Card('0', 'S')
def test_cards_from_str_list(self):
cards = Card.from_str_list('AD,1D,10S')
self.assertEqual(cards[0], self.ace_of_diamonds)
self.assertEqual(cards[1], self.ace_of_diamonds)
self.assertEqual(cards[2], self.ten_of_spades)
Card.from_str_list('AD, 1D, 10S')
with self.assertRaises(ValueError):
Card.from_str_list('AD,1x,10S')
def test_split_ranks(self):
cards = Card.from_str_list('2d,3c,5h,5s')
ranks = split_ranks(cards)
self.assertEqual(3, len(ranks))
self.assertDictEqual(
ranks, {
2: [Card.from_str('2d')],
3: [Card.from_str('3c')],
5: Card.from_str_list('5h,5s')
})
def test_best_hand_ignore_box_multiple_matches(self):
best = player.best_hand_ignore_box(
Card.from_str_list('ac,2c,9c,7c,3s,kd'), 4)
self.assertEqual(2, len(best))
self.assertEqual(5, best[0][0])
self.assertTrue(
set(Card.from_str_list('AC,2C,9C,3S')) in
[set(x[1]) for x in best])
self.assertTrue(
set(Card.from_str_list('AC, 2C, 3S, KD')) in
[set(x[1]) for x in best])
def test_split_suits(self):
cards = Card.from_str_list('2d,3c,5h,qh')
suits = split_suits(cards)
self.assertEqual(4, len(suits))
self.assertDictEqual(
suits, {
'D': [Card.from_str('2d')],
'C': [Card.from_str('3c')],
'H': Card.from_str_list('5h,qh'),
'S': []
})
def test_pegging(self):
dealer = Card.from_str_list('AD, 3D, 5D, 7S')
non_dealer = Card.from_str_list('QH, 10H, 7H, 5C')
self._game.pegging(self._p1, self._p2, dealer, non_dealer,
Card.from_str('KC'), self._board)
# QH, AD, 10H, 3D, 7H = 31 scored by non_dealer 2+1 points
# 5D 5C 7S = pair for non dealer 2, last card for dealer, 1 point
self.assertEqual((1, 0, 0), self._collector.averages(self._p1))
self.assertEqual((4, 0, 0), self._collector.averages(self._p2))
def test_score_hand_run_and_four_of_a_kind_not_overlapping(self):
hand = Card.from_str_list('2c,3c,4c,6c,6d,6h,6s,8c,9s,10d,jh')
results = score.score_hand(hand)
best_melds = results[0][0]
deadwood = results[0][1]
deadwood_count = results[0][2]
self.assertEqual(2, len(best_melds))
self.assertTrue(set(Card.from_str_list('2c,3c,4c')) in best_melds)
self.assertTrue(set(Card.from_str_list('6c,6d,6h,6s')) in best_melds)
self.assertEqual(set(Card.from_str_list('8c,9s,10d,jh')),
set(deadwood))
self.assertEqual(37, deadwood_count)
def test_flush_box(self):
self.assertEqual(
5,
score.score_hand(Card.from_str_list('ac,2c,9c,7c'),
Card.from_str('Jc'),
is_box=True))
self.assertEqual(
0,
score.score_hand(Card.from_str_list('ac,2c,9c,7s'),
Card.from_str('Jc'),
is_box=True))
self.assertEqual(
0,
score.score_hand(Card.from_str_list('ac,2c,9c,7c'),
None,
is_box=True))
def test_score_hand_run_and_four_of_a_kind_overlapping(self):
hand = Card.from_str_list('2c,3c,4c,4d,4h,4s,8c,9s,10d,jh')
results = score.score_hand(hand)
self.assertEqual(37, results[0][2]) # deadwood for 3x4's and a run
self.assertEqual(42, results[1][2]) # deadwood for the 4 4's meld
self.assertEqual(
49, results[-1][2]) # worst hand is the run of 3 on it's own
def test_score_pegging_stack_no_score(self):
stack = []
sc, desc = score.score_pegging_stack(stack)
self.assertEqual(0, sc)
stack = Card.from_str_list('AC')
sc, desc = score.score_pegging_stack(stack)
self.assertEqual(0, sc)
stack = Card.from_str_list('AC, 2S, 5D')
sc, desc = score.score_pegging_stack(stack)
self.assertEqual(0, sc)
stack = Card.from_str_list('AC, 2S, AD')
sc, desc = score.score_pegging_stack(stack)
self.assertEqual(0, sc)
def test_no_sequences(self):
hand = Card.from_str_list('1c,2d,3h,4s,5c,6d,7h,8s,9c,10d')
all_card_values = sum(x.value for x in hand)
results = score.score_hand(hand)
self.assertEqual([], results[0])
self.assertEqual(hand, results[1])
self.assertEqual(all_card_values, results[2])
def test_same_suit_all_runs(self):
cards = Card.from_str_list('AS,2C,3C')
self.assertFalse(same_suit_all_runs(cards, 3))
cards = Card.from_str_list('AS,2S,3S')
runs = same_suit_all_runs(cards, 3)
self.assertEqual(1, len(runs))
self.assertEqual([Card.from_str_list('AS,2S,3S')], runs)
cards = Card.from_str_list('AS,2S,3S,6c,7c,8c')
runs = set(tuple(r) for r in same_suit_all_runs(cards, 3))
self.assertEqual(2, len(runs))
self.assertTrue(tuple(Card.from_str_list('AS,2S,3S')) in runs)
self.assertTrue(tuple(Card.from_str_list('6c,7c,8c')) in runs)
cards = Card.from_str_list('AS,2S,3S,4s')
runs = set(tuple(r) for r in same_suit_all_runs(cards, 3))
self.assertEqual(3, len(runs))
self.assertTrue(tuple(Card.from_str_list('AS,2S,3S,4s')) in runs)
self.assertTrue(tuple(Card.from_str_list('AS,2S,3S')) in runs)
self.assertTrue(tuple(Card.from_str_list('2S,3S,4s')) in runs)
def test_complex_hands(self):
sc, bd = score.score_hand_with_breakdown(
Card.from_str_list('2d, 3d, 4d, 5d'), Card.from_str('5s'))
self.assertEqual(1, len(bd['pairs']))
self.assertEqual(2, len(bd['runs']))
self.assertEqual(1, len(bd['flushes']))
self.assertEqual(1, len(bd['fifteens']))
self.assertEqual(16, sc)
str_rep = '''Runs : [2D, 3D, 4D, 5D], [2D, 3D, 4D, 5S]
Flushes : [2D, 3D, 4D, 5D]
Fifteens : [2D, 3D, 5D, 5S]
Pairs : [5D, 5S]'''
self.assertEqual(str_rep, score.breakdown_tostring(bd))
sc, bd = score.score_hand_with_breakdown(
Card.from_str_list('jc, qc, kc, jd'), Card.from_str('js'))
self.assertEqual(3, len(bd['pairs']))
self.assertEqual(3, len(bd['runs']))
self.assertEqual(15, sc)
self.assertEqual(
29,
score.score_hand(Card.from_str_list('jc,5d,5h,5s'),
Card.from_str('5c')))
def test_all_subsets_with_list_of_cards(self):
data = [Card.from_str_list('2c, 2d, 2s'), Card.from_str_list('3c, 3d, 3s')]
subsets = list(all_subsets(data))
self.assertEqual(4, len(subsets))
self.assertTrue(() in subsets)
self.assertTrue((Card.from_str_list('2c, 2d, 2s'),) in subsets)
self.assertTrue((Card.from_str_list('3c, 3d, 3s'),) in subsets)
self.assertTrue((Card.from_str_list('2c, 2d, 2s'), Card.from_str_list('3c, 3d, 3s')) in subsets)
def test_find_melds_run_and_four_of_a_kind(self):
hand = Card.from_str_list('2c,3c,4c,5c,6d,7h,8c,8s,8d,8h')
all_melds = set(tuple(x) for x in score.find_all_melds(hand))
self.assertEqual(8, len(all_melds))
self.assertTrue(tuple(Card.from_str_list('2c,3c,4c')) in all_melds)
self.assertTrue(tuple(Card.from_str_list('3c,4c,5c')) in all_melds)
self.assertTrue(tuple(Card.from_str_list('2c,3c,4c,5c')) in all_melds)
self.assertTrue(tuple(Card.from_str_list('8c,8s,8d')) in all_melds)
self.assertTrue(tuple(Card.from_str_list('8c,8s,8d,8h')) in all_melds)
def test_remove_intersecting_sets_of_cards(self):
sets = [set(Card.from_str_list('2c, 3c')), set(Card.from_str_list('4c, 5c'))]
removed = remove_intersecting_sets(sets)
self.assertEqual(2, len(removed))
sets = [set(Card.from_str_list('2c, 3c')), set(Card.from_str_list('3c, 10c'))]
removed = remove_intersecting_sets(sets)
self.assertEqual(1, len(removed))
sets = [set(Card.from_str_list('2c, 3c')), set(Card.from_str_list('3c, 10c')),
set(Card.from_str_list('10s, 11s'))]
removed = remove_intersecting_sets(sets)
self.assertEqual(2, len(removed))
def test_pairs(self):
self.assertEqual(
4,
score.score_hand(Card.from_str_list('JS, JD, 6C, 2H'),
Card.from_str('2C')))
self.assertEqual(
2,
score.score_hand(Card.from_str_list('QS, JD, 6C, 2H'),
Card.from_str('2C')))
self.assertEqual(
2,
score.score_hand(Card.from_str_list('JS, QD, 3C, 3H'),
Card.from_str('4C')))
self.assertEqual(
4,
score.score_hand(Card.from_str_list('JS, JD, 3C, 3H'),
Card.from_str('AC')))
def test_find_melds_three_of_kind(self):
hand = Card.from_str_list('2c,2d,3s,5c,6d,7h,8s,9c,10d,jc')
self.assertFalse(score.find_all_melds(hand))
hand = Card.from_str_list('2c,2d,2s,5c,6d,7h,8s,9c,10d,jc')
self.assertEqual([Card.from_str_list('2c,2d,2s')],
score.find_all_melds(hand))
hand = Card.from_str_list('2c,2d,2s,5c,5d,5h,8s,9c,10d,jc')
self.assertEqual(
[Card.from_str_list('2c,2d,2s'),
Card.from_str_list('5c,5d,5h')], score.find_all_melds(hand))
def test_flush(self):
self.assertEqual(
5,
score.score_hand(Card.from_str_list('ac, 2c, 9c, 7c'),
Card.from_str('Jc')))
self.assertEqual(
4,
score.score_hand(Card.from_str_list('ac, 2c, 9c, 7c'),
Card.from_str('Jh')))
self.assertEqual(
0,
score.score_hand(Card.from_str_list('ad, 2c, 9c, 7c'),
Card.from_str('Jc')))
def test_fifteens(self):
self.assertEqual(
6,
score.score_hand(Card.from_str_list('10C, QD, KH, 2H'),
Card.from_str('3S')))
self.assertEqual(
2,
score.score_hand(Card.from_str_list('JC, 5D, 4H, 9S'),
Card.from_str('7S')))
self.assertEqual(
4,
score.score_hand(Card.from_str_list('JC, QD, 4H, 3S'),
Card.from_str('AS')))
def test_runs(self):
self.assertEqual(
4,
score.score_hand(Card.from_str_list('2d,3d,4d'),
Card.from_str('5D')))
self.assertEqual(
8,
score.score_hand(Card.from_str_list('2d,3d,4d'),
Card.from_str('4c')))
self.assertEqual(
17,
score.score_hand(Card.from_str_list('2d,3d,4d,4c'),
Card.from_str('4s')))
def test_three_of_a_kind(self):
self.assertEqual(
6,
score.score_hand(Card.from_str_list('JC, JD, JH, 2H'),
Card.from_str('6S')))
self.assertEqual(
6,
score.score_hand(Card.from_str_list('3c, 3d, 3s, qh'),
Card.from_str('kh')))
self.assertEqual(
8,
score.score_hand(Card.from_str_list('JC, JD, JH, 2H'),
Card.from_str('2S')))
def test_card_diff_speed(self):
deck = set(standard_deck())
hand = set(Card.from_str_list('2d,3c,4s,5h'))
x1 = set([x for x in deck if x not in hand])
x2 = set(deck).difference(hand)
self.assertEqual(x1, x2)
start_time = timeit.default_timer()
for _ in range(1000):
[x for x in deck if x not in hand]
list_time_taken = timeit.default_timer() - start_time
start_time = timeit.default_timer()
for _ in range(1000):
deck.difference(hand)
set_time_taken = timeit.default_timer() - start_time
print(f'List {list_time_taken} vs Set {set_time_taken}')
self.assertTrue(set_time_taken < list_time_taken)
def test_four_of_a_kind(self):
self.assertEqual(
12,
score.score_hand(Card.from_str_list('QC, QD, QH, QS'),
Card.from_str('6S')))
def test_pairs_no_turn(self):
self.assertEqual(
2, score.score_hand(Card.from_str_list('JS, JD, 6C, 2H'), None))
self.assertEqual(
0, score.score_hand(Card.from_str_list('QS, JD, 6C, 2H'), None))
