def test_quads_to_quads_comparison(self): player = Player("player", ManualActionCollector()) player2 = Player("Player2", ManualActionCollector()) suit = Suit.DIAMONDS suit1 = Suit.CLUBS hand1 = [ Card(Number.THREE, suit1), Card(Number.THREE, Suit.HEARTS), Card(Number.THREE, suit), Card(Number.THREE, Suit.SPADES), Card(Number.KING, suit1) ] hand2 = [ Card(Number.TWO, suit1), Card(Number.TWO, Suit.HEARTS), Card(Number.TWO, suit), Card(Number.TWO, Suit.SPADES), Card(Number.KING, suit) ] round_result = RoundResult( [HandResult(hand1, player), HandResult(hand2, player2)]) winning_hand = round_result.find_winning_hands()[0].cards self.assertTrue(set(hand1).issubset(winning_hand))
def test_high_card_pair_comparison(self): player = Player("player", ManualActionCollector()) player2 = Player("Player2", ManualActionCollector()) suit = Suit.DIAMONDS suit1 = Suit.CLUBS hand1 = [ Card(Number.TWO, suit), Card(Number.TWO, suit1), Card(Number.THREE, suit), Card(Number.FOUR, suit), Card(Number.FIVE, suit1) ] hand2 = [ Card(Number.ACE, suit), Card(Number.KING, suit), Card(Number.QUEEN, suit), Card(Number.JACK, suit), Card(Number.NINE, suit1) ] round_result = RoundResult( [HandResult(hand1, player), HandResult(hand2, player2)]) winning_hand = round_result.find_winning_hands()[0].cards self.assertTrue(set(hand1).issubset(winning_hand))
def test_sort(self): hand = [ Card('KING', 'SPADES'), Card('QUEEN', 'HEARTS'), Card('JACK', 'HEARTS'), Card('ACE', 'DIAMONDS'), Card(10, 'DIAMONDS'), Card('QUEEN', 'DIAMONDS'), Card('JACK', 'SPADES') ] self.print_hand(hand) hand = sorted( hand ) #, key=lambda card: card.suit) a lambda is not needed now that __lt__() has been implemented print() self.print_hand(hand)
def __init__(self): self.cards_storage = [] db_file_path = os.path.join("data", "cards - main cards.csv") with open(db_file_path) as cards_db: cards_db_reader = csv.reader(cards_db, delimiter=",") header_line_skipped = False for row in cards_db_reader: if not header_line_skipped: header_line_skipped = True continue card = Card(row[1], row[2], row[3], row[4], row[5], CardsStorage.parseLevel(row[6]), row[7], CardsStorage.parseCoinType(row[8])) self.cards_storage.append(card)
def test_cards_storage(self): self.assertEqual( self.cards.getCard(6), Card(white_cost=2, green_cost=2, level=CardLevel.ONE, discount=CoinTypes.BLACK)) self.assertEqual( self.cards.getCard(21), Card(blue_cost=1, red_cost=2, black_cost=2, level=CardLevel.ONE, discount=CoinTypes.GREEN)) self.assertEqual( self.cards.getCard(36), Card(white_cost=1, blue_cost=1, red_cost=1, black_cost=1, level=CardLevel.ONE, discount=CoinTypes.GREEN)) self.assertEqual( self.cards.getCard(41), Card(blue_cost=5, level=CardLevel.TWO, points=2, discount=CoinTypes.BLUE)) self.assertEqual( self.cards.getCard(70), Card(red_cost=6, level=CardLevel.TWO, points=3, discount=CoinTypes.RED)) self.assertEqual( self.cards.getCard(90), Card(white_cost=3, black_cost=7, level=CardLevel.THREE, points=5, discount=CoinTypes.WHITE))
def __init__(self): self.unused = Deck((Card(n, s) for n, s in itertools.product( constants.STANDARD_CARDS, constants.STANDARD_SUITS))) self.discard, self.active = Deck(), Deck() self.Reset()
def _create_suit(self, suit): for number in Number: self.cards.append(Card(number, suit))
random.seed(5) def get_cards(deck, number): return [deck.deal() for i in range(number)] if __name__ == '__main__': d = Deck(jokers=2) print(unicode(d)) #Shuffle the deck again d.shuffle() print("\nPost shuffling again:") print(unicode(d)) #Get a hand of cards from the deck print('\nDealt Hand:') hand = get_cards(d, 5) for c in hand: print(unicode(c)) #Make sure one of the cards dealt is no longer in the deck check_card = hand[1] print('\n{} in deck? {}'.format(unicode(check_card),\ d.contains(check_card))) #Check if a card is still in the deck print('\nJoker in deck? {}'.format(d.contains(Card('Wild', 'Joker'))))
def test_is_sorted(self): hand = [ Card('KING', 'SPADES'), Card('QUEEN', 'HEARTS'), Card('JACK', 'HEARTS'), Card('ACE', 'DIAMONDS'), Card(10, 'DIAMONDS'), Card('QUEEN', 'DIAMONDS'), Card('JACK', 'SPADES') ] #self.assertFalse(self.is_sorted(hand)) hand = [ Card(10, 'DIAMONDS'), Card('JACK', 'HEARTS'), Card('JACK', 'SPADES'), Card('QUEEN', 'DIAMONDS'), Card('QUEEN', 'HEARTS'), Card('KING', 'SPADES'), Card('ACE', 'DIAMONDS') ] self.assertTrue(self.is_sorted(hand))
def test_equality_jokers(self): x = Card('Wild', 'Joker') y = Card('Wild', 'Joker') self.assertEqual(x, y)
def _get_deck(self): result = [] for rank in self.ranks: for suit in self.suits: result.append(Card(rank, suit)) return result
import pytest from cards.card import Card @pytest.mark.parametrize("card,expected", [(Card('hearts', 2), "2 of Hearts"), (Card('hearts', 11), "Jack of Hearts"), (Card('hearts', 12), "Quin of Hearts"), (Card('hearts', 13), "King of Hearts"), (Card('hearts', 14), "Ace of Hearts")]) def cards_names_test(card, expected): assert card.display_name == expected assert card.__str__() == expected assert card.__repr__() == expected
def test_is_legit_with_legit_5_card_hands(self): hand = [ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(4, 'SPADES'), Card(5, 'DIAMONDS') ] self.assertFalse(Cards.is_legit_hand(hand)) self.assertFalse( Cards.is_legit_hand([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertFalse( Cards.is_legit_hand([ Card(2, 'SPADES'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertFalse( Cards.is_legit_hand([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card('KING', 'DIAMONDS') ])) #TODO: repeated cards (should fail) self.assertFalse( Cards.is_legit_hand([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card('KING', 'DIAMONDS') ]))
def test_contains_duplidate(self): self.assertEqual( False, Cards.contains_duplicate([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(8, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertEqual( True, Cards.contains_duplicate([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(8, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertEqual( True, Cards.contains_duplicate([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(8, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(2, 'DIAMONDS') ])) self.assertEqual( True, Cards.contains_duplicate([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS') ]))
def test_construction(self): six_oF_diamonds = Card(6, "DIAMONDS") self.assertEqual(six_oF_diamonds.__str__(), '6 DIAMONDS')
def test_contains_three_of_a_kind(self): self.assertFalse( Cards.contains_three_of_a_kind([ Card(10, 'HEARTS'), Card('JACK', 'DIAMONDS'), Card('ACE', 'DIAMONDS'), Card('KING', 'DIAMONDS'), Card('QUEEN', 'DIAMONDS') ])) self.assertFalse( Cards.contains_three_of_a_kind([ Card(10, 'HEARTS'), Card('JACK', 'DIAMONDS'), Card('ACE', 'DIAMONDS'), Card('KING', 'DIAMONDS'), Card('QUEEN', 'HEARTS') ])) self.assertTrue( Cards.contains_three_of_a_kind([ Card(4, 'DIAMONDS'), Card(4, 'CLUBS'), Card(5, 'HEARTS'), Card(5, 'CLUBS'), Card(5, 'SPADES') ]))
def test_is_straight_flush(self): self.assertFalse( Cards.is_straight_flush([ Card(10, 'HEARTS'), Card('JACK', 'DIAMONDS'), Card('ACE', 'DIAMONDS'), Card('KING', 'DIAMONDS'), Card('QUEEN', 'DIAMONDS') ])) self.assertFalse( Cards.is_straight_flush([ Card(5, 'DIAMONDS'), Card(7, 'SPADES'), Card(3, 'DIAMONDS'), Card(6, 'DIAMONDS'), Card(4, 'DIAMONDS') ])) self.assertTrue( Cards.is_straight_flush([ Card(5, 'DIAMONDS'), Card(7, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(6, 'DIAMONDS'), Card(4, 'DIAMONDS') ])) self.assertTrue( Cards.is_straight_flush([ Card(5, 'HEARTS'), Card(7, 'HEARTS'), Card(3, 'HEARTS'), Card(6, 'HEARTS'), Card(4, 'HEARTS') ])) self.assertTrue( Cards.is_straight_flush([ Card(5, 'SPADES'), Card(7, 'SPADES'), Card(3, 'SPADES'), Card(6, 'SPADES'), Card(4, 'SPADES') ])) self.assertTrue( Cards.is_straight_flush([ Card(5, 'CLUBS'), Card(7, 'CLUBS'), Card(3, 'CLUBS'), Card(6, 'CLUBS'), Card(4, 'CLUBS') ])) self.assertTrue( Cards.is_straight_flush([ Card(10, 'DIAMONDS'), Card('JACK', 'DIAMONDS'), Card('ACE', 'DIAMONDS'), Card('KING', 'DIAMONDS'), Card('QUEEN', 'DIAMONDS') ]))
def test_is_flush(self): self.assertFalse( Cards.is_flush([ Card(1, 'HEARTS'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertFalse( Cards.is_flush([ Card(1, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(4, 'SPADES'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertFalse( Cards.is_flush([ Card(1, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(4, 'SPADES'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) #self.assertFalse(Cards.is_flush([Card(1, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS'), Card(5, 'DIAMONDS')])) will be correct once we check for duplicates #some valid flush hands self.assertTrue( Cards.is_flush([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(8, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) #randomly generate some valid flushes for suit in Cards.SUITS: #hand = Cards.random_cards(Cards.RANKS, [suit], 5) #for card in hand: # print(card) #self.assertTrue(Cards.is_flush(hand)) self.assertTrue( Cards.is_flush(Cards.random_cards(Cards.RANKS, [suit], 5)))
def setUp(self): self.cards = CardsStorage() self.level1_stack = CardsStack(1, self.cards.cards_storage) self.level2_stack = CardsStack(2, self.cards.cards_storage) self.level3_stack = CardsStack(3, self.cards.cards_storage) self.level1_cumulative_cost = 33 self.level2_cumulative_cost = 41 self.level3_cumulative_cost = 43 self.level1_cards_count = 40 self.level2_cards_count = 30 self.level3_cards_count = 20 self.cards_db = [ Card(blue_cost=3, level=CardLevel.ONE, discount=CoinTypes.WHITE), Card(red_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLUE), Card(white_cost=3, level=CardLevel.ONE, discount=CoinTypes.WHITE), Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLUE), Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN), Card(red_cost=3, level=CardLevel.ONE, discount=CoinTypes.RED), Card(black_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLACK), Card(black_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN), Card(blue_cost=2, green_cost=2, level=CardLevel.TWO, discount=CoinTypes.WHITE), Card(white_cost=2, green_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLUE), Card(red_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.GREEN), Card(white_cost=2, blue_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLACK), Card(blue_cost=2, red_cost=2, level=CardLevel.TWO, discount=CoinTypes.RED), Card(white_cost=2, red_cost=2, level=CardLevel.TWO, discount=CoinTypes.WHITE), Card(green_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.GREEN), Card(white_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLACK), Card(white_cost=2, blue_cost=4, level=CardLevel.THREE, discount=CoinTypes.WHITE), Card(white_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLUE), Card(white_cost=2, red_cost=4, level=CardLevel.THREE, discount=CoinTypes.GREEN), Card(white_cost=2, black_cost=4, level=CardLevel.THREE, discount=CoinTypes.RED), Card(blue_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.WHITE), Card(blue_cost=2, red_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLACK), Card(blue_cost=2, black_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLUE), Card(red_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.GREEN) ] self.cards_stack_lvl1 = CardsStack(1, self.cards_db) self.cards_stack_lvl2 = CardsStack(2, self.cards_db) self.cards_stack_lvl3 = CardsStack(3, self.cards_db)
def test_init_jokers(self): d = Deck(jokers=2) self.assertEqual(len(d.cards), 54) self.assertTrue(d.contains(Card('Wild', 'Joker')))
def setUp(self): self.cards_db = [Card(blue_cost=3, level=CardLevel.ONE, discount=CoinTypes.WHITE), Card(red_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLUE), Card(white_cost=3, level=CardLevel.ONE, discount=CoinTypes.WHITE), Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLUE), Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN), Card(red_cost=3, level=CardLevel.ONE, discount=CoinTypes.RED), Card(black_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLACK), Card(black_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN), Card(blue_cost=2, green_cost=2, level=CardLevel.TWO, discount=CoinTypes.WHITE), Card(white_cost=2, green_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLUE), Card(red_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.GREEN), Card(white_cost=2, blue_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLACK), Card(blue_cost=2, red_cost=2, level=CardLevel.TWO, discount=CoinTypes.RED), Card(white_cost=2, red_cost=2, level=CardLevel.TWO, discount=CoinTypes.WHITE), Card(green_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.GREEN), Card(white_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLACK), Card(white_cost=2, blue_cost=4, level=CardLevel.THREE, discount=CoinTypes.WHITE), Card(white_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLUE), Card(white_cost=2, red_cost=4, level=CardLevel.THREE, discount=CoinTypes.GREEN), Card(white_cost=2, black_cost=4, level=CardLevel.THREE, discount=CoinTypes.RED), Card(blue_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.WHITE), Card(blue_cost=2, red_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLACK), Card(blue_cost=2, black_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLUE), Card(red_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.GREEN)]
def test_count_duplicates_sort(self): self.assertEqual( 0, Cards.count_duplicates_sort([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(8, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertEqual( 1, Cards.count_duplicates_sort([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(8, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(5, 'DIAMONDS') ])) self.assertEqual( 2, Cards.count_duplicates_sort([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(8, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(2, 'DIAMONDS') ])) self.assertEqual( 3, Cards.count_duplicates_sort([ Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(2, 'DIAMONDS'), Card(3, 'DIAMONDS') ]))
def __init__(self, suits: List[str], values: List[int]): self.cards = deque( [Card(suit, value) for suit, value in product(suits, values)])
import pytest from cards.card import Card from games.wargame.main import WarGame from games.wargame.players import Player card_1 = Card('A', 3) card_2 = Card('B', 6) card_3 = Card('B', 6) @pytest.fixture() def game(): return WarGame([Player(), Player()]) @pytest.mark.parametrize("cards,expected", [([card_1, card_2], card_2), ([card_1, card_1], None), ([card_3, card_3], None)]) def compare_cards_test(cards, expected, game): bigger_card = game.compare_cards(*cards) assert bigger_card == expected def deal_all_cards_test(game): amount_of_cards_per_player = len(game.deck.cards) / len(game.players) game.deal_cards() assert not game.deck.cards
def test_init(self): d = Deck(jokers=False) self.assertEqual(len(d.cards), 52) self.assertFalse(d.contains(Card('Wild', 'Joker')))
def _from_hours_to_cards(self, tracked_hours): cards = [] for hours in tracked_hours: cards.append(Card(hours)) return cards
def test_deck_contains_ace_of_hearts(self): d = Deck() c = Card('Hearts', 'Ace') self.assertTrue(d.contains(c))
def _change_contract_for_hourly_to_fixed(self, staff): employee = staff.employees()[1] # Getting an hourly employee.change_contract(Fixed(2500), FixedCalculator()) employee.add_card(Card(10))
def test_eq(self): card1 = Card('ACE', 'SPADES') card2 = Card('ACE', 'SPADES') self.assertFalse(card1 is card2) self.assertTrue(card1 == card2) self.assertTrue(card1.__eq__(card2))
def __init__(self): CardStack.__init__(self) self.cards = [Card(i, j) for i in Card.suit_names for j in Card.value_names]