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)