def testdraw(self):
deck = hw5.Deck()
hand = ec1.Hand(deck.cards)
deck1=hw5.Deck()
hand.draw(deck1)
self.assertEqual(len(hand.init_card),53)
self.assertEqual(len(deck1.cards),51)
def testAddAndRemove(self):
c1 = hw5_cards_ec1.Card(0, 2)
c2 = hw5_cards_ec1.Card(1, 1)
init_list = [c1, c2]
hand1 = hw5_cards_ec1.Hand(init_list)
#c2 should not be added to the hand
#c2 is already in the hand
len_before = len(hand1.init_card)
hand1.add_card(c2)
len_after = len(hand1.init_card)
self.assertEqual(len_after, len_before)
#c3 should be added successfullt
c3 = hw5_cards_ec1.Card(suit=1, rank=7)
len_before = len(hand1.init_card)
hand1.add_card(c3)
len_after = len(hand1.init_card)
self.assertEqual(len_after, len_before + 1)
#remove one card
#remove c3
self.assertEqual(c3, hand1.remove_card(c3))
#cannot remove c3, c3 is not in the hand
self.assertEqual(None, hand1.remove_card(c3))
def test_q9(self):
'''
test that hand is initialized properly
'''
new_card = hw5_cards_ec1.Card()
hand = hw5_cards_ec1.Hand([new_card])
self.assertEqual(hand.cards, [new_card])
def test_construct_Card(self):
c1 = hw5_cards_ec1.Card(0, 2)
c2 = hw5_cards_ec1.Card(1, 1)
init_list = [c1, c2]
hand1 = hw5_cards_ec1.Hand(init_list)
self.assertEqual(hand1.init_card, init_list)
self.assertIsInstance(hand1.init_card[0], hw5_cards_ec1.Card)
def test1_init(self):
d = hw5_cards.Deck() # create a deck
d.shuffle() # shuffle the deck
hand_size = random.randint(1,51) # generate a random hand size
hand = d.deal_hand(hand_size) # create a temp hand list from deck also update the deck
h = hw5_cards_ec1.Hand(hand) # create hand object
for i in range(0,hand_size):
self.assertEqual(h.cards[i].__str__(), hand[i].__str__())
def testAddAndRemove(self):
deck = hw5.Deck()
card_missing=deck.deal_card()
hand = ec1.Hand(deck.cards)
for i in hand.init_card:
hand.add_card(i)
self.assertEqual(len(hand.init_card), 51)
hand.add_card(card_missing)
self.assertEqual(len(hand.init_card),52)
def test_construct_Hand(self):
cards_already_in_hands = \
[hw5_cards_ec1.Card(0, 1), hw5_cards_ec1.Card(1, 4), hw5_cards_ec1.Card(3, 11), hw5_cards_ec1.Card(3, 12)]
hand_1 = hw5_cards_ec1.Hand(cards_already_in_hands)
self.assertIsInstance(hand_1, hw5_cards_ec1.Hand)
self.assertIsInstance(hand_1.init_card, list)
self.assertEqual(hand_1.init_card[0].__str__(), "Ace of Diamonds")
self.assertEqual(hand_1.init_card[1].__str__(), "4 of Clubs")
self.assertEqual(hand_1.init_card[2].__str__(), "Jack of Spades")
self.assertEqual(hand_1.init_card[3].__str__(), "Queen of Spades")
def test_add_remove(self):
'''
test that add_card and remove_card function functions as inteneded
'''
new_card = hw5_cards_ec1.Card()
hand = hw5_cards_ec1.Hand([])
hand.add_card(new_card)
self.assertEqual(hand.cards, [new_card])
hand.remove_card(new_card)
self.assertEqual(hand.cards, [])
def testAddAndRemove(self):
'''
Test that add_card( ) and remove_card( ) behave as specified.
'''
c1 = hw5_cards_ec1.Card(0, 2)
c2 = hw5_cards_ec1.Card(1, 1)
c3 = hw5_cards_ec1.Card(2, 12)
c4 = hw5_cards_ec1.Card(3, 6)
c5 = hw5_cards_ec1.Card(0, 13)
c6 = hw5_cards_ec1.Card(1, 3)
list_init_cards = [c1, c2, c3, c4, c5]
h1 = hw5_cards_ec1.Hand(
list_init_cards) # Initialize a hand with five cards
h2 = hw5_cards_ec1.Hand(
list_init_cards) # Initialize a hand with five cards
num_init_cards = len(h1.init_cards)
# Test add_card()
h1.add_card(c3) # Add the card that is already in the hand
self.assertEqual(
len(h1.init_cards),
num_init_cards) # Check if the number of cards does not change
h1.add_card(c6) # Add a new card
self.assertEqual(
len(h1.init_cards), num_init_cards +
1) # Check if the number of cards has increased by one
self.assertTrue(str(c6) in [str(card) for card in h1.init_cards
]) # Check if the new card is in the hand
# Test remove_card()
h2.remove_card(c6) # Remove a card that is not in the hand
self.assertEqual(
len(h2.init_cards),
num_init_cards) # Check if the number of cards does not change
removed_card = h2.remove_card(
c4) # Remove the card that is in the hand
self.assertEqual(
len(h2.init_cards), num_init_cards -
1) # Check if the number of cards has decreased by one
self.assertEqual(str(removed_card),
str(c4)) # Check if the removed card is correct
def testAddAndRemove(self):
c1 = hw5_cards_ec1.Card(1,2)
c2 = hw5_cards_ec1.Card(2,4)
h2 = hw5_cards_ec1.Hand()
n0 = len(h2.cards)
h2.add_card(c1)
n1 = len(h2.cards)
h2.remove_card(c1)
n2 = len(h2.cards)
self.assertEqual(n0,n2)
self.assertEqual(n1-1,n2)
def test3_draw(self):
d = hw5_cards.Deck() # create a deck
d.shuffle() # shuffle the deck
hand_size = random.randint(1,51) # generate a random hand size
hand = d.deal_hand(hand_size) # create a temp hand list from deck also update the deck
h = hw5_cards_ec1.Hand(hand) # create hand object
num_cards_in_hand = len(h.cards) # how many cards in the hand now
num_cards_in_dect = len(d.cards) # how many cards in the dect now
h.draw(d)
self.assertEqual(len(h.cards), num_cards_in_hand+1)
self.assertEqual(len(d.cards), num_cards_in_dect-1)
def testDraw(self):
deck1 = hw5_cards_ec1.Deck()
deck1.shuffle()
len_deck_before = len(deck1.cards)
hand1 = hw5_cards_ec1.Hand([])
len_hand_before = len(hand1.init_card)
hand1.draw(deck1)
len_dec_after = len(deck1.cards)
len_hand_after = len(hand1.init_card)
self.assertEqual(len_hand_before + 1, len_hand_after)
self.assertEqual(len_dec_after, len_deck_before - 1)
def testDraw(self):
d1 = hw5_cards_ec1.Deck()
h1 = hw5_cards_ec1.Hand()
d1_start_length = len(d1.cards)
h1_start_length = len(h1.cards)
h1.draw(d1)
d1_end_length = len(d1.cards)
h1_end_length = len(h1.cards)
start_cards = d1_start_length + h1_start_length
end_cards = d1_end_length + h1_end_length
self.assertEqual(start_cards,end_cards)
self.assertEqual(d1_start_length,d1_end_length+1)
self.assertEqual(h1_start_length,h1_end_length-1)
def test_q10(self):
'''
test that draw function functions as intended
'''
deck = hw5_cards_ec1.Deck()
hand = hw5_cards_ec1.Hand([])
self.assertEqual(hand.cards, [])
self.assertEqual(len(deck.cards), 52)
hand.draw(deck)
self.assertEqual(len(hand.cards), 1)
self.assertEqual(len(deck.cards), 51)
def test_draw(self):
c1 = hw5_cards_ec1.Card(0, 1)
c2 = hw5_cards_ec1.Card(0, 2)
d1 = hw5_cards_ec1.Deck()
d1.shuffle()
h1 = hw5_cards_ec1.Hand(d1.deal_hand(5))
self.assertEqual(len(h1.init_cards), 5)
self.assertEqual(len(d1.cards), 47)
h1.draw(d1)
self.assertEqual(len(h1.init_cards), 6)
self.assertEqual(len(d1.cards), 46)
h1.draw(d1)
self.assertEqual(len(h1.init_cards), 7)
self.assertEqual(len(d1.cards), 45)
def testAddAndRemove(self):
#test add
c1 = hw5_cards_ec1.Card(0, 1)
c2 = hw5_cards_ec1.Card(0, 2)
c3 = hw5_cards_ec1.Card(2, 13)
hand1 = [c1, c2]
hand2 = [c1, c2, c3]
h1 = hw5_cards_ec1.Hand(hand1)
#add existing card
h1.add_card(c1)
self.assertEqual(h1.init_cards, hw5_cards_ec1.Hand(hand1).init_cards)
#add other card
h1.add_card(c3)
self.assertEqual(h1.init_cards, hw5_cards_ec1.Hand(hand2).init_cards)
#test remove
#remove card in hand
h1.remove_card(c3)
self.assertEqual(len(h1.init_cards), 2)
self.assertEqual(h1.init_cards, hw5_cards_ec1.Hand(hand1).init_cards)
#remove card not in hand
h1.remove_card(c3)
self.assertEqual(len(h1.init_cards), 2)
self.assertEqual(h1.init_cards, hw5_cards_ec1.Hand(hand1).init_cards)
def test_draw(self):
'''
Test that draw( ) works as specified.
'''
d = hw5_cards_ec1.Deck() # Initialize a deck
h = hw5_cards_ec1.Hand([]) # Initialize a hand with no cards
h.draw(d) # Draw a card from the deck
self.assertEqual(len(h.init_cards), 1) # Check if one card is added
self.assertEqual(
len(d.cards), 51
) # Check if the number of cards in the deck has decreased by one (side effect)
self.assertTrue(
str(h.init_cards[0])
not in [str(card) for card in d.cards
]) # Check if the drawed card is not in the deck
def test_init(self):
init_cards = [
hw5_cards_ec1.Card(3, 12),
hw5_cards_ec1.Card(0, 13),
hw5_cards_ec1.Card(2, 6),
hw5_cards_ec1.Card(1, 5),
hw5_cards_ec1.Card(3, 3)
]
hand = hw5_cards_ec1.Hand(init_cards)
self.assertIsInstance(hand, hw5_cards_ec1.Hand)
self.assertIsInstance(hand.cards, list)
self.assertEqual(hand.cards[0].__str__(), "Queen of Spades")
self.assertEqual(hand.cards[1].__str__(), "King of Diamonds")
self.assertEqual(hand.cards[2].__str__(), "6 of Hearts")
self.assertEqual(hand.cards[3].__str__(), "5 of Clubs")
self.assertEqual(hand.cards[4].__str__(), "3 of Spades")
def test_construct_Card(self):
hand = []
for i in range(1, 4):
hand.append(hw5_cards_ec1.Card(0, i))
h1 = hw5_cards_ec1.Hand(hand)
self.assertEqual(h1.init_cards[0].suit, 0)
self.assertEqual(h1.init_cards[0].suit_name, "Diamonds")
self.assertEqual(h1.init_cards[0].rank, 1)
self.assertEqual(h1.init_cards[0].rank_name, "Ace")
self.assertEqual(h1.init_cards[1].suit, 0)
self.assertEqual(h1.init_cards[1].suit_name, "Diamonds")
self.assertEqual(h1.init_cards[1].rank, 2)
self.assertEqual(h1.init_cards[1].rank_name, "2")
self.assertEqual(h1.init_cards[2].suit, 0)
self.assertEqual(h1.init_cards[2].suit_name, "Diamonds")
self.assertEqual(h1.init_cards[2].rank, 3)
self.assertEqual(h1.init_cards[2].rank_name, "3")
def test2_AddAndRemove(self):
d = hw5_cards.Deck() # create a deck
d.shuffle() # shuffle the deck
hand_size = random.randint(1,51) # generate a random hand size
hand = d.deal_hand(hand_size) # create a temp hand list from deck also update the deck
h = hw5_cards_ec1.Hand(hand) # create hand object
num_cards_in_hand = len(h.cards) # how many cards in the hand now
c_new = d.deal_card() # create a card in the deck but not in the hand
c_old = h.cards[random.randint(0,len(h.cards)-1)] # create a card in the hand but not in the deck
h.add_card(c_old)
self.assertEqual(len(h.cards), num_cards_in_hand)
h.add_card(c_new)
self.assertEqual(len(h.cards), num_cards_in_hand+1)
h.remove_card(c_new)
self.assertEqual(len(h.cards), num_cards_in_hand)
h.remove_card(c_old)
self.assertEqual(len(h.cards), num_cards_in_hand-1)
def test_remove_card(self):
'''
Test that if you invoke the remove_card method on a Hand, the Hand has one fewer cards in it afterwards.
Test that if you invoke the remove_card method with a Hand that is not in the Hand, the Hand size is not affected.
'''
c1 = hw5_cards.Card(1, 1)
c2 = hw5_cards.Card(0, 2)
c3 = hw5_cards.Card(0, 2)
c4 = hw5_cards.Card(3, 3)
h1 = hw5_cards_ec1.Hand([c1, c2])
self.assertEqual(len(h1.init_cards), 2)
h1.remove_card(c3)
self.assertEqual(len(h1.init_cards), 1)
h1.remove_card(c4)
self.assertEqual(len(h1.init_cards), 1)
def test_add_card(self):
'''
Test that if you invoke the add_card method on a Hand, the Hand has one more cards in it afterwards.
Test that if you invoke the add_card method with a card that is already in the Hand, the Hand size is not affected.
'''
c1 = hw5_cards.Card(1, 1)
c2 = hw5_cards.Card(0, 2)
c3 = hw5_cards.Card(3, 3)
c4 = hw5_cards.Card(0, 2)
h1 = hw5_cards_ec1.Hand([c1, c2])
self.assertEqual(len(h1.init_cards), 2)
h1.add_card(c3)
self.assertEqual(len(h1.init_cards), 3)
h1.add_card(c4)
self.assertEqual(len(h1.init_cards), 3)
def test_draw(self):
deck = hw5_cards_ec1.Deck()
init_cards = [
hw5_cards_ec1.Card(3, 12),
hw5_cards_ec1.Card(0, 13),
hw5_cards_ec1.Card(2, 6),
hw5_cards_ec1.Card(1, 5),
hw5_cards_ec1.Card(3, 3)
]
hand = hw5_cards_ec1.Hand(init_cards)
# Remove the cards that are in hand from the deck
deck_str = []
for i in deck.cards:
deck_str.append(i.__str__())
hand_str = []
for i in hand.cards:
hand_str.append(i.__str__())
for i in hand_str:
for j in deck_str:
if j == i:
idx = deck_str.index(j)
deck.cards.pop(idx)
# Make sure the cards in hand and the deck cards are compensate with each other.
initial_deck_length = len(deck.cards)
initial_hand_length = len(hand.cards)
self.assertEqual(initial_deck_length + initial_hand_length,
52,
msg="Compensate pair")
# Make sure the draw function works
hand.draw(deck)
after_deck_length = len(deck.cards)
after_hand_length = len(hand.cards)
self.assertEqual(after_deck_length + after_hand_length,
52,
msg="Compensate pair")
self.assertEqual(after_deck_length,
initial_deck_length - 1,
msg="Remove one from deck")
self.assertEqual(after_hand_length,
initial_hand_length + 1,
msg="Add one to the hand")
def testAddAndRemove(self):
init_cards = [
hw5_cards_ec1.Card(3, 12),
hw5_cards_ec1.Card(0, 13),
hw5_cards_ec1.Card(2, 6),
hw5_cards_ec1.Card(1, 5),
hw5_cards_ec1.Card(3, 3)
]
hand = hw5_cards_ec1.Hand(
init_cards) #create a Hand object for convenience
handlength_0 = len(hand.cards)
#Add a card (invalid card, not adding anything)
hand.add_card(hw5_cards_ec1.Card(3, 12))
handlength_1 = len(hand.cards)
self.assertEqual(handlength_0,
handlength_1,
msg="Test adding a card when the card is in hand.")
#Add a card (valid card)
hand.add_card(hw5_cards_ec1.Card(0, 1))
handlength_2 = len(hand.cards)
self.assertEqual(
handlength_1 + 1,
handlength_2,
msg="Test adding a card when the card is not in hand.")
#Remove a card (valid card)
card_to_remove = hand.remove_card(hw5_cards_ec1.Card(0, 1))
handlength_3 = len(hand.cards)
self.assertEqual(handlength_2,
handlength_3 + 1,
msg="Test removing a card that is in hand")
self.assertEqual(card_to_remove.__str__(),
"Ace of Diamonds",
msg="Test the card that is removed is as specified")
#Remove a card (invalid card, not really removing anything)
card_to_remove2 = hand.remove_card(hw5_cards_ec1.Card(3, 8))
handlength_4 = len(hand.cards)
self.assertEqual(handlength_3,
handlength_4,
msg="Test removing a card that is not in hand.")
self.assertEqual(card_to_remove2, None)
def test_initialize_Hand(self):
'''
Test that a hand is initialized properly
'''
c1 = hw5_cards_ec1.Card(0, 2)
c2 = hw5_cards_ec1.Card(1, 1)
c3 = hw5_cards_ec1.Card(2, 12)
c4 = hw5_cards_ec1.Card(3, 6)
c5 = hw5_cards_ec1.Card(0, 13)
h = hw5_cards_ec1.Hand([c1, c2, c3, c4,
c5]) # Initialize a hand with five cards
self.assertIsInstance(h.init_cards,
list) # check the type of the Instance Attribute
self.assertEqual(len(h.init_cards), 5) # check the number of cards
self.assertEqual(type(h.init_cards[0]),
hw5_cards_ec1.Card) # check the type of the card
self.assertEqual(str(h.init_cards[1]),
str(c2)) # check if the card corresponds to the input
def testAddAndRemove(self):
cards_already_in_hands = \
[hw5_cards_ec1.Card(0, 1), hw5_cards_ec1.Card(1, 4), hw5_cards_ec1.Card(3, 11), hw5_cards_ec1.Card(3, 12)]
hand_1 = hw5_cards_ec1.Hand(cards_already_in_hands)
# test a card already in hand
card_in = hand_1.init_card[2]
initial_length = len(hand_1.init_card)
hand_1.add_card(card_in)
length_after_add = len(hand_1.init_card)
self.assertEqual(initial_length, length_after_add)
card_to_remove = hand_1.remove_card(card_in)
self.assertEqual(card_to_remove.__str__(), "Jack of Spades")
self.assertEqual(len(hand_1.init_card), length_after_add - 1)
# test a card not in hand
card_not_in = card_in # we've already removed it, so not in
response = hand_1.remove_card(card_not_in)
self.assertEqual(response, None)
current_length = len(hand_1.init_card)
hand_1.add_card(card_not_in)
self.assertEqual(len(hand_1.init_card), current_length + 1)
def test_draw(self):
# construct hand_1, instance of Hand
cards_already_in_hands = \
[hw5_cards_ec1.Card(0, 1), hw5_cards_ec1.Card(1, 4), hw5_cards_ec1.Card(3, 11), hw5_cards_ec1.Card(3, 12)]
hand_1 = hw5_cards_ec1.Hand(cards_already_in_hands)
# construct deck, instance of Deck
deck = hw5_cards_ec1.Deck()
# eliminate cards already in hand_1 from deck
deck_existing_card_str = []
for deck_card in deck.cards:
deck_existing_card_str.append(deck_card.__str__())
hand_existing_card_str = []
for hand_card in hand_1.init_card:
hand_existing_card_str.append(hand_card.__str__())
deck_str_to_use = []
for deck_card_str in deck_existing_card_str:
if deck_card_str not in hand_existing_card_str:
deck_str_to_use.append(deck_card_str)
deck_to_use = []
for deck_card in deck.cards:
if deck_card.__str__() in deck_str_to_use:
deck_to_use.append(deck_card)
deck.cards = deck_to_use
# test starts
current_len_hand_cards = len(hand_1.init_card)
current_len_deck_cards = len(deck.cards)
# make sure they compensate for each other
self.assertEqual(current_len_hand_cards + current_len_deck_cards, 52)
hand_1.draw(deck)
after_len_hand_cards = len(hand_1.init_card)
after_len_deck_cards = len(deck.cards)
self.assertEqual(after_len_hand_cards, current_len_hand_cards + 1)
self.assertEqual(after_len_deck_cards, current_len_deck_cards - 1)
def test_draw(self):
'''
Test that if you invoke the draw method from a deck and add it to the hand, the Hand has one more cards in it afterwards.
Test that if you invoke the draw method with a Hand that caused a side effect: the deck will be depleted by one card.
'''
c1 = hw5_cards.Card(1, 1)
c2 = hw5_cards.Card(0, 2)
d1 = hw5_cards.Deck()
h1 = hw5_cards_ec1.Hand([c1, c2])
self.assertEqual(len(h1.init_cards), 2)
self.assertEqual(len(d1.cards), 52)
h1.draw(d1)
self.assertEqual(len(h1.init_cards), 3)
self.assertEqual(len(d1.cards), 51)
d2 = hw5_cards.Deck()
self.assertEqual(len(d2.cards), 52)
for i in range(len(d2.cards)-1):
d2.cards.pop(-1)
h1.draw(d2)
self.assertEqual(len(h1.init_cards), 4)
self.assertEqual(len(d2.cards), 0)
def test_construct_Hand(self):
deck=hw5.Deck()
hand = ec1.Hand(deck.cards)
self.assertEqual(len(hand.init_card),52)
def test_construct_Hand(self):
c1 = hw5_cards.Card(1, 1)
c2 = hw5_cards.Card(0, 2)
h1 = hw5_cards_ec1.Hand([c1, c2])
self.assertIsInstance(h1.init_cards, list)
