def testCanCreateJokerUsingRank(self):
c = card.Card('JOKER', None)
self.assertEqual(ck.JOKER, c.rank)
self.assertTrue(c.is_joker())
c = card.Card('joker', None)
self.assertEqual(ck.JOKER, c.rank)
self.assertTrue(c.is_joker())
def testConvertCardToString(self):
c = card.Card(4, ck.DIAMONDS)
self.assertEqual('4 of diamonds (face up)', str(c))
c = card.Card(ck.ACE, ck.SPADES, ck.FACE_DOWN)
self.assertEqual('ace of spades (face down)', str(c))
c = card.Card(ck.JOKER, None)
self.assertEqual('joker (face up)', str(c))
def testCanCreateCardFaceUp(self):
c = card.Card(8, 'diamonds', 'UP')
self.assertEqual(ck.FACE_UP, c.face)
c = card.Card(9, 'hearts', 'up')
self.assertEqual(ck.FACE_UP, c.face)
c = card.Card('joker', None, 'up')
self.assertEqual(ck.FACE_UP, c.face)
def testCanCreateCardFaceDown(self):
c = card.Card(7, 'clubs', 'DOWN')
self.assertEqual(ck.FACE_DOWN, c.face)
c = card.Card(6, 'spades', 'down')
self.assertEqual(ck.FACE_DOWN, c.face)
c = card.Card('joker', None, 'down')
self.assertEqual(ck.FACE_DOWN, c.face)
def testAddAddsCardToTopOfDeck(self):
cards = [card.Card(ck.ACE, suit) for suit in ck.SUITS]
d = deck.Deck(cards)
new_card = card.Card(ck.TWO, ck.CLUBS)
d.add(new_card)
c = d.deal()
self.assertEqual(new_card, c)
c = d.deal()
self.assertEqual(cards[0], c)
def testUnequalCardsHashUnequal(self):
c1 = card.Card(ck.QUEEN, ck.HEARTS, ck.FACE_UP)
c2 = card.Card(ck.KING, ck.HEARTS, ck.FACE_UP)
c3 = card.Card(ck.QUEEN, ck.SPADES, ck.FACE_UP)
c4 = card.Card(ck.QUEEN, ck.HEARTS, ck.FACE_DOWN)
self.assertNotEqual(hash(c1), hash(c2))
self.assertNotEqual(hash(c1), hash(c3))
self.assertNotEqual(hash(c1), hash(c4))
def testDealWithFaceSetsFace(self):
d = deck.Deck([
card.Card(ck.ACE, ck.SPADES, ck.FACE_DOWN),
card.Card(ck.ACE, ck.SPADES, ck.FACE_UP)
])
c = d.deal(face=ck.FACE_UP)
self.assertEqual(ck.FACE_UP, c.face)
c = d.deal(face=ck.FACE_DOWN)
self.assertEqual(ck.FACE_DOWN, c.face)
def testUnequalCardsAreUnequal(self):
c1 = card.Card(ck.QUEEN, ck.HEARTS, ck.FACE_UP)
c2 = card.Card(ck.KING, ck.HEARTS, ck.FACE_UP)
c3 = card.Card(ck.QUEEN, ck.SPADES, ck.FACE_UP)
c4 = card.Card(ck.QUEEN, ck.HEARTS, ck.FACE_DOWN)
self.assertNotEqual(c1, c2)
self.assertNotEqual(c1, c3)
self.assertNotEqual(c1, c4)
def testAddToBottomAddsCardToBottomOfDeck(self):
cards = [card.Card(ck.ACE, suit) for suit in ck.SUITS]
d = deck.Deck(cards)
new_card = card.Card(ck.TWO, ck.CLUBS)
d.add(new_card, to_bottom=True)
dealt_cards = d.deal_several(len(cards))
self.assertEqual(cards, dealt_cards)
c = d.deal()
self.assertEqual(new_card, c)
def testInitialCardsAreDealtInOrder(self):
cards = [card.Card(ck.ACE, suit) for suit in ck.SUITS]
d = deck.Deck(cards)
self.assertEqual(cards[0], d.deal())
self.assertEqual(cards[1], d.deal())
self.assertEqual(cards[2], d.deal())
self.assertEqual(cards[3], d.deal())
def testWithFaceReturnsCardWithDifferentFace(self):
c1 = card.Card(6, 'clubs', 'up')
c2 = c1.with_face('down')
self.assertEqual(c1.rank, c2.rank)
self.assertEqual(c1.suit, c2.suit)
self.assertEqual('up', c1.face)
self.assertEqual('down', c2.face)
def testPeekDoesNotRemoveCardFromDeck(self):
cards = [card.Card(ck.ACE, suit, ck.FACE_DOWN) for suit in ck.SUITS]
d = deck.Deck(cards)
c = d.peek()
self.assertEqual(len(cards), len(d))
c2 = d.deal()
self.assertEqual(c, c2)
def testResetUnshufflesDeck(self):
random.seed("foo")
cards = [card.Card(ck.ACE, suit) for suit in ck.SUITS]
d = deck.Deck(cards)
d.shuffle()
d.reset()
dealt_cards = d.deal_several(4)
self.assertEqual(cards, dealt_cards)
def testResetSetsDeckToOriginalCards(self):
cards = [card.Card(ck.ACE, suit) for suit in ck.SUITS]
d = deck.Deck(cards)
d.deal_several(len(cards))
self.assertEqual(0, len(d))
d.reset()
self.assertEqual(len(cards), len(d))
dealt_cards = d.deal_several(4)
self.assertEqual(cards, dealt_cards)
def testShuffle(self):
# Hardcode the seed for this test.
random.seed("foo")
cards = [card.Card(ck.ACE, suit) for suit in ck.SUITS]
d = deck.Deck(cards)
d.shuffle()
dealt_cards = d.deal_several(len(cards))
# This was determined by capturing the results using the given seed.
expected_shuffle = [cards[0], cards[3], cards[1], cards[2]]
self.assertEqual(expected_shuffle, dealt_cards)
def testNormalCardIsNotJoker(self):
c = card.Card(10, 'diamonds')
self.assertFalse(c.is_joker())
def testCardIsFaceUpByDefault(self):
c = card.Card('king', 'clubs')
self.assertEqual(ck.FACE_UP, c.face)
def testJokerWithInvalidRankThrowsException(self):
with self.assertRaises(ValueError):
card.Card(None, 'joker')
def testCanCreateCardWithIntegerRank(self):
c = card.Card(2, 'clubs')
self.assertEqual('2', c.rank)
def testCanCreateJokerWithSuitOfJoker(self):
c = card.Card('joker', 'joker')
self.assertEqual(ck.JOKER, c.rank)
self.assertIsNone(c.suit)
self.assertTrue(c.is_joker())
def testJokerWithInvalidSuitThrowsException(self):
with self.assertRaises(ValueError):
card.Card('joker', 'hearts')
def testCardWithRankOfOneCreatesAce(self):
c = card.Card(1, 'spades')
self.assertEqual(ck.ACE, c.rank)
c = card.Card('1', 'clubs')
self.assertEqual(ck.ACE, c.rank)
def testInvalidSuitThrowsException(self):
with self.assertRaises(ValueError):
card.Card('ace', 'spuds')
with self.assertRaises(AttributeError):
card.Card(4, 1)
def testCanCreateCardWithLowercaseSuit(self):
c = card.Card('jack', 'spades')
self.assertEqual(ck.SPADES, c.suit)
def testCanCreaceAceWithAceRank(self):
c = card.Card('ace', 'spades')
self.assertEqual(ck.ACE, c.rank)
def testInvalidFaceThrowsException(self):
with self.assertRaises(ValueError):
c = card.Card(5, 'hearts', 'sideways')
def testCanCreateFaceCard(self):
c = card.Card('JACK', 'diamonds')
self.assertEqual(ck.JACK, c.rank)
c = card.Card('queen', 'hearts')
self.assertEqual(ck.QUEEN, c.rank)
def testCanCreateCardWithUppercaseSuit(self):
c = card.Card(2, 'CLUBS')
self.assertEqual(ck.CLUBS, c.suit)
import copy
import random
import pygame
from cardkit import card
from cardkit import card_constants as ck
DEFAULT_CARD_SET = [
card.Card(rank, suit, ck.FACE_DOWN) for rank, suit in ck.DECK_OF_52
]
class DeckError(Exception):
"""A runtime error encountered while doing Deck operations."""
pass
class Deck(object):
"""An ordered, mutable collection of Cards.
The deck has a top and a bottom. Most operations involve the top
of the deck.
len(deck) will give you the number of cards currently in the deck.
Attributes:
initial_cards (list): The initial sequence of cards that the
deck was created with. The deck may be reset to this initial
state.
cards (list): The current sequence of cards in the deck. For
def testInvalidRankThrowsException(self):
with self.assertRaises(ValueError):
card.Card('bogus', 'diamonds')
with self.assertRaises(ValueError):
card.Card(11, 'clubs')
