class TestCardGame(unittest.TestCase):
def setUp(self):
self.h6 = Card('hearts', 6)
self.ace = Card('spades', 1)
self.hand = (self.h6, self.ace)
self.game = CardGame()
def test_card_has_suit(self):
self.assertEqual('hearts', self.h6.suit)
def test_card_has_value(self):
self.assertEqual(6, self.h6.value)
def test_check_for_ace_true(self):
result = self.game.check_for_ace(self.ace)
self.assertEqual(True, result)
def test_check_for_ace_false(self):
result = self.game.check_for_ace(self.h6)
self.assertEqual(False, result)
def test_highest_card_card1(self):
result = self.game.highest_card(self.h6, self.ace)
self.assertEqual(self.h6, result)
def test_highest_card_card2(self):
result = self.game.highest_card(self.ace, self.h6)
self.assertEqual(self.h6, result)
def test_cards_total(self):
result = self.game.cards_total(self.hand)
self.assertEqual("You have a total of 7", result)
class CardGameTest(unittest.TestCase):
def setUp(self):
self.card_ace = Card("Hearts", 1)
self.card_2 = Card("Hearts", 2)
self.card_3 = Card("Hearts", 2)
self.game_1 = CardGame()
def test_checkforAce_is_ace(self):
self.assertEqual(True, self.game_1.checkforAce(self.card_ace))
def test_checkforAce_isnt_ace(self):
self.assertEqual(False, self.game_1.checkforAce(self.card_2))
def test_highest_card_first_card(self):
self.assertEqual(self.card_2, self.game_1.highest_card(self.card_2, self.card_ace))
def test_highest_card_second_card(self):
self.assertEqual(self.card_2, self.game_1.highest_card(self.card_ace, self.card_2))
def test_cards_total_no_cards(self):
cards = []
self.assertEqual("You have a total of 0", self.game_1.cards_total(cards))
def test_cards_total_1_card(self):
cards = [self.card_2]
self.assertEqual("You have a total of 2", self.game_1.cards_total(cards))
def test_cards_toal_3_cards(self):
cards = [self.card_ace, self.card_2, self.card_3]
self.assertEqual("You have a total of 5", self.game_1.cards_total(cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card_1 = Card("hearts", 1)
self.card_2 = Card("clubs", 9)
self.game = CardGame()
def test_check_for_ace(self):
self.assertEqual(True, self.game.check_for_ace(self.card_1))
def test_check_for_ace_false(self):
self.assertEqual(False, self.game.check_for_ace(self.card_2))
def test_highest_card_first_card(self):
self.assertEqual(self.card_2,
self.game.highest_card(self.card_2, self.card_1))
def test_highest_card_second_card(self):
self.assertEqual(self.card_2,
self.game.highest_card(self.card_1, self.card_2))
def test_cards_total(self):
self.card_3 = Card("spades", 7)
self.cards = [self.card_1, self.card_2, self.card_3]
self.assertEqual("You have a total of 17",
self.game.cards_total(self.cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.game = CardGame()
self.card1 = Card("Diamonds", 10)
self.card2 = Card("Spades", 5)
self.card3 = Card("Hearts", 1)
self.cards = [self.card1, self.card2, self.card3]
def test_check_for_ace_true(self):
game1 = self.game.check_for_ace(self.card3)
self.assertEqual(True, game1)
def test_check_for_ace_false(self):
game2 = self.game.check_for_ace(self.card2)
self.assertEqual(False, game2)
def test_highest_card_card1_highest(self):
game3 = self.game.highest_card(self.card1, self.card2)
self.assertEqual(self.card1, game3)
def test_highest_card_card2_highest(self):
game4 = self.game.highest_card(self.card2, self.card1)
self.assertEqual(self.card1, game4)
def test_cards_total(self):
game5 = self.game.cards_total(self.cards)
self.assertEqual("You have a total of 16", game5)
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card1 = Card("Spades", 1)
self.card2 = Card("Jack", 2)
self.cards = [self.card1, self.card2]
self.cardgame = CardGame()
def test_check_for_ace__True(self):
self.assertEqual(True, self.cardgame.check_for_ace(self.card1))
def test_check_for_ace__False(self):
self.assertEqual(False, self.cardgame.check_for_ace(self.card2))
def test_highest_card__card2(self):
self.assertEqual(self.card2,
self.cardgame.highest_card(self.card1, self.card2))
def test_highest_card__card1(self):
self.card1 = Card("Queen", 5)
self.assertEqual(self.card1,
self.cardgame.highest_card(self.card1, self.card2))
def test_cards_total(self):
self.assertEqual("You have a total of 3",
self.cardgame.cards_total(self.cards))
class CardGameTest(unittest.TestCase):
def setUp(self):
self.card_game = CardGame()
def test_check_for_ace__false(self):
card = Card("Club", 3)
self.assertEqual(False, self.card_game.check_for_ace(card))
def test_check_for_ace__true(self):
card = Card("Heart", 1)
self.assertEqual(True, self.card_game.check_for_ace(card))
def test_highest_card__card1(self):
card1 = Card("Heart", 12)
card2 = Card("Diamond", 3)
self.assertEqual(card1, self.card_game.highest_card(card1, card2))
def test_highest_card__card2(self):
card1 = Card("Diamond", 6)
card2 = Card("Spade", 9)
self.assertEqual(card2, self.card_game.highest_card(card1, card2))
def test_cards_total(self):
card1 = Card("Diamond", 12)
card2 = Card("Diamond", 13)
card3 = Card("Diamond", 11)
cards = [card1, card2, card3]
self.assertEqual("You have a total of 36",
self.card_game.cards_total(cards))
class CardGameTest(unittest.TestCase):
def setUp(self):
self.game = CardGame()
def test_check_for_ace_true(self):
expected = True
card = Card("Hearts", 1)
actual = self.game.checkforAce(card)
self.assertEqual(expected, actual)
def test_check_for_ace_false(self):
expected = False
card = Card("Clubs", 4)
actual = self.game.checkforAce(card)
self.assertEqual(expected, actual)
def test_highest_card_is_card1(self):
card1 = Card("Clubs", 8)
card2 = Card("Spades", 3)
expected = card1
actual = self.game.highest_card(card1, card2)
self.assertEqual(expected, actual)
def test_highest_card_is_card_2(self):
card1 = Card("Hearts", 4)
card2 = Card("Diamonds", 7)
expected = card2
actual = self.game.highest_card(card1, card2)
self.assertEqual(expected, actual)
def test_highest_card__equal_card_values(self):
card1 = Card("Hearts", 9)
card2 = Card("Clubs", 9)
expected = card2
actual = self.game.highest_card(card1, card2)
self.assertEqual(expected, actual)
def test_cards_total(self):
card1 = Card("Spades", 7)
card2 = Card("Clubs", 3)
cards = [card1, card2]
expected = "You have a total of 10"
actual = self.game.cards_total(cards)
self.assertEqual(expected, actual)
def test_cards_total_many(self):
card1 = Card("Spades", 7)
card2 = Card("Clubs", 3)
card3 = Card("Hearts", 8)
card4 = Card("Diamonds", 10)
cards = [card1, card2, card3, card4]
expected = "You have a total of 28"
actual = self.game.cards_total(cards)
self.assertEqual(expected, actual)
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card1 = Card("Spades", 4)
self.card2 = Card("Clubs", 1)
self.card_game_01 = CardGame(self.card1, self.card2)
def test_game_has_card_01(self):
self.assertEqual(self.card1, self.card_game_01.card1)
def test_game_has_card_02(self):
self.assertEqual(self.card2, self.card_game_01.card2)
def test_can_check_for_ace_true(self):
result = self.card_game_01.check_for_ace(self.card2)
self.assertEqual(result, True)
def test_can_check_for_ace_false(self):
result = self.card_game_01.check_for_ace(self.card1)
self.assertEqual(result, False)
def test_can_find_highest_card(self):
result = self.card_game_01.highest_card(self.card1, self.card2)
self.assertEqual(result, self.card1)
def test_can_calculate_total(self):
cards = [self.card1, self.card2]
result = self.card_game_01.cards_total(cards)
self.assertEqual(result, "You have a total of 5")
class CardGameTest(unittest.TestCase):
def setUp(self):
self.card = Card("Spades", 1)
self.card_2 = Card("Hearts", 2)
self.cards = [self.card, self.card_2]
self.game = CardGame()
def test_check_for_ace_true(self):
actual = self.game.checkforAce(self.card)
self.assertTrue(actual)
def test_check_for_ace_false(self):
actual = self.game.checkforAce(self.card_2)
self.assertFalse(actual)
def test_card_2_is_higher_than_card_1_return_card_1(self):
expected = self.card_2
actual = self.game.highest_card(self.card_2, self.card)
self.assertEqual(expected, actual)
def test_card_has_total_of_2(self):
actual = self.game.cards_total(self.cards)
self.assertEqual("You have a total of 2", actual)
class CardGameTest(unittest.TestCase):
def test_checkforace(self):
self.card = Card('hearts', 1)
self.card2 = Card('spades', 12)
self.card_game = CardGame()
return_value = self.card_game.checkforace(self.card)
self.assertEqual(True, return_value)
return_value = self.card_game.checkforace(self.card2)
self.assertEqual(False, return_value)
def test_highest_card(self):
self.card1 = Card('hearts', 2)
self.card2 = Card('spades', 12)
self.card_game = CardGame()
return_value = self.card_game.highest_card(self.card1, self.card2)
self.assertEqual(self.card2, return_value)
def test_cards_total(self):
self.cards = [
Card('hearts', 2),
Card('spades', 12),
Card('diamond', 6),
Card('clubs', 3)
]
self.card_game = CardGame()
return_value = self.card_game.cards_total(self.cards)
self.assertEqual("You have a total of 23", return_value)
class TestCardGame(unittest.TestCase):
def setUp(self):
self.ace_spades = Card("spades", 1)
self.three_clubs = Card("clubs", 3)
self.nine_hearts = Card("hearts", 9)
self.cards = [
self.ace_spades,
self.three_clubs,
self.nine_hearts
]
self.card_game = CardGame()
def test_check_for_ace(self):
self.assertEqual(True, self.card_game.check_for_ace(self.ace_spades))
self.assertEqual(False, self.card_game.check_for_ace(self.three_clubs))
def test_highest_card(self):
self.assertEqual(self.nine_hearts, self.card_game.highest_card(self.three_clubs, self.nine_hearts))
self.assertEqual(self.nine_hearts, self.card_game.highest_card(self.nine_hearts, self.three_clubs))
def test_cards_total(self):
self.assertEqual("You have a total of 13", self.card_game.cards_total(self.cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card1 = Card("Hearts", 7)
self.card2 = Card("Clubs", 6)
self.card3 = Card("Spades", 4)
self.card4 = Card("Diamonds", 1)
self.cards = (self.card1, self.card2, self.card3)
def test_card_has_suit(self):
self.assertEqual("Hearts", self.card1.suit)
def card_has_value(self):
self.assertEqual(7, self.card1.value)
def test_check_for_ace(self):
self.card_game = CardGame()
self.assertEqual(1, self.card_game.check_for_ace(self.card4))
def test_highest_card(self):
self.card_game = CardGame()
self.assertEqual(self.card3,
self.card_game.highest_card(self.card3, self.card4))
def test_cards_total(self):
self.card_game = CardGame()
self.assertEqual("You have a total of 17",
self.card_game.cards_total(self.cards))
class CardGameTest(unittest.TestCase):
def setUp(self):
self.test_card1 = Card("Heart", 1)
self.test_card2 = Card("Diamonds", 10)
self.card_game = CardGame()
def test_card_has_suit(self):
self.assertEqual("Heart", self.test_card1.suit)
def test_card_has_value(self):
self.assertEqual(1, self.test_card1.value)
def test_check_for_ace(self):
self.assertEqual(True, self.card_game.check_for_ace(self.test_card1))
def test_highest_card(self):
self.assertEqual(
self.test_card2,
self.card_game.highest_card(self.test_card1, self.test_card2))
def test_cards_total(self):
card1 = Card("Diamonds", 2)
card2 = Card("Clubs", 4)
card3 = Card("hearts", 10)
cards = [card1, card2, card3]
self.assertEqual("You have a total of 16",
self.card_game.cards_total(cards))
class CardGameTest(unittest.TestCase):
def setUp(self):
self.card1 = Card("Hearts", 1)
self.card2 = Card("Hearts", 2)
self.card3 = Card("Spades", 2)
self.cards1 = [self.card1, self.card2, self.card3]
self.cards2 = [self.card1, self.card3]
self.game1 = CardGame()
#test card has suit
def test_card_has_suit(self):
self.assertEqual("Hearts", self.card1.suit)
#test card has value
def test_card_has_value(self):
self.assertEqual(1, self.card1.value)
#test check for ace true
def test_check_ace_returns_true(self):
output = self.game1.checkforAce(self.card1)
self.assertEqual(True, output)
# test card is not ace
def test_check_ace_returns_false(self):
output = self.game1.checkforAce(self.card2)
self.assertEqual(False, output)
# test for highest card is 2
def test_check_which_highest(self):
output = self.game1.highest_card(self.card2, self.card1)
self.assertEqual(2, output.value)
# test cards same value
def test_check_neither_highest(self):
output = self.game1.highest_card(self.card2, self.card3)
self.assertEqual(2, output.value)
# test total adds up to 5
def test_total_add_5(self):
output = self.game1.cards_total(self.cards1)
self.assertEqual("You have a total of 5", output)
# test total adds up to 3
def test_total_add_3(self):
output = self.game1.cards_total(self.cards2)
self.assertEqual("You have a total of 3", output)
class TestCardGame(unittest.TestCase):
# This is to setup countries for test
def setUp(self):
self.ace_of_spades = Card("spade", 1)
self.five_of_spades = Card("spade", 5)
self.six_of_spades = Card("spade", 6)
self.deck_of_cards = [self.ace_of_spades, self.five_of_spades, self.six_of_spades]
self.card_game = CardGame()
def test_check_for_ace(self):
self.assertTrue(self.card_game.check_for_ace(self.ace_of_spades))
self.assertFalse(self.card_game.check_for_ace(self.five_of_spades))
def test_highest_card(self):
self.highest_card = self.card_game.highest_card(self.five_of_spades, self.six_of_spades)
self.assertEqual(self.highest_card.value, 6)
self.highest_card = self.card_game.highest_card(self.six_of_spades, self.five_of_spades)
self.assertEqual(self.highest_card.value, 6)
def test_cards_total(self):
self.assertEqual(self.card_game.cards_total(self.deck_of_cards),"You have a total of 12")
class TestCardGame(unittest.TestCase):
def setUp(self):
self.cardgame = CardGame()
self.card1 = Card("Spades", 2)
self.card2 = Card("Hearts", 6)
self.card3 = Card("Clubs", 9)
self.cards = [self.card1, self.card2, self.card3]
def test_check_for_ace(self):
self.assertEqual(False, self.cardgame.check_for_ace(self.card1))
def test_highest_card(self):
self.assertEqual(self.card2,
self.cardgame.highest_card(self.card1, self.card2))
self.assertEqual(self.card3,
self.cardgame.highest_card(self.card3, self.card2))
self.assertEqual(self.card3,
self.cardgame.highest_card(self.card1, self.card3))
def test_cards_total(self):
self.assertEqual("You have a total of 17",
self.cardgame.cards_total(self.cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.cardgame = CardGame()
self.card1 = Card("Spades", 9)
self.card2 = Card("Diamonds", 10)
self.card3 = Card("Hearts", 7)
self.cards = [self.card_1, self.card_2]
def test_check_for_ace_true (self):
self.assertEqual (True, self.cardgame.check_for_ace(self.card_1))
def test_check_for_ace_false (self):
self.assertEqual (False, self.cardgame.check_for_ace(self.card_2))
def test_highest_card_returns_higher_value_card (self):
self.assertEqual (self.card_2, self.cardgame.highest_card(self.card_1, self.card_2))
self.assertEqual (self.card_3, self.cardgame.highest_card(self.card_3, self.card_2))
self.assertEqual (self.card_3, self.cardgame.highest_card(self.card_1, self.card_3))
def test_cards_total (self):
self.assertEqual ("You have a total of 26", self.cardgame.cards_total(self.cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card_game_1 = CardGame()
self.card1 = Card('diamonds', 1)
self.card2 = Card('spades', 10)
def test_check_is_ace(self):
self.assertEqual(True, self.card_game_1.check_for_ace(self.card1))
def test_check_is_not_ace(self):
self.assertEqual(False, self.card_game_1.check_for_ace(self.card2))
def test_check_highest_card(self):
self.assertEqual(self.card2,
self.card_game_1.highest_card(self.card1, self.card2))
def test_check_highest_card_other_way_round(self):
self.assertEqual(self.card2,
self.card_game_1.highest_card(self.card2, self.card1))
def test_card_total(self):
self.assertEqual(
"You have a total of 11",
self.card_game_1.cards_total([self.card1, self.card2]))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card_game = CardGame()
self.card = Card("hearts", 1)
self.card_1 = Card("spades", 10)
def test_check_for_ace(self):
self.assertEqual(True, self.card_game.check_for_ace(self.card))
def test_highest_card(self):
self.assertEqual(self.card_1, self.card_game.highest_card(self.card, self.card_1))
def test_cards_total(self):
cards = [self.card, self.card_1]
self.assertEqual("You have a total of11", self.card_game.cards_total(cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.game = CardGame("Game 1")
self.card1 = Card("Spades", 1)
self.card2 = Card("Hearts", 8)
def test_has_ace(self):
self.assertEqual(True, self.game.check_for_ace(self.card1))
def test_highest_card(self):
self.assertEqual(str(self.card2),
self.game.highest_card(self.card1, self.card2))
def test_cards_total(self):
cards = [self.card1, self.card2]
self.assertEqual("You have a total of 9", self.game.cards_total(cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card1 = Card("Hearts", 10)
self.card2 = Card("Spades", 1)
self.cardGame = CardGame()
self.cards = [self.card1, self.card2]
def test_check_for_ace(self):
self.assertEqual(True, self.cardGame.check_for_ace(self.card2))
def test_highest_card(self):
self.assertEqual(self.card1,
self.cardGame.highest_card(self.card1, self.card2))
def test_cards_total(self):
self.assertEqual("You have a total of 11",
self.cardGame.cards_total(self.cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card_1 = Card("Spades", 1)
self.card_2 = Card("Diamonds", 7)
self.card_game = CardGame(self.card_1, self.card_2)
self.cards = [self.card_1, self.card_2]
def test_check_for_ace(self):
self.assertEqual(True,
self.card_game.check_for_ace(self.card_game.card1))
def test_highest_card(self):
result = self.card_game.highest_card(self.card_1, self.card_2)
self.assertEqual(7, result)
def test_cards_total(self):
result = self.card_game.cards_total(self.cards)
self.assertEqual("You have a total of 8", result)
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card1 = Card('Hearts', 5)
self.card2 = Card('Diamonds', 1)
self.cards = [self.card1, self.card2]
self.game = CardGame()
def test_check_for_ace(self):
self.assertEqual(True, self.game.check_for_ace(self.card2))
def test_highest_card(self):
self.assertEqual(self.card1,
self.game.highest_card(self.card1, self.card2))
def test_cards_total(self):
self.assertEqual('You have a total of 6',
self.game.cards_total(self.cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card_game = CardGame()
self.card_1 = Card("heart", 1)
self.card_2 = Card("heart", 2)
self.card_3 = Card("heart", 3)
self.cards = [self.card_1, self.card_2, self.card_3]
def test_check_for_ace(self):
self.assertEqual(True, self.card_game.check_for_ace(self.card_1))
def test_highest_card(self):
self.assertEqual(self.card_3,
self.card_game.highest_card(self.card_2, self.card_3))
def test_cards_total(self):
self.assertEqual("You have a total of 6",
self.card_game.cards_total(self.cards))
class CardGameTest(unittest.TestCase):
def setUp(self):
self.cardgame = CardGame()
self.card = Card("Hearts", 1)
self.card1 = Card("Clubs", 6)
self.card2 = Card("Hearts", 5)
self.card3 = Card("Spades", 8)
self.cards = [self.card1, self.card2, self.card3]
def test_check_for_ace(self):
self.assertEqual(True, self.cardgame.check_for_ace(self.card))
def test_check_for_highest_card(self):
self.assertEqual(6, self.cardgame.highest_card(self.card1, self.card2))
def test_for_cards_total(self):
self.assertEqual("You have a total of 19",
self.cardgame.cards_total(self.cards))
class card_gameTest(unittest.TestCase):
def setUp(self):
self.cardGame = CardGame()
self.first_card = Card("ace", 1)
self.second_card = Card("clubs", 3)
self.cards = [self.first_card, self.second_card]
def test_check_for_ace(self):
self.assertEqual(True, self.cardGame.check_for_ace(self.first_card))
def test_highest_card(self):
self.assertEqual(
"clubs",
self.cardGame.highest_card(self.first_card, self.second_card).suit)
def test_cards_total(self):
self.assertEqual("You have a total of4",
self.cardGame.cards_total(self.cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card1 = Card("spades", 1)
self.card2 = Card("clubs", 5)
self.cardgame1 = CardGame()
self.cards = [self.card1, self.card2]
def test_for_ace(self):
self.assertEqual(True, self.cardgame1.check_for_ace(self.card1))
def test_for_not_ace(self):
self.assertEqual(False, self.cardgame1.check_for_ace(self.card2))
def test_for_highest_card(self):
self.assertEqual(self.card2, self.cardgame1.highest_card(self.card1, self.card2))
def test_cards_total(self):
self.assertEqual("You have a total of 6", self.cardgame1.cards_total(self.cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card = Card("spade", 5)
self.card1 = Card("heart", 9)
self.card2 = Card("diamond", 2)
self.cards = [self.card1, self.card2]
self.cardgame = CardGame(self.card)
def test_check_for_ace(self):
result = self.cardgame.check_for_ace(self.card)
self.assertEqual(False, result)
def test_highest_card(self):
result = self.cardgame.highest_card(self.card1, self.card2)
self.assertEqual(9, result.value)
def test_cards_total(self):
result = self.cardgame.cards_total(self.cards)
self.assertEqual("You have a total of11", result)
class TestCardGame(unittest.TestCase):
def setUp(self):
self.game = CardGame()
def test_check_for_ace(self):
new_card = Card("Clubs", 1)
self.assertEqual(True, self.game.check_for_ace(new_card))
def test_highest_card(self):
card1 = Card("Hearts", 4)
card2 = Card("Spades", 10)
self.assertEqual(card2, self.game.highest_card(card1, card2))
def test_cards_total(self):
card1 = Card("Hearts", 4)
card2 = Card("Spades", 10)
cards = [card1, card2]
self.assertEqual("You have a total of 14",
self.game.cards_total(cards))
class TestCardGame(unittest.TestCase):
def setUp(self):
self.card1 = Card("Clubs", 1)
self.card2 = Card("Clubs", 2)
self.card3 = Card("Spades", 9)
self.card4 = Card("Diamonds", 10)
self.card_game1 = CardGame([self.card1])
self.card_game2 = CardGame([self.card2])
self.card_game3 = CardGame([self.card3, self.card4])
self.card_game4 = CardGame([self.card1, self.card2])
def test_card_has_value(self):
self.assertEqual(2, self.card2.value)
def test_card_has_suit(self):
self.assertEqual("Clubs", self.card1.suit)
def test_card_game_has_cardlist(self):
self.assertEqual([], self.card_game1.cardlist)
self.assertEqual([], self.card_game3.cardlist)
def test_check_for_ace(self):
# result = self.card_game2.check_for_ace(self.card_game2.cardlist[0].value)
# self.assertEqual(False, result)
result = self.card_game1.check_for_ace(self.card1)
result2 = self.card_game2.check_for_ace(self.card2)
result3 = self.card_game1.check_for_ace(self.card2)
result4 = self.card_game2.check_for_ace(self.card1)
self.assertEqual(True, result)
self.assertEqual(False, result2)
self.assertEqual(False, result3)
self.assertEqual(True, result4)
def test_highest_card(self):
result = self.card_game3.highest_card(self.card3, self.card4)
self.assertEqual(self.card4, result)
def test_cards_total(self):
result = self.card_game3.cards_total([self.card4, self.card3])
result2 = self.card_game4.cards_total([self.card1, self.card2])
self.assertEqual(19, result)
self.assertEqual(3, result2)
