haiyingjiang7/poker_task1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

task1

Browse Source
This commit is contained in:
haiyingjiang7@1price.io
2025-09-23 11:11:47 +08:00
parent 674a7b16b7
commit 45f86ba95e
11 changed files with 121 additions and 377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
tests/test_card.py
View File

@@ -5,37 +5,19 @@ Tests for Card, Rank, and Suit classes
import pytest
from poker.card import Card, Rank, Suit
# card.py测试
class TestRank:
"""Test cases for Rank enum"""
def test_rank_values(self):
"""Test rank numeric values"""
assert Rank.TWO.numeric_value == 2
assert Rank.ACE.numeric_value == 14
assert Rank.KING.numeric_value == 13
assert Rank.JACK.numeric_value == 11
def test_rank_symbols(self):
"""Test rank symbols"""
assert Rank.TWO.symbol == '2'
assert Rank.ACE.symbol == 'A'
assert Rank.KING.symbol == 'K'
assert Rank.TEN.symbol == 'T'
def test_rank_comparison(self):
"""Test rank comparison operations"""
assert Rank.TWO < Rank.THREE
assert Rank.KING < Rank.ACE
assert Rank.JACK > Rank.TEN
assert Rank.ACE >= Rank.KING
assert Rank.TWO <= Rank.TWO
def test_rank_str(self):
"""Test string representation"""
assert str(Rank.ACE) == 'A'
assert str(Rank.KING) == 'K'
assert str(Rank.TWO) == '2'
class TestSuit:
@@ -47,11 +29,7 @@ class TestSuit:
assert Suit.HEARTS.value == 'h'
assert Suit.DIAMONDS.value == 'd'
assert Suit.CLUBS.value == 'c'
def test_suit_str(self):
"""Test string representation"""
assert str(Suit.SPADES) == 's'
assert str(Suit.HEARTS) == 'h'
class TestCard:
@@ -71,60 +49,42 @@ class TestCard:
card2 = Card(Rank.KING, Suit.HEARTS)
assert str(card2) == 'Kh'
def test_card_equality(self):
"""Test card equality"""
card1 = Card(Rank.ACE, Suit.SPADES)
card2 = Card(Rank.ACE, Suit.SPADES)
card3 = Card(Rank.ACE, Suit.HEARTS)
assert card1 == card2
assert card1 != card3
def test_card_comparison(self):
"""Test card comparison (by rank)"""
ace_spades = Card(Rank.ACE, Suit.SPADES)
king_hearts = Card(Rank.KING, Suit.HEARTS)
two_clubs = Card(Rank.TWO, Suit.CLUBS)
assert two_clubs < king_hearts
assert king_hearts < ace_spades
assert not (ace_spades < king_hearts)
def test_from_string_valid(self):
"""Test creating card from valid string"""
card = Card.from_string("As")
card = Card.createCard("As")
assert card.rank == Rank.ACE
assert card.suit == Suit.SPADES
card2 = Card.from_string("Kh")
card2 = Card.createCard("Kh")
assert card2.rank == Rank.KING
assert card2.suit == Suit.HEARTS
card3 = Card.from_string("2c")
card3 = Card.createCard("2c")
assert card3.rank == Rank.TWO
assert card3.suit == Suit.CLUBS
card4 = Card.from_string("Td")
card4 = Card.createCard("Td")
assert card4.rank == Rank.TEN
assert card4.suit == Suit.DIAMONDS
def test_from_string_invalid(self):
"""Test creating card from invalid string"""
with pytest.raises(ValueError):
Card.from_string("A") # Too short
Card.createCard("A") # Too short
with pytest.raises(ValueError):
Card.from_string("Asx") # Too long
Card.createCard("Asx") # Too long
with pytest.raises(ValueError):
Card.from_string("Xs") # Invalid rank
Card.createCard("Xs") # Invalid rank
with pytest.raises(ValueError):
Card.from_string("Ax") # Invalid suit
Card.createCard("Ax") # Invalid suit
def test_parse_cards_valid(self):
"""Test parsing multiple cards from string"""
cards = Card.parse_cards("AsKs AhAdAc6s7s")
cards = Card.parseCards("AsKs AhAdAc6s7s")
assert len(cards) == 7
assert str(cards[0]) == "As"
assert str(cards[1]) == "Ks"
@@ -133,23 +93,23 @@ class TestCard:
def test_parse_cards_with_spaces(self):
"""Test parsing cards with various spacing"""
cards = Card.parse_cards("As Ks Ah Ad Ac 6s 7s")
cards = Card.parseCards("As Ks Ah Ad Ac 6s 7s")
assert len(cards) == 7
assert str(cards[0]) == "As"
assert str(cards[6]) == "7s"
def test_parse_cards_empty(self):
"""Test parsing empty string"""
cards = Card.parse_cards("")
cards = Card.parseCards("")
assert len(cards) == 0
cards = Card.parse_cards(" ")
cards = Card.parseCards(" ")
assert len(cards) == 0
def test_parse_cards_invalid(self):
"""Test parsing invalid card strings"""
with pytest.raises(ValueError):
Card.parse_cards("AsKs A") # Incomplete card
Card.parseCards("AsKs A") # Incomplete card
with pytest.raises(ValueError):
Card.parse_cards("AsKs Ax") # Invalid suit
Card.parseCards("AsKs Ax") # Invalid suit

41
tests/test_hand_evaluator.py
View File

@@ -14,7 +14,7 @@ class TestHandEvaluator:
def test_royal_flush(self):
"""Test royal flush detection"""
cards_str = "AhKhQhJhTh2c3c"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.ROYAL_FLUSH
assert str(ranking) == "Royal Flush"
@@ -22,7 +22,7 @@ class TestHandEvaluator:
def test_straight_flush(self):
"""Test straight flush detection"""
cards_str = "2h3h4h5h6h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.STRAIGHT_FLUSH
assert str(ranking) == "Straight Flush(6 high)"
@@ -30,7 +30,7 @@ class TestHandEvaluator:
def test_four_of_a_kind(self):
"""Test four of a kind detection"""
cards_str = "AsKs AhAdAc6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.FOUR_OF_A_KIND
assert str(ranking) == "Quad(A)"
@@ -38,7 +38,7 @@ class TestHandEvaluator:
def test_full_house(self):
"""Test full house detection"""
cards_str = "AsAhAd KsKh6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.FULL_HOUSE
assert "Full House(A over K)" in str(ranking)
@@ -46,7 +46,7 @@ class TestHandEvaluator:
def test_flush(self):
"""Test flush detection"""
cards_str = "AhKh6h4h2h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.FLUSH
assert "Flush(A high)" in str(ranking)
@@ -54,7 +54,7 @@ class TestHandEvaluator:
def test_straight(self):
"""Test straight detection"""
cards_str = "As2h3d4c5h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
assert str(ranking) == "Straight(5 high)" # A-2-3-4-5 wheel
@@ -62,7 +62,7 @@ class TestHandEvaluator:
def test_straight_ace_high(self):
"""Test straight with ace high"""
cards_str = "AsTsJhQdKh7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
assert str(ranking) == "Straight(A high)"
@@ -70,7 +70,7 @@ class TestHandEvaluator:
def test_three_of_a_kind(self):
"""Test three of a kind detection"""
cards_str = "AsAhAd6s7h8s9s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.THREE_OF_A_KIND
assert str(ranking) == "Three of a Kind(A)"
@@ -78,7 +78,7 @@ class TestHandEvaluator:
def test_two_pair(self):
"""Test two pair detection"""
cards_str = "AsAh6d6s7h8s9s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.TWO_PAIR
assert "Two Pair(A and 6)" in str(ranking)
@@ -86,7 +86,7 @@ class TestHandEvaluator:
def test_one_pair(self):
"""Test one pair detection"""
cards_str = "AsAh6d4s2h3cJd"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.ONE_PAIR
assert str(ranking) == "Pair(A)"
@@ -94,7 +94,7 @@ class TestHandEvaluator:
def test_high_card(self):
"""Test high card detection"""
cards_str = "As6h4d8s9hJdKc"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.HIGH_CARD
assert str(ranking) == "High Card(A)"
@@ -102,7 +102,7 @@ class TestHandEvaluator:
def test_wheel_straight(self):
"""Test A-2-3-4-5 straight (wheel)"""
cards_str = "As2h3d4c5h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
assert ranking.key_ranks[0] == Rank.FIVE # 5 is high in wheel
@@ -110,21 +110,21 @@ class TestHandEvaluator:
def test_invalid_input_not_seven_cards(self):
"""Test error handling for wrong number of cards"""
with pytest.raises(ValueError):
HandEvaluator.evaluate_from_input("AsKh")
HandEvaluator.evaluateFromInput("AsKh")
with pytest.raises(ValueError):
HandEvaluator.evaluate_from_input("AsKhQdJc9h8s7d6c")
HandEvaluator.evaluateFromInput("AsKhQdJc9h8s7d6c")
def test_invalid_card_format(self):
"""Test error handling for invalid card format"""
with pytest.raises(ValueError):
HandEvaluator.evaluate_from_input("AsKhQdJcXh8s7d")
HandEvaluator.evaluateFromInput("AsKhQdJcXh8s7d")
def test_seven_cards_best_five_selected(self):
"""Test that best 5 cards are selected from 7"""
# Should pick the straight flush over the pair
cards_str = "2h3h4h5h6hAsAd"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.STRAIGHT_FLUSH
assert str(ranking) == "Straight Flush(6 high)"
@@ -132,7 +132,7 @@ class TestHandEvaluator:
def test_multiple_possible_straights(self):
"""Test selecting highest straight from multiple possibilities"""
cards_str = "As2h3d4c5h6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
# Should pick 3-4-5-6-7 over A-2-3-4-5
@@ -141,7 +141,7 @@ class TestHandEvaluator:
def test_multiple_possible_flushes(self):
"""Test selecting best flush from multiple suits"""
cards_str = "AhKh6h4h2h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert ranking.hand_type == HandType.FLUSH
assert ranking.key_ranks[0] == Rank.ACE
@@ -150,12 +150,11 @@ class TestHandEvaluator:
"""Test evaluating exactly 5 cards"""
cards = [
Card(Rank.ACE, Suit.SPADES),
Card(Rank.ACE, Suit.HEARTS),
Card(Rank.ACE, Suit.HEARTS),
Card(Rank.ACE, Suit.DIAMONDS),
Card(Rank.ACE, Suit.CLUBS),
Card(Rank.KING, Suit.SPADES)
]
ranking = HandEvaluator._evaluate_five_cards(cards)
ranking = HandEvaluator.evaluate5Cards(cards)
assert ranking.hand_type == HandType.FOUR_OF_A_KIND
assert ranking.key_ranks[0] == Rank.ACE

33
tests/test_hand_ranking.py
View File

@@ -90,48 +90,25 @@ class TestHandRanking:
def test_three_of_a_kind_string_representation(self):
"""Test string representation for three of a kind"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
cards = [Card(Rank.ACE, Suit.SPADES)] * 5
ranking = HandRanking(HandType.THREE_OF_A_KIND, [Rank.ACE], cards)
assert str(ranking) == "Three of a Kind(A)"
def test_two_pair_string_representation(self):
"""Test string representation for two pair"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
cards = [Card(Rank.ACE, Suit.SPADES)] * 5
ranking = HandRanking(HandType.TWO_PAIR, [Rank.ACE, Rank.KING], cards)
assert str(ranking) == "Two Pair(A and K)"
def test_one_pair_string_representation(self):
"""Test string representation for one pair"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
cards = [Card(Rank.ACE, Suit.SPADES)] * 5
ranking = HandRanking(HandType.ONE_PAIR, [Rank.ACE], cards)
assert str(ranking) == "Pair(A)"
def test_high_card_string_representation(self):
"""Test string representation for high card"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
cards = [Card(Rank.ACE, Suit.SPADES)] * 5
ranking = HandRanking(HandType.HIGH_CARD, [Rank.ACE], cards)
assert str(ranking) == "High Card(A)"
def test_hand_ranking_equality(self):
"""Test hand ranking equality"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking1 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
ranking2 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
ranking3 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.KING, Rank.ACE], cards)
assert ranking1 == ranking2
assert ranking1 != ranking3
def test_hand_ranking_comparison(self):
"""Test hand ranking comparison"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
# Different hand types
quad_aces = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE], cards)
full_house = HandRanking(HandType.FULL_HOUSE, [Rank.ACE], cards)
assert full_house < quad_aces
# Same hand type, different ranks
quad_aces = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE], cards)
quad_kings = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.KING], cards)
assert quad_kings < quad_aces

20
tests/test_integration.py
View File

@@ -15,7 +15,7 @@ class TestMainProgram:
def test_example_input(self):
"""Test the example input from the requirements"""
cards_str = "AsKs AhAdAc6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert str(ranking) == "Quad(A)"
@@ -35,19 +35,18 @@ class TestMainProgram:
]
for cards_str, expected_result in test_cases:
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert str(ranking) == expected_result, f"Failed for {cards_str}"
def test_wheel_straight(self):
"""Test A-2-3-4-5 straight (wheel)"""
"""Test A-2-3-4-5 straight"""
cards_str = "As2h3d4c5h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert str(ranking) == "Straight(5 high)"
def test_different_card_formats(self):
"""Test different ways of writing the same cards"""
# These should all represent the same hand
formats = [
"AsKsAhAdAc6s7s",
"As Ks Ah Ad Ac 6s 7s",
@@ -57,30 +56,29 @@ class TestMainProgram:
expected_result = "Quad(A)"
for cards_str in formats:
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert str(ranking) == expected_result
def test_case_insensitive_suits(self):
"""Test that suits are case insensitive"""
cards_str = "AsKsAhAdAc6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert str(ranking) == "Quad(A)"
def test_edge_cases(self):
"""Test edge cases and boundary conditions"""
# All same rank except one
cards_str = "2s2h2d2c3s4h5d"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert str(ranking) == "Quad(2)"
# Minimum straight
cards_str = "As2h3d4c5h6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
# Should pick 3-4-5-6-7 over A-2-3-4-5
assert "Straight(7 high)" in str(ranking)
# Maximum straight
cards_str = "9sTsJhQdKhAsAd"
ranking = HandEvaluator.evaluate_from_input(cards_str)
ranking = HandEvaluator.evaluateFromInput(cards_str)
assert str(ranking) == "Straight(A high)"