def WantCard(self, deck):
if deck.CheckEmpty():
deck = CardDeck()
deck.Shuffle()
card = deck.PopCard()
self.hands.append(card)
class TestCardDeck(unittest.TestCase):
def setUp(self):
self.c = CardDeck('TESTUSER')
def tearDown(self):
pass
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def test_deck_has_52_cards(self):
self.assertEqual(52, len(self.c), "Deck does not have 52 cards")
def test_dealing_reduces_len_by_one(self):
old_len = len(self.c)
self.c.deal()
new_len = len(self.c)
self.assertEqual((old_len - new_len), 1, "Dealing does not reduce len")
@unittest.skipUnless(sys.platform == 'win32',
"Only implemented on windows")
def test_non_str_raises_exception(self):
with self.assertRaises(TypeError):
c = CardDeck(1234)
def test_whatever(self):
a = 1.00000000003
b = 1.00000000002
self.assertAlmostEqual(a, b, 7, "a and b are not equal!")
class TestCardDeck(unittest.TestCase):
def setUp(self):
self.d = CardDeck('TESTUSER')
def tearDown(self):
pass
@classmethod
def setUpClass(cls) -> None:
pass
@classmethod
def tearDownClass(cls) -> None:
pass
def test_deck_has_52_cards(self):
deck_len = len(self.d)
self.assertEqual(52, deck_len, "Length of deck is NOT 52")
def test_drawing_one_reduces_len_by_one(self):
orig_len = len(self.d)
self.d.draw()
new_len = len(self.d)
diff = orig_len - new_len
self.assertEqual(diff, 1, 'Removing card did not decrement by one')
@unittest.skipIf(sys.platform == 'win32', "Not implemented on Windows")
def test_bad_dealer_name_raises_error(self):
with self.assertRaises(TypeError):
d = CardDeck(1234)
class TestCardDeck(unittest.TestCase):
def setUp(self):
self.d = CardDeck("TEST USER")
def tearDown(self):
pass
def test_deck_len_is_52(self):
self.assertEqual(52, len(self.d), "Length is not 52")
def test_drawing_one_card_reduces_length_by_one(self):
self.d = CardDeck("TEST USER")
old_len = len(self.d)
self.d.draw()
new_len = len(self.d)
self.assertEqual(1, old_len - new_len,
"Draw does not reduce length of deck")
@classmethod
def setUpClass(cls):
pass
@unittest.skipUnless(sys.platform == 'win32',
"only implemented on Windows")
def test_empty_deck_raises_exception(self):
with self.assertRaises(ValueError):
for i in range(53):
self.d.draw()
class TestCardDeck(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None: # test CASE fixture
pass
@classmethod
def tearDownClass(cls) -> None: # test CASE fixture
pass
def setUp(self): # test fixture
self.test_deck = CardDeck("TEST USER")
@unittest.skipUnless(sys.platform == 'win32',
"Only implemented on Windows")
def test_deck_has_52_cards(self):
self.assertEqual(52, len(self.test_deck),
"Deck does not have 52 cards")
def test_deck_has_all_combos(self):
for rank in CardDeck.RANKS:
for suit in CardDeck.SUITS:
card = rank, suit
self.assertIn(card, self.test_deck._cards,
f"Card {card} not in deck")
def test_drawing_card_decrements_deck(self):
len_before = len(self.test_deck)
self.test_deck.draw()
len_after = len(self.test_deck)
self.assertEqual(len_before - 1, len_after,
"Drawing card does not decrement deck")
def tearDown(self):
pass
def test_drawing_one_card_reduces_length_by_one(self):
self.d = CardDeck("TEST USER")
old_len = len(self.d)
self.d.draw()
new_len = len(self.d)
self.assertEqual(1, old_len - new_len,
"Draw does not reduce length of deck")
class TestCardDeck(unittest.TestCase):
def setUp(self):
self.d = CardDeck("Test User")
def tearDown(self):
pass
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
@unittest.skipUnless(sys.platform == 'win32',
"Only implemented on Windows")
def test_deck_has_52_cards(self):
self.assertEqual(52, len(self.d), "Deck does NOT have 52 cards")
def test_deck_raises_error_on_invalid_dealer_name(self):
with self.assertRaises(TypeError):
d = CardDeck(1234)
def test_dealing_1_card_reduces_len_by_1(self):
old_len = len(self.d)
self.d.draw()
new_len = len(self.d)
self.assertEqual(old_len - new_len, 1, "Dealing one card does not...")
class TestCardDeck(unittest.TestCase):
def setUp(self):
self._deck = CardDeck('test user')
def test_length_of_deck_is_52(self):
expected = 52
self.assertEqual(len(self._deck), expected)
def test_invalid_name_raises_err(self):
with self.assertRaises(TypeError):
d = CardDeck(1234)
def test_drawing_card_reduces_len_by_one(self):
expected = 51
self._deck.draw()
self.assertEqual(len(self._deck), expected)
def __init__(self, player_names):
print("Let's start the game!\n")
self.deck = CardDeck()
self.discard_pile = DiscardPile(self.deck)
self.table = Table()
self.players = [Player(name, self.deck) for name in player_names]
self.turn_counter = 0
def __init__(self, num_players, chips):
self.dealer = Dealer()
self.players = [None] * num_players
self.num_players = num_players
self.deck = CardDeck()
for i in range(self.num_players):
self.players[i] = Player(i, chips)
class BlackJack:
def __init__(self, players: list):
self.game_state = True
self.players = players
self.hand_size = 2
self.deck = CardDeck()
self.winning_score = 21
@property
def players(self) -> list:
return self._players
@players.setter
def players(self, players: list) -> None:
player_objs = []
for player in players:
player_obj = Player(player)
player_objs.append(player_obj)
house_player = Player("House")
player_objs.append(house_player)
self._players = player_objs
@property
def player_names(self) -> list:
players = self.players
player_names = []
for player in players:
player_names.append(player.name)
return player_names
@property
def current_leader(self) -> Player:
return max(self.active_players,
key=lambda player: player.hand.hand_sum)
def add_player(self, name: str) -> None:
new_player = Player(name)
self.players.append(new_player)
def deal_hand_to_players(self) -> None:
for player in self.players:
player.hand = Hand(self.deck.draw_cards(self.hand_size))
player.hand.attach(player)
def clean_up_busted_hands(self) -> list:
players = []
for player in self.active_players:
busted = player.hand.busted()
if busted:
players.append(player)
return players
@property
def active_players(self) -> list:
return [player for player in self.players if player.active]
def __repr__(self):
return f"Players: {self.player_names}, Game State: {self.game_state}"
def reset(self, number_of_starting_cards=7):
self.deck = CardDeck()
self.discard_pile = DiscardPile(self.deck)
self.table = Table()
self.turn_counter = 0
for player in self.players:
player.cards = player.get_starting_cards(self.deck,
number_of_starting_cards)
player.submitted_cards = []
def main():
"""
Program entry point
:return: None
"""
deck1 = CardDeck('Nellie') # instantiate
print(deck1)
deck2 = CardDeck('Andy')
deck3 = CardDeck('Rosie')
# deck1.some_method()
# deck1.some_property
print(deck1.dealer) # deck1.dealer() line 9
deck1.dealer = "Frodo" # deck1.dealer() line 13
print(deck1.dealer)
try:
deck1.dealer = 1234
except TypeError as err:
print(err)
print(deck1.dealer, deck2.dealer, deck3.dealer)
deck1.shuffle()
print(deck1.cards)
print()
for _ in range(5):
rank, suit = deck1.draw()
print(f"{rank} of {suit}")
jokerdeck1 = JokerDeck("Alicia")
jokerdeck2 = JokerDeck("Ferdinand")
print(jokerdeck1)
jokerdeck1.shuffle()
print(jokerdeck1.cards)
print(jokerdeck1.draw())
print(deck1) # print(str(deck1))
print(jokerdeck1, deck1, jokerdeck2, deck2)
class TestCardDeck(unittest.TestCase):
@classmethod
def setUpclass(cls):
pass
def setUp(self):
self.d = CardDeck("TEST USER")
def test_deck_has_52_cards(self):
self.assertEqual(len(self.d), 52, "Deck did not have 52 cards")
def test_empty_deck_raises_error(self):
for i in range(52):
self.d.draw()
with self.assertRaises(ValueError):
self.d.draw()
@unittest.skipUnless(sys.platform == 'win32',
"Only implemented on Windows")
def test_shuffling_preserves_cards(self):
old_cards = list(self.d.cards)
self.d.shuffle()
new_cards = self.d.cards
assert (set(old_cards) == set(new_cards))
def RunGame(self):
self.game_status = True
self.game_table.deck.Shuffle()
while self.game_status:
if self.game_table.deck.CheckLess60():
self.game_table.deck = CardDeck()
self.game_table.deck.Shuffle()
self.StartToServe()
self.game_status = self.CheckTable()
sys.exit(1)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.card_deck = CardDeck()
self.card_deck.deck = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'D', 'K', 'A']
def test_deal_cards(self):
hand = self.card_deck.deal_cards(5)
self.assertEqual([2,3,4,5,6],hand)
self.assertEqual(8, len(self.card_deck.deck))
def test_deal_no_cards(self):
hand = self.card_deck.deal_cards(0)
self.assertEqual([], hand)
self.assertEqual(13, len(self.card_deck.deck))
def test_create_deck(self):
self.assertEqual([2,3,4,5,6], self.card_deck.deck[0:5])
self.assertEqual(13, len(self.card_deck.deck))
def test_shuffle(self):
self.card_deck.shuffle()
self.assertNotEqual([2,3,4,5,6], self.card_deck.deck[0:5])
self.assertEqual(13, len(self.card_deck.deck))
class TestCardDeck(TestCase):
@classmethod
def setUpClass(cls):
pass
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
self.deck = CardDeck(TEST_USER)
def test_card_deck_has_52_cards(self):
self.assertEqual(52, len(self.deck), "New deck did not have 52 cards")
# @skipUnless(sys.platform == 'win32', 'only implemented on Windows')
def test_drawing_one_card_reduces_length_by_one(self):
self.deck.draw()
self.assertEqual(51, len(self.deck),
"Drawing one card did not reduce length by one")
def tearDown(self):
pass
#!/usr/bin/env python
from carddeck import CardDeck
from jokerdeck import JokerDeck
c1 = CardDeck("Fred")
print(c1)
print(c1.dealer)
c1.dealer = "Abigail"
print(c1.dealer)
try:
c1.dealer = [5, 6.9]
except TypeError as err:
print(err)
else:
print(c1.dealer)
c1.spam("ha ha ha")
c1.shuffle()
print(c1.cards)
print()
for i in range(10):
print(c1.draw())
print()
print(c1.get_ranks())
print()
def setUp(self):
self.d = CardDeck("TEST USER")
#!/usr/bin/env python
from carddeck import CardDeck
from jokerdeck import JokerDeck
d = CardDeck("Suzie")
print(d)
print(d.get_dealer())
print(d.dealer)
d.dealer = 'Bob'
print(d.dealer)
try:
d.dealer = 12.34
except TypeError as err:
print(err)
else:
print(d.dealer)
d.shuffle()
print(d.cards)
print()
hand = []
for i in range(5):
hand.append(d.draw())
print("Hand:", hand)
#!/usr/bin/env python
from carddeck import CardDeck
from jokerdeck import JokerDeck
c1 = CardDeck("Betty")
print(c1)
print(c1.dealer)
c1.dealer = 'Bob'
print(c1.dealer)
try:
c1.dealer = 1.234
except TypeError as err:
print(err)
else:
print(c1.dealer)
print()
c1.shuffle()
print(c1.cards)
print()
print(len(c1))
print(c1)
print(c1.get_suits())
from carddeck import CardDeck
from jokerdeck import JokerDeck
d1 = CardDeck('Tom')
d2 = CardDeck('Susan')
print(d1, d2)
print(d1.get_dealer())
print(d1.dealer)
print(d1.color)
d1.color = "chartreuse"
d1.dealer = 'Jeff'
print(d1.dealer)
try:
d1.dealer = 123.456
except TypeError as err:
print(err)
else:
print(d1.dealer)
d1.shuffle()
print(d1.cards)
print()
def test_dealer_name_rejects_non_str(self):
with self.assertRaises(Exception) as cm:
sys.stdout.write(str(cm.exception) + '\n')
d = CardDeck(1234)
def setUp(self):
self.d = CardDeck('Test User')
#!/usr/bin/env python
"""
Main program for playing cards
"""
import sys
import time
from carddeck import CardDeck
from jokerdeck import JokerDeck
start = time.time()
D1 = CardDeck("Anne")
print(D1)
D2 = CardDeck("Fernando")
print(D2)
print(D1.dealer_name)
print(D2.dealer_name)
D1.dealer_name = "Bob"
print(D1.dealer_name)
try:
D1.dealer_name = 123.456
except TypeError as err:
print(err)
print(D1.dealer_name)
print(D1.dealer_name.upper())
#!/usr/bin/env python
from carddeck import CardDeck
from jokerdeck import JokerDeck
d1 = CardDeck("Bob")
print(d1)
print(d1.dealer)
d1.shuffle()
print(d1.cards)
hand = []
for i in range(5):
hand.append(d1.draw())
print(hand)
d2 = CardDeck("Linda")
j1 = JokerDeck("Beth")
j1.shuffle()
print(j1.cards)
#!/usr/bin/env python
from carddeck import CardDeck
from jokerdeck import JokerDeck
print(CardDeck)
# create new object d1
d1 = CardDeck("Zach")
# d1 is "self"
# bad programmer! no biscuit!
# print(d1._dealer_name)
# access a property
# (variable)
print(d1.dealer_name)
print(d1)
d1.dealer_name = "Freida"
# doing this:
# CardDeck.dealer_name(d1, "Fredia")
print(d1.dealer_name)
d2 = CardDeck("Franz")
d2.dealer = "Billy"
d1.shuffle()
#!/usr/bin/env python
# module class
from carddeck import CardDeck
from joker_deck import JokerDeck
#creates an instance of the class
d1 = CardDeck("Scotty")
print(d1)
#
# d1.shuffle()
# for i in range(5):
# print(d1.draw())
d2 = CardDeck('Jess')
print(d2)
print(d2.dealer)
d2.dealer = 'Kara'
print(d2.dealer)
d1.shuffle()
print(d1.cards)
hand = []
for i in range(5):
hand.append(d1.deal())
#!/usr/bin/env python
import time
start_time = time.time()
from carddeck import CardDeck
from jokerdeck import JokerDeck
d1 = CardDeck("Betty")
print(d1)
print(d1.dealer)
d1.dealer = "Bob"
print(d1.dealer)
# print(d1.get_dealer())
# d1.set_dealer("Brenda")
d1.shuffle()
print(d1.cards, '\n')
for i in range(7):
print(d1.draw())
print()
print(d1.get_ranks())
print(CardDeck.get_ranks())
from carddeck import CardDeck
from jokerdeck import JokerDeck
d1 = CardDeck("Andy")
print(type(d1))
# d1.shuffle()
# d1.draw()
print(d1.dealer)
d1.dealer = "Nellie"
print(d1.dealer)
try:
d1.dealer = 5.8
except TypeError as err:
print(err)
else:
print(d1.dealer)
d1.shuffle()
print(d1.cards, '\n')
for i in range(7):
card = d1.draw()
print(card.rank, card.suit)
# print(x)
