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 test_q7(self): ''' 1. fill in your test method for question 7: Test that if you invoke the replace_card method, the deck has one more card in it afterwards. (Please note that you want to use deal_card function first to remove a card from the deck and then add the same card back in) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' q7 = hw5_cards.Deck() q71 = hw5_cards.Deck( ) # create this to match the autograder expected output q7.deal_card( ) # deal_card() will remote the card from q7, and return the removed card (3,13) q71.deal_card( ) # q71 is used to test after deal function, the length of q71 should be 51 not 52 q7.replace_card( hw5_cards.Card(3, 13) ) # use hw5_cards.Card(3,13) to add back the one being pop out which is King of Spades (3,13) self.assertEqual( len(q7.cards), 52 ) #q7 is the list after pop function and replace function >> length should be 52 self.assertNotEqual( len(q7.cards), 53 ) #q7 is the list after pop function and replace function >> length should be 52 return len(q71.cards) + 1, len( q7.cards ), 52 # q71 is used to test the length after deal, q7 is the length after deal and replace
def test_q4(self): ''' 1. fill in your test method for question 4: Test that if you create a eck instance, it will have 52 cards in its cards instance variable 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' self.assertEqual(len(hw5_cards.Deck().cards),52) return len(hw5_cards.Deck().cards),52
def test_q5(self): ''' 1. fill in your test method for question 5: Test that if you invoke the deal_card method on a deck, it will return a card instance. 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' self.assertIsInstance(hw5_cards.Deck().deal_card(),hw5_cards.Card) return hw5_cards.Deck().deal_card(),hw5_cards.Card
def test_q7(self): ''' 1. fill in your test method for question 7: Test that if you invoke the replace_card method, the deck has one more card in it afterwards. (Please note that you want to use deal_card function first to remove a card from the deck and then add the same card back in) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' c_test_q7_1 = hw5_cards.Deck() self.assertEqual(len(c_test_q7_1.cards), 52) card0 = c_test_q7_1.deal_card() self.assertEqual(len(c_test_q7_1.cards), 51) X = len(c_test_q7_1.cards) + 1 c_test_q7_1.replace_card(card0) self.assertEqual(len(c_test_q7_1.cards), 52) Y = len(c_test_q7_1.cards) Z = 52 card1 = c_test_q7_1.deal_card() card2 = c_test_q7_1.deal_card() self.assertEqual(len(c_test_q7_1.cards), 50) c_test_q7_1.replace_card(card1) c_test_q7_1.replace_card(card2) self.assertEqual(len(c_test_q7_1.cards), 52) return X, Y, Z
def test_q8(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' q8 = hw5_cards.Deck() randomNumber = random.randint(1,len(q8.cards)) new_card = q8.cards[randomNumber] temp = q8.cards.copy() q8.replace_card(new_card) #print("pop cards : " + str(new_card)) #print("pre cards : " + str(len(temp))) #print("now cards : " + str(len(q8.cards))) self.assertEqual(len(q8.cards), len(temp)) return len(q8.cards), len(temp)
def test_q6(self): ''' 1. fill in your test method for question 6: Test that if you invoke the deal_card method on a deck, the deck has one fewer cards in it afterwards. 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' q6 = hw5_cards.Deck() q6_cards = q6.cards.copy() #list可以算len q6.deal_card() nq6_cards = q6.cards self.assertEqual(len(q6_cards)-1,len(nq6_cards)) self.assertNotEqual(len(q6_cards), len(nq6_cards)) self.assertTrue(len(q6_cards) != len(nq6_cards)) self.assertFalse(len(q6_cards) == len(nq6_cards)) self.assertEqual(len(q6_cards)-1 , len(nq6_cards)) self.assertNotEqual(len(q6_cards), len(nq6_cards)) return len(q6_cards)-1, len(nq6_cards)
def test_q8(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' test_deck = hw5_cards.Deck() num_card1 = len(test_deck.cards) test_card = hw5_cards.Card(suit=3, rank=13) test_deck.replace_card(test_card) num_card2 = len(test_deck.cards) X = num_card2 - num_card1 Y = 0 self.assertEqual(X, Y) return X, Y
def test_q7(self): ''' 1. fill in your test method for question 7: Test that if you invoke the replace_card method, the deck has one more card in it afterwards. (Please note that you want to use deal_card function first to remove a card from the deck and then add the same card back in) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' test_deck = hw5_cards.Deck() tmp_card = test_deck.deal_card() card_num1 = len(test_deck.cards) test_deck.replace_card(tmp_card) card_num2 = len(test_deck.cards) X = card_num2 - card_num1 Y = 1 self.assertEqual(X, Y) return X, Y
def test_q8(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' suit = random.randint(0, 3) rank = random.randint(1, 13) c = hw5_cards.Deck() len_before = len(c.cards) card = hw5_cards.Card(suit, rank) c.replace_card(card) len_after = len(c.cards) self.assertEqual(len_before, len_after) X = len_before Y = len_after return X, Y
def test_q8(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' #creating Deck instance c10 = hw5_cards.Deck() #deal one card from the card and store the card properties card = c10.deal_card() #deal another card from the card and store the card properties #card2 = c10.deal_card() #check the length of deck with 2 cards dealt deal_len = len(c10.cards) #replace a card into the deck c10.replace_card(card) #try to replace same card into deck c10.replace_card(card) #check length of deck after two replace attempts replace_len = len(c10.cards) #compare the two lengths to make sure that #it ignores the attempt if the same card is tried self.assertEqual(replace_len, deal_len + 1) return replace_len, deal_len + 1
def test_q8_alt(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' q8 = hw5_cards.Deck() q8.deal_card() newDeck = q8.cards newDeckCount = len(newDeck) # Attempt to replace with card already in newDeck for c in newDeck: q8.replace_card(c) finalDeckCount = len(q8.cards) # Test that 'replace_card' method did not change deck size # if the card is already in the deck self.assertEqual(newDeckCount, finalDeckCount) return newDeckCount, finalDeckCount
def test_q7(self): ''' 1. fill in your test method for question 7: Test that if you invoke the replace_card method, the deck has one more card in it afterwards. (Please note that you want to use deal_card function first to remove a card from the deck and then add the same card back in) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' #creating Deck instance c9 = hw5_cards.Deck() #dealing card and capturing instance card = c9.deal_card() #checking length of deck after dealing card deal_len = len(c9.cards) #replacing card back into deck c9.replace_card(card) #checking length of deck with card replaced replace_len = len(c9.cards) #comparing length of card before and after replacing self.assertEqual(replace_len, deal_len + 1) return replace_len, deal_len + 1
def test_q8(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' cards = [] d5 = hw5_cards.Deck() d5_old = len(d5.cards) for card in d5.cards: cards.append(card.__str__()) if card.__str__() not in cards: d5.replace_card(card) else: pass d5_new = len(d5.cards) self.assertEqual(d5_old, d5_new) return d5_old, d5_new
def test_q7(self): ''' 1. fill in your test method for question 7: Test that if you invoke the replace_card method, the deck has one more card in it afterwards. (Please note that you want to use deal_card function first to remove a card from the deck and then add the same card back in) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' q7 = hw5_cards.Deck() dealt_card = q7.deal_card() deckInitialCount = len(q7.cards) # Replace with same card dealt q7.replace_card(dealt_card) deckEndCount = len(q7.cards) # Testing that that end count is one greater than the initial # Expected count value is '52' self.assertEqual((deckInitialCount + 1), deckEndCount, 52) return (deckInitialCount + 1), deckEndCount, 52
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_q6(self): ''' 1. fill in your test method for question 6: Test that if you invoke the deal_card method on a deck, the deck has one fewer cards in it afterwards. 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' deck = hw5_cards.Deck().cards new_deck = hw5_cards.Deck() new_deck.deal_card() newdeck = new_deck.cards self.assertEqual(len(newdeck),len(deck)-1) return len(newdeck),len(deck)-1
def test_q8(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' d_original = hw5_cards.Deck() d1 = hw5_cards.Deck() c1 = hw5_cards.Card(0, 12) d1.replace_card(c1) self.assertEqual(len(d1.cards), len(d_original.cards)) return len(d1.cards), len(d_original.cards)
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 test_q7(self): ''' 1. fill in your test method for question 7: Test that if you invoke the replace_card method, the deck has one more card in it afterwards. (Please note that you want to use deal_card function first to remove a card from the deck and then add the same card back in) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' d_original = hw5_cards.Deck() d1 = hw5_cards.Deck() card_dealt = d1.deal_card() d2 = d1 d3 = len(d2.cards) d2.replace_card(card_dealt) self.assertEqual(len(d2.cards), len(d_original.cards), d3 + 1) return len(d2.cards), len(d_original.cards), d3 + 1
def test_q6(self): ''' 1. fill in your test method for question 6: Test that if you invoke the deal_card method on a deck, the deck has one fewer cards in it afterwards. 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' #creating Deck instance c7 = hw5_cards.Deck() #dealing out one card c7.deal_card() #creating Deck instance c8 = hw5_cards.Deck() #comparing two instances one with card dealt(c7) and one without (c8) self.assertEqual(len(c8.cards) - 1, len(c7.cards)) return len(c8.cards) - 1, len(c7.cards)
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 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_q6(self): ''' 1. fill in your test method for question 6: Test that if you invoke the deal_card method on a deck, the deck has one fewer cards in it afterwards. 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' d1 = hw5_cards.Deck() num1 = len(d1.cards) # number of cards before deal_card d2 = d1.deal_card() num2 = len(d1.cards) # number of cards after deal_card self.assertEqual(num1 - 1, num2) return (num1 - 1, num2)
def test_q6(self): ''' 1. fill in your test method for question 6: Test that if you invoke the deal_card method on a deck, the deck has one fewer cards in it afterwards. 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' q6 = hw5_cards.Deck() original_length = len(q6.cards) q6.deal_card() current_length = len(q6.cards) self.assertEqual((original_length, current_length), (52, 51)) return current_length, 51
def test_q6(self): ''' 1. fill in your test method for question 6: Test that if you invoke the deal_card method on a deck, the deck has one fewer cards in it afterwards. 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' q6 = hw5_cards.Deck() q61 = q6.deal_card( ) # deal_card() will remote the card from q6, and return the removed card self.assertEqual(len(q6.cards), 51) #q6 is the list after the pop function return len(q6.cards), 51
def test_q8(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' deck = hw5_cards.Deck() card = hw5_cards.Card( ) # card to be added, which is already in the deck num_cards = len(deck.cards) # number of cards after deal card deck.replace_card(card) # try to add the card self.assertEqual(num_cards, len(deck.cards))
def test_q8(self): ''' 1. fill in your test method for question 8: Test that if you invoke the replace_card method with a card that is already in the deck, the deck size is not affected.(The function must silently ignore it if you try to add a card that’s already in the deck) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' test_deck = hw5_cards.Deck() card_already_exist = test_deck.cards[random.randint(0, 51)] current_size = len(test_deck.cards) test_deck.replace_card(card_already_exist) after_replace_size = len(test_deck.cards) self.assertEqual(current_size, after_replace_size) return current_size, after_replace_size
def test_q7(self): ''' 1. fill in your test method for question 7: Test that if you invoke the replace_card method, the deck has one more card in it afterwards. (Please note that you want to use deal_card function first to remove a card from the deck and then add the same card back in) 2. remove the pass command 3. uncomment the return command and 3b. change X, Y to the values from your assert statement ### please note: normally unit test methods do not have return statements. But returning will allow for unit testing of your unit test, and allow you to check your answer with the autograder. This is optional today. ''' d1 = hw5_cards.Deck() c1 = d1.deal_card(-4) num1 = len(d1.cards) # number of cards before replace_card d1.replace_card(c1) num2 = len(d1.cards) # number of cards after replace_card self.assertEqual(num2, num1 + 1) return (num2, num1 + 1)