def test_hittable_case4(self):
     self.testDealer.recieve_card(Card(CardFaceType.ACE, SuitType.CLUB))
     self.testDealer.recieve_card(Card(CardFaceType.ACE, SuitType.SPADE))
     self.testDealer.recieve_card(Card(CardFaceType.SEVEN, SuitType.HEART))
     # draw cards, at least 2 aces
     self.assertFalse(self.testDealer.should_hit(True),
                      "dealer should have stayed")
 def test_hittable_case3(self):
     # draw some cards, face up with a value greater than 17
     self.testDealer.recieve_card(Card(CardFaceType.KING, SuitType.CLUB))
     self.testDealer.recieve_card(Card(CardFaceType.FIVE, SuitType.CLUB))
     self.testDealer.recieve_card(Card(CardFaceType.FIVE, SuitType.HEART))
     self.assertFalse(self.testDealer.should_hit(True),
                      "dealer sould have stayed")
Esempio n. 3
0
def test_card_has_a_value():

    king_of_spades = Card('spade', 'K')
    queen_of_spades = Card('spade', 'Q')

    assert king_of_spades.value == 'K'
    assert queen_of_spades.value == 'Q'
 def test_hittable_case1(self):
     # draw some cards , face up, value > 13 < 17
     # assert on return of hittable status
     self.testDealer.recieve_card(Card(CardFaceType.KING, SuitType.CLUB))
     self.testDealer.recieve_card(Card(CardFaceType.FIVE, SuitType.DIAMOND))
     self.assertTrue(self.testDealer.should_hit(True),
                     "dealer should have hit")
Esempio n. 5
0
 def test_downgrade_ace_on_bust(self):
     hand = Hand()
     hand.cards = [Card('Ace', 'Spades'), Card('5', 'Hearts')]
     hand.hit(Card('Jack', 'Diamonds'))
     is_hand_busted = hand.check_for_bust()
     self.assertFalse(is_hand_busted)
     self.assertEqual(hand.calculate_total(), 16)
Esempio n. 6
0
 def test_one_big_ace_hand(self):
     """Test generate summary for hand with one ace."""
     hand = Hand()
     hand.cards = [Card('Ace', 'Spades'), Card('7', 'Clubs')]
     summary = hand.generate_hand_summary()
     self.assertEqual(summary,
                      '[Ace of Spades, 7 of Clubs] for a total of 18 (8)')
Esempio n. 7
0
 def test_normal_hand(self):
     """Test generate summary for normal hand."""
     hand = Hand()
     hand.cards = [Card('Queen', 'Spades'), Card('7', 'Clubs')]
     summary = hand.generate_hand_summary()
     self.assertEqual(summary,
                      '[Queen of Spades, 7 of Clubs] for a total of 17')
Esempio n. 8
0
 def test_no_ace_alt_score(self):
     """Test generate summary for hand with one ace."""
     hand = Hand()
     hand.cards = [Card('Ace', 'Spades'), Card('7', 'Clubs')]
     summary = hand.generate_hand_summary(show_ace_alt_score=False)
     self.assertEqual(summary,
                      '[Ace of Spades, 7 of Clubs] for a total of 18')
    def test_hand_value_all_aces(self):
        self.testPlayer.recieve_card(Card(CardFaceType.ACE, SuitType.CLUB))
        self.testPlayer.recieve_card(Card(CardFaceType.ACE, SuitType.HEART))
        self.testPlayer.recieve_card(Card(CardFaceType.ACE, SuitType.SPADE))
        self.testPlayer.recieve_card(Card(CardFaceType.ACE, SuitType.CLUB))

        self.assertEqual(self.testPlayer.get_hand_value(), 14, "failed case 1")
 def test_hittable_case2(self):
     # draw some cards , face up, one ace,  value > 13 < 17
     # assert on return of hittable status
     self.testDealer.recieve_card(Card(CardFaceType.ACE, SuitType.CLUB))
     self.testDealer.recieve_card(Card(CardFaceType.THREE, SuitType.HEART))
     self.assertTrue(self.testDealer.should_hit(True),
                     "dealer should have hit")
Esempio n. 11
0
def test_card_has_valid_suite():

    with pytest.raises(ValueError):
        Card('robotricks', 2)

    c = Card('spade', 2)

    assert c.suit == 'spade'
Esempio n. 12
0
 def test_two_ace_hand(self):
     """Test generate summary for hand with one ace."""
     hand = Hand()
     hand.cards = [Card('Ace', 'Spades'), Card('Ace', 'Clubs')]
     hand.check_for_bust()  # to downgrade one Ace to value=1
     summary = hand.generate_hand_summary()
     self.assertEqual(
         summary, '[Ace of Spades, Ace of Clubs] for a total of 12 (2)')
    def test_hand_value_face_and_ace(self):
        self.testPlayer.recieve_card(Card(CardFaceType.JACK, SuitType.CLUB))
        self.testPlayer.recieve_card(Card(CardFaceType.ACE, SuitType.HEART))

        self.assertEqual(len(self.testPlayer.get_hand()), 2,
                         "mismatch on the number of cards")
        self.assertEqual(self.testPlayer.get_hand_value(), 21,
                         "error this should be a winning hand")
Esempio n. 14
0
def test_iter_deck():
    deck = Deck()

    assert next(deck) == Card('spade', 2)

    next(deck)
    next(deck)

    assert next(deck) == Card('spade', 5)
Esempio n. 15
0
 def test_value(
     self
 ):  #Tests my calc_val() method in my Player class. It calculates the value sum of the hand of the player
     player = Player("Mikkel")
     player.hand.append(Card("Hearts", "Ace", 11))
     player.hand.append(Card("Hearts", "King", 10))
     self.assertEqual(
         player.calc_val(), 21, "Total should be 21"
     )  #In this scenario it tests if the appended cards give a sum of 21 which they should do
Esempio n. 16
0
 def test_false_blackjack(self):
     """Test check_for_black() returns None for a hand with more than 2 cards."""
     self.hand.cards = [
         Card('10', 'Hearts'),
         Card('9', 'Clubs'),
         Card('2', 'Spades')
     ]
     is_blackjack = self.hand.check_for_blackjack()
     self.assertFalse(is_blackjack)
     self.assertEqual(self.hand.status, None)
 def test_visable_value_case2(self):
     self.testDealer.recieve_card(Card(CardFaceType.EIGHT, SuitType.SPADE))
     self.testDealer.recieve_card(
         Card(CardFaceType.ACE, SuitType.HEART, CardFaceState.DOWN))
     visible_value = self.testDealer.get_visible_hand_value()
     self.assertEqual(visible_value, 8, "error on visible hand value")
     self.testDealer.show_card_faces()
     visible_value = self.testDealer.get_visible_hand_value()
     self.assertEqual(visible_value, 19,
                      "error in visible hand value after turning cards")
Esempio n. 18
0
 def test_check_for_bust_positive(self):
     """Test check for bust."""
     self.hand.cards = [
         Card('10', 'Hearts'),
         Card('4', 'Clubs'),
         Card('King', 'Spades')
     ]
     is_bust = self.hand.check_for_bust()
     self.assertTrue(is_bust)
     self.assertEqual(self.hand.status, 'bust')
Esempio n. 19
0
 def test_calulate_total(self):
     """Test calculate total."""
     self.hand.cards = [
         Card('2', 'Hearts'),
         Card('3', 'Clubs'),
         Card('6', 'Diamonds'),
         Card('4', 'Spades'),
         Card('5', 'Hearts')
     ]
     self.assertEqual(self.hand.calculate_total(), 20)
Esempio n. 20
0
 def test_check_for_bust_negative(self):
     """Test check for bust."""
     self.hand.cards = [
         Card('10', 'Hearts'),
         Card('4', 'Clubs'),
         Card('6', 'Spades')
     ]
     is_bust = self.hand.check_for_bust()
     self.assertFalse(is_bust)
     self.assertEqual(self.hand.status, None)
Esempio n. 21
0
def UImain():
    used_cards = []
    cards_showing = []
    deck = []
    for decks in range(1):
        for val in VALS:
            for suit in SUITS:
                deck.append(Card(suit, val))
    random.shuffle(deck)
    blank_card = Card('Plastic', 'Blank')
    rand_index = 8 + random.randint(-4, 4)
    deck.insert(rand_index, blank_card)

    player1 = UIPlayer(200.0, deck, used_cards, cards_showing)
    dealer = Dealer(deck, used_cards, cards_showing)
    while player1.balence > 0:
        os.system('cls' if os.name == 'nt' else 'clear')
        print('Balence:', player1.balence)
        s = int(input('Place wager amount: '))
        player1.set_wager(s)
        deal_cards([dealer, player1])

        # UI player loop
        while (player1.status != Status.STAND):
            print_UI(dealer, player1)
            player1.move()

        while dealer.status != Status.STAND:
            print_UI(dealer, player1, dealer_move=True)
            dealer.move()
            time.sleep(1)
        print_UI(dealer, player1, dealer_move=True)

        dealer_hand_val = dealer.best_hand_val()
        p_hand_val = player1.best_hand_val()

        if p_hand_val > 21 or p_hand_val <= 0:
            print('You lose', player1.wager)
            player1.lose()
        elif player1.has_blackjack() and not dealer.has_blackjack():
            print('You win', player1.wager)
            player1.win()
        elif not player1.has_blackjack() and dealer.has_blackjack():
            print('You lose', player1.wager)
            player1.lose()
        elif p_hand_val > dealer_hand_val:
            print('You win', player1.wager)
            player1.win()
        elif p_hand_val < dealer_hand_val:
            print('You lose', player1.wager)
            player1.lose()

        input('\nhit any key to continue ')
        clear_table([dealer, player1])
Esempio n. 22
0
    def test_get_card_str(self):
        """
        Test that get_card_str() returns the appropriate
        str representation of a card. Also test that it works
        with hidden cards.
        """
        card = Card('Hearts', 'King', 10)
        self.assertEqual(card.get_card_str(), 'King of Hearts')

        card.hidden = True
        self.assertEqual(card.get_card_str(), '**')
Esempio n. 23
0
 def test_check_draw(self):  #Testing if the game ends when there's a draw
     deck = Deck()
     player = Player("Mikkel")
     player.hand.append(Card("Hearts", "Ace", 11))
     player.hand.append(Card("Spades", "Jack", 10))
     dealer = Player("dealer")
     dealer.hand.append(Card("Clubs", "Ace", 11))
     dealer.hand.append(Card("Diamonds", "Jack", 10))
     bj = Blackjack(player, dealer, deck)
     bj.check_who_won()
     self.assertFalse(bj.game_running,
                      "Game should be over since the game drawed")
Esempio n. 24
0
    def test_determine_winners(self):
        """
        Test that the dealer hits at the appropriate times and
        that winning hands are appropriated updated as such.
        """

        # setup deck
        deck = Deck()
        deck.create()
        deck.shuffle()

        # setup gambler, dealer & hands
        dealer = Dealer()
        dealer_hand = Hand()
        dealer.hands.append(dealer_hand)
        gambler = Gambler("Test")
        gambler_hand = Hand()
        gambler.hands.append(gambler_hand)
        players = [gambler, dealer]

        # must hit a soft 17 (A, 6)
        gambler_hand.final_value = 20
        dealer_hand.cards.append(Card('Hearts', 'Ace', 1))
        dealer_hand.cards.append(Card('Hearts', 'Six', 6))
        bj.determine_winners(players, deck)
        self.assertTrue(len(dealer_hand.cards) > 2)

        # must hit on 16 or less (K, 6)
        self.reset_hand_attrs(dealer_hand)
        dealer_hand.cards.append(Card('Hearts', 'King', 10))
        dealer_hand.cards.append(Card('Hearts', 'Six', 6))
        bj.determine_winners(players, deck)
        self.assertTrue(len(dealer_hand.cards) > 2)

        # check dealer bust (K, 6, J)
        dealer_hand.cards.pop()
        dealer_hand.cards.append(Card('Hearts', 'Jack', 10))
        bj.determine_winners(players, deck)
        self.assertTrue(dealer_hand.busted)
        self.assertTrue(gambler_hand.win)

        # check dealer stands on 17 (K, 7)
        self.reset_hand_attrs(dealer_hand)
        dealer_hand.cards.append(Card('Hearts', 'King', 10))
        dealer_hand.cards.append(Card('Hearts', 'Seven', 7))
        bj.determine_winners(players, deck)
        self.assertTrue(len(dealer_hand.cards) == 2)

        # gambler wins with 20 to dealer's 17
        self.assertTrue(gambler_hand.win)

        # check dealer stands on soft 18 (Ace, 7)
        self.reset_hand_attrs(dealer_hand)
        dealer_hand.cards.append(Card('Hearts', 'Ace', 1))
        dealer_hand.cards.append(Card('Hearts', 'Seven', 7))
        bj.determine_winners(players, deck)
        self.assertTrue(len(dealer_hand.cards) == 2)
Esempio n. 25
0
def test_card_has_a_score():
    card = Card(9, "Clubs")
    assert card.get_score() == 9

    card = Card("Q", "Clubs")
    assert card.get_score() == 10

    card = Card("A", "Clubs")
    assert card.get_score() == 1
Esempio n. 26
0
 def test_check_dealer_win(
         self):  #Testing if the game ends if the dealer wins
     deck = Deck()
     player = Player("Mikkel")
     player.hand.append(Card("Hearts", "Ace", 11))
     player.hand.append(Card("Spades", 2, 2))
     dealer = Player("dealer")
     dealer.hand.append(Card("Clubs", "Ace", 11))
     dealer.hand.append(Card("Diamonds", 7, 7))
     bj = Blackjack(player, dealer, deck)
     bj.check_who_won()
     self.assertFalse(bj.game_running,
                      "Game should be over since the dealer won")
Esempio n. 27
0
 def test_ace_values(
     self
 ):  #Checks if the calc_val() method correctly recalculates the sum of the Players hand if there are multiple aces in the Players hand
     player = Player("Mikkel")
     player.hand.append(Card("Hearts", "Ace", 11))
     player.hand.append(Card("Diamonds", "Ace", 11))
     self.assertEqual(
         player.calc_val(), 12,
         "If the player starts with 2 aces the value should be 12 and not 22"
     )
     player.hand.append(Card("Spades", "Ace", 11))
     self.assertEqual(
         player.calc_val(), 13,
         "Fails if the calc.val() doesn't correctly make the value 13")
Esempio n. 28
0
    def test_winner_dealerBlackJack(self):
        # dealer has blackjack
        self.testPlayer.recieve_card(
            Card(CardFaceType.SEVEN, SuitType.CLUB, CardFaceState.UP))
        self.testPlayer.recieve_card(
            Card(CardFaceType.JACK, SuitType.HEART, CardFaceState.UP))
        self.testDealer.recieve_card(
            Card(CardFaceType.KING, SuitType.DIAMOND, CardFaceState.UP))
        self.testDealer.recieve_card(
            Card(CardFaceType.ACE, SuitType.SPADE, CardFaceState.UP))

        self.winner = blackjack.determine_blackjack_winner(
            self.testPlayer, self.testDealer)
        self.assertIsInstance(self.winner, Dealer, "Dealer should have won")
Esempio n. 29
0
    def test_winner_player(self):
        #player has better hand < blackJack
        self.testPlayer.recieve_card(
            Card(CardFaceType.NINE, SuitType.CLUB, CardFaceState.UP))
        self.testPlayer.recieve_card(
            Card(CardFaceType.EIGHT, SuitType.HEART, CardFaceState.UP))
        self.testDealer.recieve_card(
            Card(CardFaceType.KING, SuitType.DIAMOND, CardFaceState.UP))
        self.testDealer.recieve_card(
            Card(CardFaceType.THREE, SuitType.SPADE, CardFaceState.UP))

        self.winner = blackjack.determine_blackjack_winner(
            self.testPlayer, self.testDealer)
        self.assertIsInstance(self.winner, Player, "Player should have won")
Esempio n. 30
0
    def test_Winnner_push(self):
        #  both player and dealer have Ace and Face card
        self.testPlayer.recieve_card(
            Card(CardFaceType.ACE, SuitType.CLUB, CardFaceState.UP))
        self.testPlayer.recieve_card(
            Card(CardFaceType.JACK, SuitType.HEART, CardFaceState.UP))
        self.testDealer.recieve_card(
            Card(CardFaceType.KING, SuitType.DIAMOND, CardFaceState.UP))
        self.testDealer.recieve_card(
            Card(CardFaceType.ACE, SuitType.SPADE, CardFaceState.UP))

        self.winner = blackjack.determine_blackjack_winner(
            self.testPlayer, self.testDealer)
        self.assertTrue((self.winner is None),
                        "there should be no winner here")
Esempio n. 31
0
class card_getRankTest(unittest.TestCase):

    def setUp(self):
        """Call before every test case."""
        self.card = Card("C", "A")

    def testGetSuit(self):
        assert self.card.get_rank() == "A", 'Card.get_rank() does not provide the right return value'
Esempio n. 32
0
class card_strTest(unittest.TestCase):

    def setUp(self):
        """Call before every test case."""
        self.card = Card("C", "A")

    def testStr(self):
        assert self.card.__str__() == "CA", 'Card.__str__() does not provide the right return value'
Esempio n. 33
0
    def test_get_value(self):
        """A test which checks the get_value method of the Card class."""

        # Test to make sure that all of the faces and values match up
        faces = [
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "10",
            "Jack",
            "Queen",
            "King",
            "Ace",
        ]
        values = [
            [2,],
            [3,],
            [4,],
            [5,],
            [6,],
            [7,],
            [8,],
            [9,],
            [10,],
            [10,],
            [10,],
            [10,],
            [1, 11,],
        ]

        for index in range(len(faces)):
            face = faces[index]
            card = Card("Clubs", face)
            found_value = card.get_value()
            expected_value = values[index]
            self.assertEqual(found_value, expected_value, msg="The value for face " + face + \
                " was incorrectly returned as " + str(found_value[0]) + " when it should have" + \
                " been " + str(expected_value[0]) + ".")
Esempio n. 34
0
class card_drawTest(unittest.TestCase):

    def setUp(self):
        """Call before every test case."""
        self.card = Card("C", "A")

    def tearDown(self):
        """Call after every test case."""

    def testDrawInit(self):
        testCanvas = Canvas()
        pos = [1,1]
        assert self.card.draw(testCanvas, pos) == dummy(self), 'BlackJackGame.draw() does not provide the right return value'
Esempio n. 35
0
 def setUp(self):
     """Call before every test case."""
     self.card = Card("C", "A")
Esempio n. 36
0
    def run(self):
        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_socket.bind((socket.gethostname(), SERVER_PORT))
        server_socket.listen()

        server_socket.settimeout(1.5)

        while len(self.clients) == 0 or len(self.not_ready) > 0:
            try:
                client = Client(*server_socket.accept())

                self.not_ready[client.uuid] = True
                self.clients.append(client)

                client_thread = Thread(target=self.client_thread_wait_for_ready, args=(client,), daemon=True)
                client_thread.start()

                # logging -- when a connection happens
                print("New connection: " + str(len(self.clients)))
            except socket.timeout:
                continue

        # minor cleanup
        server_socket.close()

        # play the blackjack game:
        consecutive_passes = 0
        players_at_or_above_max = 0

        # send message to all players announcing start
        self.broadcast("The game is beginning.\n")

        # main game loop: infinite cycle through clients, until exit conditions are met
        for player in cycle(self.clients):
            # ask client for move
            player.client_socket.send(b"TAKE or PASS")

            # receive move: if TAKE, give player a card and update players min score
            data = player.client_socket.recv(128)
            data = data.decode("utf-8")

            # move will be broadcast to all players
            move = "Player " + str(player.uuid) + " has: "

            if data == "PASS":
                consecutive_passes += 1

                move += " opted to PASS.\n"
            elif data == "TAKE":
                card = Card.random()
                player.cards.append(card)
                player.client_socket.send(
                    bytes("Your card: " + str(card) + ".\n", "utf-8")
                )

                move += " TAKEN the card " + str(card) + "\n"

                # check if this player's min sum of card values is at or above 21
                if Card.min_value(player.cards) >= 21:
                    players_at_or_above_max += 1

                # reset consecutive passes
                consecutive_passes = 0
            else:
                # invalid request
                pass

            # send move broadcast
            self.broadcast(move, dont_send_to=player)

            # check for game over conditions
            if consecutive_passes == len(self.clients) or players_at_or_above_max == len(self.clients):
                break

        # decide winner and send to all clients
        # todo
        message = "It's over! "
        if consecutive_passes == len(self.clients):
            message = "Game is over because each player has passed consecutively.\n"

            # todo get winner

        elif players_at_or_above_max == len(self.clients):
            message = "Game is over because every player is either at or above 21 score.\n"

            # todo get winners

        # send final message
        for player in self.clients:
            player.client_socket.send(bytes(message, "utf-8"))

        # cleanup the server
        for player in self.clients:
            player.client_socket.close()
Esempio n. 37
0
 def create_card_test(self):
     c1 = Card("ten", "clubs")
     self.assertEqual(("ten", "clubs"), c1.__repr__())