task4

tests/shortdeck/__init__.py

@@ -0,0 +1,3 @@
+"""
+Test module for Short Deck Poker implementation
+"""

tests/shortdeck/test_card.py

@@ -0,0 +1,203 @@
+"""
+Tests for Short Deck Card implementation
+"""
+
+import pytest
+from poker.card import Card, ShortDeckRank, Suit  # 使用统一的Card类
+
+
+class TestShortDeckRank:
+    """Test cases for ShortDeckRank enum"""
+    
+    def test_rank_values(self):
+        """Test that short deck ranks have correct values"""
+        assert ShortDeckRank.SIX.numeric_value == 6
+        assert ShortDeckRank.SEVEN.numeric_value == 7
+        assert ShortDeckRank.EIGHT.numeric_value == 8
+        assert ShortDeckRank.NINE.numeric_value == 9
+        assert ShortDeckRank.TEN.numeric_value == 10
+        assert ShortDeckRank.JACK.numeric_value == 11
+        assert ShortDeckRank.QUEEN.numeric_value == 12
+        assert ShortDeckRank.KING.numeric_value == 13
+        assert ShortDeckRank.ACE.numeric_value == 14
+    
+    def test_rank_symbols(self):
+        """Test that short deck ranks have correct symbols"""
+        assert ShortDeckRank.SIX.symbol == '6'
+        assert ShortDeckRank.SEVEN.symbol == '7'
+        assert ShortDeckRank.EIGHT.symbol == '8'
+        assert ShortDeckRank.NINE.symbol == '9'
+        assert ShortDeckRank.TEN.symbol == 'T'
+        assert ShortDeckRank.JACK.symbol == 'J'
+        assert ShortDeckRank.QUEEN.symbol == 'Q'
+        assert ShortDeckRank.KING.symbol == 'K'
+        assert ShortDeckRank.ACE.symbol == 'A'
+    
+    def test_rank_string_representation(self):
+        """Test string representation of ranks"""
+        assert str(ShortDeckRank.SIX) == '6'
+        assert str(ShortDeckRank.ACE) == 'A'
+    
+    def test_rank_comparison(self):
+        """Test rank comparison"""
+        assert ShortDeckRank.SIX < ShortDeckRank.SEVEN
+        assert ShortDeckRank.KING < ShortDeckRank.ACE
+        assert ShortDeckRank.ACE > ShortDeckRank.KING
+        assert ShortDeckRank.SIX <= ShortDeckRank.SIX
+        assert ShortDeckRank.ACE >= ShortDeckRank.ACE
+    
+    def test_rank_equality(self):
+        """Test rank equality"""
+        assert ShortDeckRank.SIX == ShortDeckRank.SIX
+        assert ShortDeckRank.ACE != ShortDeckRank.KING
+    
+    def test_rank_hash(self):
+        """Test rank hash functionality"""
+        rank_set = {ShortDeckRank.SIX, ShortDeckRank.SIX, ShortDeckRank.SEVEN}
+        assert len(rank_set) == 2  # No duplicate SIX
+    
+    def test_no_low_ranks(self):
+        """Test that ranks 2,3,4,5 are not present in short deck"""
+        rank_values = [rank.numeric_value for rank in ShortDeckRank]
+        assert 2 not in rank_values
+        assert 3 not in rank_values
+        assert 4 not in rank_values
+        assert 5 not in rank_values
+        assert len(list(ShortDeckRank)) == 9  # Only 9 ranks
+
+
+class TestSuit:
+    """Test cases for Suit enum (same as regular poker)"""
+    
+    def test_suit_values(self):
+        """Test suit values"""
+        assert Suit.SPADES.value == 's'
+        assert Suit.HEARTS.value == 'h'
+        assert Suit.DIAMONDS.value == 'd'
+        assert Suit.CLUBS.value == 'c'
+    
+    def test_suit_string_representation(self):
+        """Test string representation of suits"""
+        assert str(Suit.SPADES) == 's'
+        assert str(Suit.HEARTS) == 'h'
+
+
+class TestCard:
+    """Test cases for Card class"""
+    
+    def test_card_creation(self):
+        """Test card creation"""
+        card = Card(ShortDeckRank.ACE, Suit.SPADES)
+        assert card.rank == ShortDeckRank.ACE
+        assert card.suit == Suit.SPADES
+    
+    def test_card_string_representation(self):
+        """Test card string representation"""
+        card = Card(ShortDeckRank.ACE, Suit.SPADES)
+        assert str(card) == "As"
+        
+        card2 = Card(ShortDeckRank.KING, Suit.HEARTS)
+        assert str(card2) == "Kh"
+    
+    def test_card_comparison(self):
+        """Test card comparison"""
+        ace_spades = Card(ShortDeckRank.ACE, Suit.SPADES)
+        king_spades = Card(ShortDeckRank.KING, Suit.SPADES)
+        ace_hearts = Card(ShortDeckRank.ACE, Suit.HEARTS)
+        
+        assert king_spades < ace_spades
+        assert ace_hearts < ace_spades  # Same rank, suit comparison
+        assert ace_spades > king_spades
+    
+    def test_card_equality(self):
+        """Test card equality"""
+        card1 = Card(ShortDeckRank.ACE, Suit.SPADES)
+        card2 = Card(ShortDeckRank.ACE, Suit.SPADES)
+        card3 = Card(ShortDeckRank.KING, Suit.SPADES)
+        
+        assert card1 == card2
+        assert card1 != card3
+    
+    def test_create_card_valid(self):
+        """Test creating cards from valid strings"""
+        # 使用短牌模式创建卡片
+        card = Card.create_card("As", is_short_deck=True)
+        assert card.rank == ShortDeckRank.ACE
+        assert card.suit == Suit.SPADES
+        
+        card2 = Card.create_card("6h", is_short_deck=True)
+        assert card2.rank == ShortDeckRank.SIX
+        assert card2.suit == Suit.HEARTS
+    
+    def test_create_card_invalid_length(self):
+        """Test creating card with invalid string length"""
+        with pytest.raises(ValueError, match="Invalid card string"):
+            Card.create_card("A")
+        
+        with pytest.raises(ValueError, match="Invalid card string"):
+            Card.create_card("Ash")
+    
+    def test_create_card_invalid_rank(self):
+        """Test creating card with invalid rank (should reject 2,3,4,5)"""
+        with pytest.raises(ValueError, match="Invalid rank"):
+            Card.create_card("2s", is_short_deck=True)
+        
+        with pytest.raises(ValueError, match="Invalid rank"):
+            Card.create_card("5h", is_short_deck=True)
+        
+        with pytest.raises(ValueError, match="Invalid rank"):
+            Card.create_card("Xs", is_short_deck=True)
+    
+    def test_create_card_invalid_suit(self):
+        """Test creating card with invalid suit"""
+        with pytest.raises(ValueError, match="Invalid suit"):
+            Card.create_card("Ax")
+    
+    def test_parse_cards_valid(self):
+        """Test parsing multiple valid cards"""
+        cards = Card.parse_cards("AsKs AhAdAc6s7s")
+        assert len(cards) == 7
+        assert str(cards[0]) == "As"
+        assert str(cards[1]) == "Ks"
+        assert str(cards[6]) == "7s"
+    
+    def test_parse_cards_empty(self):
+        """Test parsing empty string"""
+        cards = Card.parse_cards("")
+        assert len(cards) == 0
+        
+        cards = Card.parse_cards("   ")
+        assert len(cards) == 0
+    
+    def test_parse_cards_invalid_format(self):
+        """Test parsing cards with invalid format"""
+        with pytest.raises(ValueError, match="Invalid card format"):
+            Card.parse_cards("AsK")  # Odd length
+    
+    def test_parse_cards_with_invalid_cards(self):
+        """Test parsing string containing invalid cards"""
+        with pytest.raises(ValueError, match="Invalid rank"):
+            Card.parse_cards("As 2s Kh", is_short_deck=True)  # Contains '2s'
+    
+    def test_get_all_cards(self):
+        """Test getting all 36 cards in short deck"""
+        all_cards = []
+        for rank in ShortDeckRank:
+            for suit in Suit:
+                all_cards.append(Card(rank, suit))
+        
+        assert len(all_cards) == 36  # 9 ranks * 4 suits
+        
+        # Check that all combinations are present
+        ranks_found = set()
+        suits_found = set()
+        for card in all_cards:
+            ranks_found.add(card.rank)
+            suits_found.add(card.suit)
+        
+        assert len(ranks_found) == 9  # All 9 short deck ranks
+        assert len(suits_found) == 4  # All 4 suits
+        
+        # Verify no low cards (2,3,4,5) are present
+        for card in all_cards:
+            assert card.rank.numeric_value >= 6

tests/shortdeck/test_hand_evaluator.py

@@ -0,0 +1,326 @@
+"""
+Tests for Short Deck Hand Evaluator
+"""
+
+import pytest
+from poker.card import Card, ShortDeckRank, Suit  # 使用统一的Card类
+from shortdeck.hand_evaluator import ShortDeckHandEvaluator
+from shortdeck.hand_ranking import ShortDeckHandType, ShortDeckHandRanking
+
+
+class TestShortDeckHandEvaluator:
+    """Test cases for ShortDeckHandEvaluator class"""
+    
+    def test_evaluate_hand_insufficient_cards(self):
+        """Test evaluation with less than 5 cards"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.HEARTS),
+            Card(ShortDeckRank.QUEEN, Suit.DIAMONDS),
+            Card(ShortDeckRank.JACK, Suit.CLUBS)
+        ]
+        
+        with pytest.raises(ValueError, match="Need at least 5 cards"):
+            ShortDeckHandEvaluator.evaluate_hand(cards)
+    
+    def test_evaluate_hand_exactly_five_cards(self):
+        """Test evaluation with exactly 5 cards"""
+        # Royal flush
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.QUEEN, Suit.SPADES),
+            Card(ShortDeckRank.JACK, Suit.SPADES),
+            Card(ShortDeckRank.TEN, Suit.SPADES)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_hand(cards)
+        assert result.hand_type == ShortDeckHandType.ROYAL_FLUSH
+    
+    def test_evaluate_hand_seven_cards(self):
+        """Test evaluation with 7 cards - should find best 5"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.ACE, Suit.DIAMONDS),
+            Card(ShortDeckRank.ACE, Suit.CLUBS),  # Four Aces
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.SIX, Suit.HEARTS),
+            Card(ShortDeckRank.SEVEN, Suit.DIAMONDS)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_hand(cards)
+        assert result.hand_type == ShortDeckHandType.FOUR_OF_A_KIND
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+    
+    def test_evaluate_five_cards_wrong_count(self):
+        """Test evaluate5Cards with wrong number of cards"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.HEARTS)
+        ]
+        
+        with pytest.raises(ValueError, match="Must provide exactly 5 cards"):
+            ShortDeckHandEvaluator.evaluate_5_cards(cards)
+    
+    def test_royal_flush(self):
+        """Test royal flush detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.QUEEN, Suit.SPADES),
+            Card(ShortDeckRank.JACK, Suit.SPADES),
+            Card(ShortDeckRank.TEN, Suit.SPADES)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.ROYAL_FLUSH
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+    
+    def test_straight_flush(self):
+        """Test straight flush detection"""
+        cards = [
+            Card(ShortDeckRank.KING, Suit.HEARTS),
+            Card(ShortDeckRank.QUEEN, Suit.HEARTS),
+            Card(ShortDeckRank.JACK, Suit.HEARTS),
+            Card(ShortDeckRank.TEN, Suit.HEARTS),
+            Card(ShortDeckRank.NINE, Suit.HEARTS)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.STRAIGHT_FLUSH
+        assert result.key_ranks[0] == ShortDeckRank.KING
+    
+    def test_four_of_a_kind(self):
+        """Test four of a kind detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.ACE, Suit.DIAMONDS),
+            Card(ShortDeckRank.ACE, Suit.CLUBS),
+            Card(ShortDeckRank.KING, Suit.SPADES)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.FOUR_OF_A_KIND
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+        assert result.key_ranks[1] == ShortDeckRank.KING  # Kicker
+    
+    def test_flush_beats_full_house(self):
+        """Test that flush beats full house in short deck"""
+        # Flush
+        flush_cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.QUEEN, Suit.SPADES),
+            Card(ShortDeckRank.JACK, Suit.SPADES),
+            Card(ShortDeckRank.NINE, Suit.SPADES)
+        ]
+        
+        # Full house
+        full_house_cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.ACE, Suit.DIAMONDS),
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.HEARTS)
+        ]
+        
+        flush_result = ShortDeckHandEvaluator.evaluate_5_cards(flush_cards)
+        full_house_result = ShortDeckHandEvaluator.evaluate_5_cards(full_house_cards)
+        
+        assert flush_result.hand_type == ShortDeckHandType.FLUSH
+        assert full_house_result.hand_type == ShortDeckHandType.FULL_HOUSE
+        assert flush_result > full_house_result  # Flush beats Full House in Short Deck!
+    
+    def test_full_house(self):
+        """Test full house detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.ACE, Suit.DIAMONDS),
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.HEARTS)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.FULL_HOUSE
+        assert result.key_ranks[0] == ShortDeckRank.ACE  # Trips
+        assert result.key_ranks[1] == ShortDeckRank.KING  # Pair
+    
+    def test_flush(self):
+        """Test flush detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.QUEEN, Suit.SPADES),
+            Card(ShortDeckRank.JACK, Suit.SPADES),
+            Card(ShortDeckRank.NINE, Suit.SPADES)  # Not a straight
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.FLUSH
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+    
+    def test_straight_regular(self):
+        """Test regular straight detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.HEARTS),
+            Card(ShortDeckRank.QUEEN, Suit.DIAMONDS),
+            Card(ShortDeckRank.JACK, Suit.CLUBS),
+            Card(ShortDeckRank.TEN, Suit.SPADES)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.STRAIGHT
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+    
+    def test_straight_low_wheel(self):
+        """Test short deck wheel straight: A-6-7-8-9"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.NINE, Suit.HEARTS),
+            Card(ShortDeckRank.EIGHT, Suit.DIAMONDS),
+            Card(ShortDeckRank.SEVEN, Suit.CLUBS),
+            Card(ShortDeckRank.SIX, Suit.SPADES)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.STRAIGHT
+        assert result.key_ranks[0] == ShortDeckRank.NINE  # 9-high straight in short deck wheel
+    
+    def test_three_of_a_kind(self):
+        """Test three of a kind detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.ACE, Suit.DIAMONDS),
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.QUEEN, Suit.HEARTS)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.THREE_OF_A_KIND
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+        assert ShortDeckRank.KING in result.key_ranks
+        assert ShortDeckRank.QUEEN in result.key_ranks
+    
+    def test_two_pair(self):
+        """Test two pair detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.KING, Suit.DIAMONDS),
+            Card(ShortDeckRank.KING, Suit.SPADES),
+            Card(ShortDeckRank.QUEEN, Suit.HEARTS)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.TWO_PAIR
+        assert result.key_ranks[0] == ShortDeckRank.ACE  # Higher pair first
+        assert result.key_ranks[1] == ShortDeckRank.KING  # Lower pair second
+        assert result.key_ranks[2] == ShortDeckRank.QUEEN  # Kicker
+    
+    def test_one_pair(self):
+        """Test one pair detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.KING, Suit.DIAMONDS),
+            Card(ShortDeckRank.QUEEN, Suit.SPADES),
+            Card(ShortDeckRank.JACK, Suit.HEARTS)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.ONE_PAIR
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+        assert ShortDeckRank.KING in result.key_ranks
+        assert ShortDeckRank.QUEEN in result.key_ranks
+        assert ShortDeckRank.JACK in result.key_ranks
+    
+    def test_high_card(self):
+        """Test high card detection"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.KING, Suit.HEARTS),
+            Card(ShortDeckRank.QUEEN, Suit.DIAMONDS),
+            Card(ShortDeckRank.JACK, Suit.CLUBS),
+            Card(ShortDeckRank.NINE, Suit.HEARTS)  # Not a straight (missing 10)
+        ]
+        
+        result = ShortDeckHandEvaluator.evaluate_5_cards(cards)
+        assert result.hand_type == ShortDeckHandType.HIGH_CARD
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+    
+    def test_is_straight_regular_straights(self):
+        """Test isStraight with regular straights"""
+        # T-J-Q-K-A
+        ranks1 = [ShortDeckRank.ACE, ShortDeckRank.KING, ShortDeckRank.QUEEN, ShortDeckRank.JACK, ShortDeckRank.TEN]
+        is_straight1, high1 = ShortDeckHandEvaluator.is_straight(ranks1)
+        assert is_straight1 == True
+        assert high1 == ShortDeckRank.ACE
+        
+        # 6-7-8-9-T
+        ranks2 = [ShortDeckRank.TEN, ShortDeckRank.NINE, ShortDeckRank.EIGHT, ShortDeckRank.SEVEN, ShortDeckRank.SIX]
+        is_straight2, high2 = ShortDeckHandEvaluator.is_straight(ranks2)
+        assert is_straight2 == True
+        assert high2 == ShortDeckRank.TEN
+    
+    def test_is_straight_wheel(self):
+        """Test isStraight with short deck wheel: A-6-7-8-9"""
+        ranks = [ShortDeckRank.ACE, ShortDeckRank.NINE, ShortDeckRank.EIGHT, ShortDeckRank.SEVEN, ShortDeckRank.SIX]
+        is_straight, high = ShortDeckHandEvaluator.is_straight(ranks)
+        assert is_straight == True
+        assert high == ShortDeckRank.NINE  # 9-high straight in short deck wheel
+    
+    def test_is_straight_not_straight(self):
+        """Test isStraight with non-straight"""
+        ranks = [ShortDeckRank.ACE, ShortDeckRank.KING, ShortDeckRank.QUEEN, ShortDeckRank.JACK, ShortDeckRank.NINE]
+        is_straight, high = ShortDeckHandEvaluator.is_straight(ranks)
+        assert is_straight == False
+        assert high is None
+    
+    def test_is_straight_insufficient_cards(self):
+        """Test isStraight with less than 5 unique ranks"""
+        ranks = [ShortDeckRank.ACE, ShortDeckRank.ACE, ShortDeckRank.KING, ShortDeckRank.KING]  # Only 2 unique
+        is_straight, high = ShortDeckHandEvaluator.is_straight(ranks)
+        assert is_straight == False
+        assert high is None
+    
+    def test_evaluate_from_input_valid(self):
+        """Test evaluateFromInput with valid input"""
+        # Four of a kind
+        result = ShortDeckHandEvaluator.evaluate_from_input("AsAhAdAc Ks")
+        assert result.hand_type == ShortDeckHandType.FOUR_OF_A_KIND
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+    
+    def test_evaluate_from_input_seven_cards(self):
+        """Test evaluateFromInput with 7 cards"""
+        result = ShortDeckHandEvaluator.evaluate_from_input("AsAhAdAc KsQsJs")
+        assert result.hand_type == ShortDeckHandType.FOUR_OF_A_KIND
+        assert result.key_ranks[0] == ShortDeckRank.ACE
+    
+    def test_evaluate_from_input_invalid_cards(self):
+        """Test evaluateFromInput with invalid cards (should reject 2,3,4,5)"""
+        with pytest.raises(ValueError, match="Invalid rank for short deck"):
+            ShortDeckHandEvaluator.evaluate_from_input("2s3s4s5s6s")
+    
+    def test_all_possible_straights(self):
+        """Test all possible straights in short deck"""
+        # All possible short deck straights:
+        # A-6-7-8-9, 6-7-8-9-T, 7-8-9-T-J, 8-9-T-J-Q, 9-T-J-Q-K, T-J-Q-K-A
+        
+        straight_combinations = [
+            ([ShortDeckRank.ACE, ShortDeckRank.NINE, ShortDeckRank.EIGHT, ShortDeckRank.SEVEN, ShortDeckRank.SIX], ShortDeckRank.NINE),
+            ([ShortDeckRank.TEN, ShortDeckRank.NINE, ShortDeckRank.EIGHT, ShortDeckRank.SEVEN, ShortDeckRank.SIX], ShortDeckRank.TEN),
+            ([ShortDeckRank.JACK, ShortDeckRank.TEN, ShortDeckRank.NINE, ShortDeckRank.EIGHT, ShortDeckRank.SEVEN], ShortDeckRank.JACK),
+            ([ShortDeckRank.QUEEN, ShortDeckRank.JACK, ShortDeckRank.TEN, ShortDeckRank.NINE, ShortDeckRank.EIGHT], ShortDeckRank.QUEEN),
+            ([ShortDeckRank.KING, ShortDeckRank.QUEEN, ShortDeckRank.JACK, ShortDeckRank.TEN, ShortDeckRank.NINE], ShortDeckRank.KING),
+            ([ShortDeckRank.ACE, ShortDeckRank.KING, ShortDeckRank.QUEEN, ShortDeckRank.JACK, ShortDeckRank.TEN], ShortDeckRank.ACE),
+        ]
+        
+        for ranks, expected_high in straight_combinations:
+            is_straight, high = ShortDeckHandEvaluator.is_straight(ranks)
+            assert is_straight == True, f"Failed to detect straight: {[r.symbol for r in ranks]}"
+            assert high == expected_high, f"Wrong high card for {[r.symbol for r in ranks]}: expected {expected_high.symbol}, got {high.symbol if high else None}"

tests/shortdeck/test_hand_ranking.py

@@ -0,0 +1,177 @@
+"""
+Tests for Short Deck HandRanking and HandType classes
+"""
+
+import pytest
+from poker.card import Card, ShortDeckRank, Suit  # 使用统一的Card类
+from shortdeck.hand_ranking import ShortDeckHandRanking, ShortDeckHandType
+
+
+class TestShortDeckHandType:
+    """Test cases for ShortDeckHandType enum"""
+    
+    def test_hand_type_values(self):
+        """Test hand type strength values - Flush beats Full House in Short Deck"""
+        assert ShortDeckHandType.HIGH_CARD.strength == 1
+        assert ShortDeckHandType.ONE_PAIR.strength == 2
+        assert ShortDeckHandType.TWO_PAIR.strength == 3
+        assert ShortDeckHandType.THREE_OF_A_KIND.strength == 4
+        assert ShortDeckHandType.STRAIGHT.strength == 5
+        assert ShortDeckHandType.FULL_HOUSE.strength == 6
+        assert ShortDeckHandType.FLUSH.strength == 7  # Higher than Full House!
+        assert ShortDeckHandType.FOUR_OF_A_KIND.strength == 8
+        assert ShortDeckHandType.STRAIGHT_FLUSH.strength == 9
+        assert ShortDeckHandType.ROYAL_FLUSH.strength == 10
+    
+    def test_hand_type_names(self):
+        """Test hand type names"""
+        assert ShortDeckHandType.HIGH_CARD.type_name == "High Card"
+        assert ShortDeckHandType.FOUR_OF_A_KIND.type_name == "Four of a Kind"
+        assert ShortDeckHandType.ROYAL_FLUSH.type_name == "Royal Flush"
+        assert ShortDeckHandType.FLUSH.type_name == "Flush"
+        assert ShortDeckHandType.FULL_HOUSE.type_name == "Full House"
+    
+    def test_hand_type_string_representation(self):
+        """Test string representation of hand types"""
+        assert str(ShortDeckHandType.HIGH_CARD) == "High Card"
+        assert str(ShortDeckHandType.ROYAL_FLUSH) == "Royal Flush"
+    
+    def test_hand_type_comparison(self):
+        """Test hand type comparison - KEY: Flush > Full House in Short Deck"""
+        assert ShortDeckHandType.HIGH_CARD < ShortDeckHandType.ONE_PAIR
+        assert ShortDeckHandType.FLUSH > ShortDeckHandType.FULL_HOUSE  # Short Deck rule!
+        assert ShortDeckHandType.ROYAL_FLUSH >= ShortDeckHandType.STRAIGHT_FLUSH
+        assert ShortDeckHandType.TWO_PAIR <= ShortDeckHandType.THREE_OF_A_KIND
+        assert ShortDeckHandType.STRAIGHT < ShortDeckHandType.FULL_HOUSE
+        assert ShortDeckHandType.FULL_HOUSE < ShortDeckHandType.FLUSH
+    
+    def test_hand_type_equality(self):
+        """Test hand type equality"""
+        assert ShortDeckHandType.FLUSH == ShortDeckHandType.FLUSH
+        assert ShortDeckHandType.FLUSH != ShortDeckHandType.FULL_HOUSE
+
+
+class TestShortDeckHandRanking:
+    """Test cases for ShortDeckHandRanking class"""
+    
+    def test_hand_ranking_creation(self):
+        """Test hand ranking creation"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.SPADES),
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.ACE, Suit.DIAMONDS),
+            Card(ShortDeckRank.ACE, Suit.CLUBS),
+            Card(ShortDeckRank.KING, Suit.SPADES)
+        ]
+        ranking = ShortDeckHandRanking(ShortDeckHandType.FOUR_OF_A_KIND, [ShortDeckRank.ACE, ShortDeckRank.KING], cards)
+        
+        assert ranking.hand_type == ShortDeckHandType.FOUR_OF_A_KIND
+        assert ranking.key_ranks == [ShortDeckRank.ACE, ShortDeckRank.KING]
+        assert ranking.cards == cards
+    
+    def test_quad_string_representation(self):
+        """Test string representation for four of a kind"""
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.FOUR_OF_A_KIND, [ShortDeckRank.ACE, ShortDeckRank.KING], cards)
+        assert str(ranking) == "Quad(A)"
+    
+    def test_full_house_string_representation(self):
+        """Test string representation for full house"""
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.FULL_HOUSE, [ShortDeckRank.ACE, ShortDeckRank.KING], cards)
+        assert str(ranking) == "Full House(A over K)"
+    
+    def test_flush_string_representation(self):
+        """Test string representation for flush"""
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.FLUSH, [ShortDeckRank.ACE], cards)
+        assert str(ranking) == "Flush(A high)"
+    
+    def test_straight_string_representation(self):
+        """Test string representation for straight"""
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.STRAIGHT, [ShortDeckRank.ACE], cards)
+        assert str(ranking) == "Straight(A high)"
+    
+    def test_straight_flush_string_representation(self):
+        """Test string representation for straight flush"""
+        cards = [Card(ShortDeckRank.KING, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.STRAIGHT_FLUSH, [ShortDeckRank.KING], cards)
+        assert str(ranking) == "Straight Flush(K high)"
+    
+    def test_royal_flush_string_representation(self):
+        """Test string representation for royal flush"""
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        
+        # Direct royal flush
+        ranking1 = ShortDeckHandRanking(ShortDeckHandType.ROYAL_FLUSH, [ShortDeckRank.ACE], cards)
+        assert str(ranking1) == "Royal Flush"
+        
+        # Straight flush with Ace high should also show as Royal Flush
+        ranking2 = ShortDeckHandRanking(ShortDeckHandType.STRAIGHT_FLUSH, [ShortDeckRank.ACE], cards)
+        assert str(ranking2) == "Royal Flush"
+    
+    def test_three_of_a_kind_string_representation(self):
+        """Test string representation for three of a kind"""
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.THREE_OF_A_KIND, [ShortDeckRank.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(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.TWO_PAIR, [ShortDeckRank.ACE, ShortDeckRank.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(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.ONE_PAIR, [ShortDeckRank.ACE], cards)
+        assert str(ranking) == "Pair(A)"
+    
+    def test_high_card_string_representation(self):
+        """Test string representation for high card"""
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        ranking = ShortDeckHandRanking(ShortDeckHandType.HIGH_CARD, [ShortDeckRank.ACE], cards)
+        assert str(ranking) == "High Card(A)"
+    
+    def test_hand_ranking_comparison(self):
+        """Test hand ranking comparison"""
+        # Create some test cards
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        
+        # Create different rankings
+        quad_aces = ShortDeckHandRanking(ShortDeckHandType.FOUR_OF_A_KIND, [ShortDeckRank.ACE], cards)
+        flush_ace = ShortDeckHandRanking(ShortDeckHandType.FLUSH, [ShortDeckRank.ACE], cards)
+        full_house = ShortDeckHandRanking(ShortDeckHandType.FULL_HOUSE, [ShortDeckRank.ACE, ShortDeckRank.KING], cards)
+        straight_ace = ShortDeckHandRanking(ShortDeckHandType.STRAIGHT, [ShortDeckRank.ACE], cards)
+        
+        # Test Short Deck specific comparison: Flush > Full House
+        assert flush_ace > full_house
+        assert full_house < flush_ace
+        
+        # Test other comparisons
+        assert quad_aces > flush_ace
+        assert straight_ace < full_house
+    
+    def test_hand_ranking_equality(self):
+        """Test hand ranking equality"""
+        cards1 = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        cards2 = [Card(ShortDeckRank.KING, Suit.HEARTS)] * 5
+        
+        ranking1 = ShortDeckHandRanking(ShortDeckHandType.FLUSH, [ShortDeckRank.ACE], cards1)
+        ranking2 = ShortDeckHandRanking(ShortDeckHandType.FLUSH, [ShortDeckRank.ACE], cards2)
+        ranking3 = ShortDeckHandRanking(ShortDeckHandType.FLUSH, [ShortDeckRank.KING], cards2)
+        
+        assert ranking1 == ranking2  # Same hand type and key ranks
+        assert ranking1 != ranking3  # Different key ranks
+    
+    def test_same_type_different_ranks(self):
+        """Test comparison of same hand type with different key ranks"""
+        cards = [Card(ShortDeckRank.ACE, Suit.SPADES)] * 5
+        
+        ace_high = ShortDeckHandRanking(ShortDeckHandType.HIGH_CARD, [ShortDeckRank.ACE], cards)
+        king_high = ShortDeckHandRanking(ShortDeckHandType.HIGH_CARD, [ShortDeckRank.KING], cards)
+        
+        assert ace_high > king_high
+        assert king_high < ace_high

tests/shortdeck/test_integration.py

@@ -0,0 +1,225 @@
+"""
+Integration tests for Short Deck Poker implementation
+"""
+
+import pytest
+from poker.card import Card, ShortDeckRank, Suit  # 使用统一的Card类
+from shortdeck import ShortDeckHandEvaluator, ShortDeckHandType, ShortDeckHandRanking
+
+
+class TestShortDeckIntegration:
+    """Integration tests for the complete short deck poker system"""
+    
+    def test_shortdeck_example_cases(self):
+        """Test various short deck example hands"""
+        
+        # Test cases with expected results
+        test_cases = [
+            # Royal Flush
+            ("AsKsQsJsTs", ShortDeckHandType.ROYAL_FLUSH, "Royal Flush"),
+            
+            # Straight Flush (not royal)
+            ("KsQsJsTs9s", ShortDeckHandType.STRAIGHT_FLUSH, "Straight Flush(K high)"),
+            
+            # Four of a Kind
+            ("AsAhAdAcKs", ShortDeckHandType.FOUR_OF_A_KIND, "Quad(A)"),
+            
+            # Flush (beats Full House in Short Deck!)
+            ("AsKsQsJs9s", ShortDeckHandType.FLUSH, "Flush(A high)"),
+            
+            # Full House (weaker than Flush in Short Deck)
+            ("AsAhAdKsKh", ShortDeckHandType.FULL_HOUSE, "Full House(A over K)"),
+            
+            # Straight - regular
+            ("AsKsQhJdTs", ShortDeckHandType.STRAIGHT, "Straight(A high)"),
+            
+            # Straight - short deck wheel (A-6-7-8-9)
+            ("As9h8d7c6s", ShortDeckHandType.STRAIGHT, "Straight(9 high)"),
+            
+            # Three of a Kind
+            ("AsAhAdKsQs", ShortDeckHandType.THREE_OF_A_KIND, "Three of a Kind(A)"),
+            
+            # Two Pair
+            ("AsAhKdKsQs", ShortDeckHandType.TWO_PAIR, "Two Pair(A and K)"),
+            
+            # One Pair
+            ("AsAhKdQsJs", ShortDeckHandType.ONE_PAIR, "Pair(A)"),
+            
+            # High Card
+            ("AsKhQdJs9s", ShortDeckHandType.HIGH_CARD, "High Card(A)")
+        ]
+        
+        for hand_str, expected_type, expected_str in test_cases:
+            result = ShortDeckHandEvaluator.evaluate_from_input(hand_str)
+            assert result.hand_type == expected_type, f"Failed for {hand_str}: expected {expected_type}, got {result.hand_type}"
+            assert str(result) == expected_str, f"Failed string for {hand_str}: expected '{expected_str}', got '{str(result)}'"
+    
+    def test_shortdeck_seven_card_hands(self):
+        """Test evaluation with 7 cards (like Texas Hold'em)"""
+        
+        # Should find the best 5-card hand from 7 cards
+        test_cases = [
+            # Four of a kind + extra cards
+            ("AsAhAdAcKs Qs 6h", ShortDeckHandType.FOUR_OF_A_KIND, "Quad(A)"),
+            
+            # Full house from 7 cards
+            ("AsAhAdKsKh Qc 7d", ShortDeckHandType.FULL_HOUSE, "Full House(A over K)"),
+            
+            # Flush with extra cards
+            ("AsKsQsJsTs 6h 7c", ShortDeckHandType.ROYAL_FLUSH, "Royal Flush"),
+        ]
+        
+        for hand_str, expected_type, expected_str in test_cases:
+            result = ShortDeckHandEvaluator.evaluate_from_input(hand_str)
+            assert result.hand_type == expected_type
+            assert str(result) == expected_str
+    
+    def test_shortdeck_flush_vs_full_house(self):
+        """Test the key Short Deck rule: Flush beats Full House"""
+        
+        # Create flush
+        flush_hand = "AsKsQsJs9s"  # A-high flush
+        flush_result = ShortDeckHandEvaluator.evaluate_from_input(flush_hand)
+        
+        # Create full house
+        full_house_hand = "AsAhAdKsKh"  # Aces full of Kings
+        full_house_result = ShortDeckHandEvaluator.evaluate_from_input(full_house_hand)
+        
+        # Flush should beat Full House
+        assert flush_result > full_house_result
+        assert flush_result.hand_type == ShortDeckHandType.FLUSH
+        assert full_house_result.hand_type == ShortDeckHandType.FULL_HOUSE
+    
+    def test_shortdeck_wheel_straight(self):
+        """Test Short Deck wheel straight: A-6-7-8-9"""
+        
+        # Wheel straight
+        wheel_hand = "As9h8d7c6s"
+        wheel_result = ShortDeckHandEvaluator.evaluate_from_input(wheel_hand)
+        
+        # Regular straight
+        regular_hand = "TsJhQdKcAs"
+        regular_result = ShortDeckHandEvaluator.evaluate_from_input(regular_hand)
+        
+        assert wheel_result.hand_type == ShortDeckHandType.STRAIGHT
+        assert regular_result.hand_type == ShortDeckHandType.STRAIGHT
+        
+        # A-high straight should beat 9-high wheel
+        assert regular_result > wheel_result
+        
+        # Check string representations
+        assert str(wheel_result) == "Straight(9 high)"
+        assert str(regular_result) == "Straight(A high)"
+    
+    def test_no_invalid_short_deck_cards(self):
+        """Test that cards 2, 3, 4, 5 are properly rejected"""
+        
+        invalid_hands = [
+            "2s3s4s5s6s",  # Contains 2, 3, 4, 5
+            "AsKs2h3h4h",  # Mixed valid and invalid
+            "5sAsKsQsJs"   # Contains 5
+        ]
+        
+        for invalid_hand in invalid_hands:
+            with pytest.raises(ValueError, match="Invalid rank for short deck"):
+                ShortDeckHandEvaluator.evaluate_from_input(invalid_hand)
+    
+    def test_all_short_deck_straights(self):
+        """Test all 6 possible straights in Short Deck"""
+        
+        straight_tests = [
+            ("As9h8d7c6s", "Straight(9 high)"),   # A-6-7-8-9 (wheel)
+            ("TsJhQdKcAs", "Straight(A high)"),   # T-J-Q-K-A (broadway)
+            ("Ts9h8d7c6s", "Straight(T high)"),   # 6-7-8-9-T
+            ("JsTh9d8c7s", "Straight(J high)"),   # 7-8-9-T-J
+            ("QsJhTd9c8s", "Straight(Q high)"),   # 8-9-T-J-Q
+            ("KsQhJdTc9s", "Straight(K high)"),   # 9-T-J-Q-K
+        ]
+        
+        for hand_str, expected_str in straight_tests:
+            result = ShortDeckHandEvaluator.evaluate_from_input(hand_str)
+            assert result.hand_type == ShortDeckHandType.STRAIGHT
+            assert str(result) == expected_str
+    
+    def test_shortdeck_card_count(self):
+        """Test that Short Deck has exactly 36 cards"""
+        # 使用Card类的ShortDeck模式
+        all_cards = []
+        for rank in ShortDeckRank:
+            for suit in Suit:
+                all_cards.append(Card(rank, suit))
+        
+        assert len(all_cards) == 36  # 9 ranks * 4 suits
+        
+        # Verify no duplicates
+        card_strings = [str(card) for card in all_cards]
+        assert len(set(card_strings)) == 36
+        
+        # Verify all ranks 6-A are present
+        ranks_present = set(card.rank for card in all_cards)
+        expected_ranks = set(ShortDeckRank)
+        assert ranks_present == expected_ranks
+        
+        # Verify no low cards (2,3,4,5)
+        for card in all_cards:
+            assert card.rank.numeric_value >= 6
+    
+    def test_shortdeck_hand_rankings_order(self):
+        """Test the complete hand ranking order for Short Deck"""
+        
+        # Create hands of different types
+        hands = [
+            ("AsKhQdJs9c", ShortDeckHandType.HIGH_CARD),      # High Card
+            ("AsAhKdQsJc", ShortDeckHandType.ONE_PAIR),       # One Pair
+            ("AsAhKdKsQc", ShortDeckHandType.TWO_PAIR),       # Two Pair
+            ("AsAhAdKsQc", ShortDeckHandType.THREE_OF_A_KIND), # Three of a Kind
+            ("AsKhQdJsTc", ShortDeckHandType.STRAIGHT),       # Straight
+            ("AsAhAdKsKc", ShortDeckHandType.FULL_HOUSE),     # Full House
+            ("AsKsQsJs9s", ShortDeckHandType.FLUSH),          # Flush (beats Full House!)
+            ("AsAhAdAcKs", ShortDeckHandType.FOUR_OF_A_KIND), # Four of a Kind
+            ("9s8s7s6sTs", ShortDeckHandType.STRAIGHT_FLUSH), # Straight Flush
+            ("AsKsQsJsTs", ShortDeckHandType.ROYAL_FLUSH),    # Royal Flush
+        ]
+        
+        results = []
+        for hand_str, expected_type in hands:
+            result = ShortDeckHandEvaluator.evaluate_from_input(hand_str)
+            assert result.hand_type == expected_type
+            results.append(result)
+        
+        # Test that they are in ascending order of strength
+        for i in range(len(results) - 1):
+            assert results[i] < results[i + 1], f"{results[i].hand_type} should be less than {results[i + 1].hand_type}"
+    
+    def test_shortdeck_main_script_functionality(self):
+        """Test that the main script input format works correctly"""
+        
+        # Test various input formats that the main script should handle
+        test_inputs = [
+            "AsKsQsJsTs",        # 5 cards
+            "AsKs QsJs TsAh Ad", # 7 cards with spaces
+            "6s7s8s9sTs",        # Low straight flush
+        ]
+        
+        for input_str in test_inputs:
+            # This should not raise an exception
+            result = ShortDeckHandEvaluator.evaluate_from_input(input_str)
+            assert result is not None
+            assert hasattr(result, 'hand_type')
+            assert hasattr(result, 'key_ranks')
+            assert len(str(result)) > 0
+    
+    def test_edge_cases(self):
+        """Test various edge cases"""
+        
+        # All same rank except one (should be four of a kind)
+        result1 = ShortDeckHandEvaluator.evaluate_from_input("6s6h6d6cAs")
+        assert result1.hand_type == ShortDeckHandType.FOUR_OF_A_KIND
+        
+        # Almost straight but not quite
+        result2 = ShortDeckHandEvaluator.evaluate_from_input("AsKhQdJs8c")  # Missing 10
+        assert result2.hand_type == ShortDeckHandType.HIGH_CARD
+        
+        # Almost flush but not quite
+        result3 = ShortDeckHandEvaluator.evaluate_from_input("AsKsQsJs8h")  # Mixed suits, not straight
+        assert result3.hand_type == ShortDeckHandType.HIGH_CARD

tests/test_card.py

@@ -52,39 +52,39 @@ class TestCard:
     
     def test_from_string_valid(self):
         """Test creating card from valid string"""
-        card = Card.createCard("As")
+        card = Card.create_card("As")
         assert card.rank == Rank.ACE
         assert card.suit == Suit.SPADES
 
-        card2 = Card.createCard("Kh")
+        card2 = Card.create_card("Kh")
         assert card2.rank == Rank.KING
         assert card2.suit == Suit.HEARTS
 
-        card3 = Card.createCard("2c")
+        card3 = Card.create_card("2c")
         assert card3.rank == Rank.TWO
         assert card3.suit == Suit.CLUBS
 
-        card4 = Card.createCard("Td")
+        card4 = Card.create_card("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.createCard("A")  # Too short
+            Card.create_card("A")  # Too short
         
         with pytest.raises(ValueError):
-            Card.createCard("Asx")  # Too long
+            Card.create_card("Asx")  # Too long
         
         with pytest.raises(ValueError):
-            Card.createCard("Xs")  # Invalid rank
+            Card.create_card("Xs")  # Invalid rank
         
         with pytest.raises(ValueError):
-            Card.createCard("Ax")  # Invalid suit
+            Card.create_card("Ax")  # Invalid suit
     
     def test_parse_cards_valid(self):
         """Test parsing multiple cards from string"""
-        cards = Card.parseCards("AsKs AhAdAc6s7s")
+        cards = Card.parse_cards("AsKs AhAdAc6s7s")
         assert len(cards) == 7
         assert str(cards[0]) == "As"
         assert str(cards[1]) == "Ks"
@@ -93,23 +93,23 @@ class TestCard:
     
     def test_parse_cards_with_spaces(self):
         """Test parsing cards with various spacing"""
-        cards = Card.parseCards("As Ks  Ah   Ad Ac 6s 7s")
+        cards = Card.parse_cards("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.parseCards("")
+        cards = Card.parse_cards("")
         assert len(cards) == 0
 
-        cards = Card.parseCards("   ")
+        cards = Card.parse_cards("   ")
         assert len(cards) == 0
     
     def test_parse_cards_invalid(self):
         """Test parsing invalid card strings"""
         with pytest.raises(ValueError):
-            Card.parseCards("AsKs A")  # Incomplete card
+            Card.parse_cards("AsKs A")  # Incomplete card
 
         with pytest.raises(ValueError):
-            Card.parseCards("AsKs Ax")  # Invalid suit
+            Card.parse_cards("AsKs Ax")  # Invalid suit

tests/test_coverage_edge_cases.py

@@ -0,0 +1,179 @@
+"""
+Edge case tests to achieve 100% code coverage
+"""
+
+import pytest
+from poker.card import Card, Rank, ShortDeckRank, Suit
+from poker.hand_evaluator import HandEvaluator
+from poker.hand_ranking import HandType, HandRanking
+from shortdeck.hand_ranking import ShortDeckHandType, ShortDeckHandRanking
+
+
+class TestCoverageEdgeCases:
+    """Tests for edge cases to improve code coverage"""
+    
+    def test_rank_comparison_with_invalid_types(self):
+        """Test rank comparisons with invalid types"""
+        rank = Rank.ACE
+        
+        # Test __eq__ with non-Rank object
+        result = rank.__eq__("invalid")
+        assert result is NotImplemented
+        
+        # Test __lt__ with non-Rank object  
+        result = rank.__lt__("invalid")
+        assert result is NotImplemented
+        
+    def test_shortdeck_rank_comparison_with_invalid_types(self):
+        """Test short deck rank comparisons with invalid types"""
+        rank = ShortDeckRank.ACE
+        
+        # Test __eq__ with non-ShortDeckRank object
+        result = rank.__eq__("invalid")
+        assert result is NotImplemented
+        
+        # Test __lt__ with non-ShortDeckRank object
+        result = rank.__lt__("invalid")
+        assert result is NotImplemented
+        
+    def test_card_creation_with_valid_ranks(self):
+        """Test Card creation with valid ranks"""
+        # Standard deck card
+        card1 = Card(Rank.ACE, Suit.HEARTS)
+        assert card1.rank == Rank.ACE
+        assert card1.suit == Suit.HEARTS
+        assert not card1.is_short_deck()
+        
+        # Short deck card
+        card2 = Card(ShortDeckRank.ACE, Suit.HEARTS)
+        assert card2.rank == ShortDeckRank.ACE
+        assert card2.suit == Suit.HEARTS
+        assert card2.is_short_deck()
+            
+    def test_hand_evaluator_exactly_5_cards_error(self):
+        """Test HandEvaluator with wrong number of cards"""
+        cards = [Card(Rank.ACE, Suit.HEARTS)]  # Only 1 card
+        
+        with pytest.raises(ValueError, match="Expected 5 cards, got 1"):
+            HandEvaluator.evaluate_5_cards(cards)
+            
+    def test_hand_ranking_comparison_with_invalid_types(self):
+        """Test HandRanking comparisons with invalid types"""
+        cards = [
+            Card(Rank.ACE, Suit.HEARTS),
+            Card(Rank.KING, Suit.HEARTS), 
+            Card(Rank.QUEEN, Suit.HEARTS),
+            Card(Rank.JACK, Suit.HEARTS),
+            Card(Rank.TEN, Suit.HEARTS)
+        ]
+        
+        ranking = HandRanking(HandType.ROYAL_FLUSH, [Rank.ACE], cards)
+        
+        # Test comparisons with non-HandRanking objects should return False, not NotImplemented
+        assert ranking != "invalid"
+        assert not (ranking == "invalid")
+        
+        # These should not raise exceptions
+        try:
+            ranking < "invalid"
+            ranking <= "invalid" 
+            ranking > "invalid"
+            ranking >= "invalid"
+        except TypeError:
+            pass  # Expected behavior
+        
+    def test_shortdeck_hand_ranking_comparison_with_invalid_types(self):
+        """Test ShortDeckHandRanking comparisons with invalid types"""
+        cards = [
+            Card(ShortDeckRank.ACE, Suit.HEARTS),
+            Card(ShortDeckRank.KING, Suit.HEARTS),
+            Card(ShortDeckRank.QUEEN, Suit.HEARTS),
+            Card(ShortDeckRank.JACK, Suit.HEARTS),
+            Card(ShortDeckRank.TEN, Suit.HEARTS)
+        ]
+        
+        ranking = ShortDeckHandRanking(ShortDeckHandType.ROYAL_FLUSH, [ShortDeckRank.ACE], cards)
+        
+        # Test comparisons with non-ShortDeckHandRanking objects
+        assert ranking != "invalid"
+        assert not (ranking == "invalid")
+        
+    def test_card_comparison_and_equality(self):
+        """Test Card comparison and equality edge cases"""
+        card1 = Card(Rank.ACE, Suit.HEARTS)
+        card2 = Card(Rank.ACE, Suit.HEARTS)
+        card3 = Card(Rank.KING, Suit.HEARTS)
+        
+        # Test equality
+        assert card1 == card2
+        assert card1 != card3
+        
+        # Test comparison
+        assert card1 > card3  # Ace > King
+        
+        # Test inequality with non-Card object
+        result = card1.__eq__("not a card")
+        assert result is NotImplemented
+        
+        result = card1.__lt__("not a card") 
+        assert result is NotImplemented
+        
+    def test_rank_hash_consistency(self):
+        """Test rank hash consistency"""
+        rank1 = Rank.ACE
+        rank2 = Rank.ACE
+        rank3 = Rank.KING
+        
+        assert hash(rank1) == hash(rank2)
+        assert hash(rank1) != hash(rank3)
+        
+    def test_shortdeck_rank_hash_consistency(self):
+        """Test short deck rank hash consistency"""
+        rank1 = ShortDeckRank.ACE
+        rank2 = ShortDeckRank.ACE
+        rank3 = ShortDeckRank.KING
+        
+        assert hash(rank1) == hash(rank2)
+        assert hash(rank1) != hash(rank3)
+        
+    def test_card_string_parsing_valid_cases(self):
+        """Test valid card string parsing cases"""
+        # Test valid input
+        cards = Card.parse_cards("As Kh")
+        assert len(cards) == 2
+        assert cards[0].rank == Rank.ACE
+        assert cards[0].suit == Suit.SPADES
+        assert cards[1].rank == Rank.KING
+        assert cards[1].suit == Suit.HEARTS
+        
+        # Test empty string returns empty list
+        cards = Card.parse_cards("")
+        assert len(cards) == 0
+    
+    def test_card_getter_methods(self):
+        """Test Card getter methods for coverage"""
+        card = Card(Rank.ACE, Suit.HEARTS)
+        assert card.get_rank() == Rank.ACE
+        assert card.get_suit() == Suit.HEARTS
+        
+    def test_card_legacy_parse_methods(self):
+        """Test legacy parsing methods"""
+        # Test parseLongCards method
+        cards = Card.parseLongCards("As Kh")
+        assert len(cards) == 2
+        
+        # Test parse_short_deck_cards method  
+        cards = Card.parse_short_deck_cards("As Kh")
+        assert len(cards) == 2
+    
+    def test_hand_type_comparisons_with_invalid_types(self):
+        """Test HandType comparisons with invalid types"""
+        hand_type = HandType.ROYAL_FLUSH
+        
+        # Test __lt__ with invalid type
+        result = hand_type.__lt__("invalid")
+        assert result is NotImplemented
+        
+        # Test __eq__ with invalid type
+        result = hand_type.__eq__("invalid")
+        assert result is NotImplemented

tests/test_hand_evaluator.py

@@ -14,7 +14,7 @@ class TestHandEvaluator:
     def test_royal_flush(self):
         """Test royal flush detection"""
         cards_str = "AhKhQhJhTh2c3c"
-        ranking = HandEvaluator.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput("AsKh")
+            HandEvaluator.evaluate_from_input("AsKh")
         
         with pytest.raises(ValueError):
-            HandEvaluator.evaluateFromInput("AsKhQdJc9h8s7d6c")
+            HandEvaluator.evaluate_from_input("AsKhQdJc9h8s7d6c")
     
     def test_invalid_card_format(self):
         """Test error handling for invalid card format"""
         with pytest.raises(ValueError):
-            HandEvaluator.evaluateFromInput("AsKhQdJcXh8s7d")
+            HandEvaluator.evaluate_from_input("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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
         
         assert ranking.hand_type == HandType.FLUSH
         assert ranking.key_ranks[0] == Rank.ACE
@@ -155,6 +155,6 @@ class TestHandEvaluator:
             Card(Rank.ACE, Suit.CLUBS),
             Card(Rank.KING, Suit.SPADES)
         ]
-        ranking = HandEvaluator.evaluate5Cards(cards)
+        ranking = HandEvaluator.evaluate_5_cards(cards)
         assert ranking.hand_type == HandType.FOUR_OF_A_KIND
         assert ranking.key_ranks[0] == Rank.ACE

tests/test_integration.py

@@ -15,7 +15,7 @@ class TestMainProgram:
     def test_example_input(self):
         """Test the example input from the requirements"""
         cards_str = "AsKs AhAdAc6s7s"
-        ranking = HandEvaluator.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
         
         assert str(ranking) == "Quad(A)"
     
@@ -35,13 +35,13 @@ class TestMainProgram:
         ]
         
         for cards_str, expected_result in test_cases:
-            ranking = HandEvaluator.evaluateFromInput(cards_str)
+            ranking = HandEvaluator.evaluate_from_input(cards_str)
             assert str(ranking) == expected_result, f"Failed for {cards_str}"
     
     def test_wheel_straight(self):
         """Test A-2-3-4-5 straight"""
         cards_str = "As2h3d4c5h7s8s"
-        ranking = HandEvaluator.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
         
         assert str(ranking) == "Straight(5 high)"
     
@@ -56,29 +56,29 @@ class TestMainProgram:
         expected_result = "Quad(A)"
         
         for cards_str in formats:
-            ranking = HandEvaluator.evaluateFromInput(cards_str)
+            ranking = HandEvaluator.evaluate_from_input(cards_str)
             assert str(ranking) == expected_result
     
     def test_case_insensitive_suits(self):
         """Test that suits are case insensitive"""
         cards_str = "AsKsAhAdAc6s7s"
-        ranking = HandEvaluator.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
         
         assert str(ranking) == "Quad(A)"
     
     def test_edge_cases(self):
         """Test edge cases and boundary conditions"""
         cards_str = "2s2h2d2c3s4h5d"
-        ranking = HandEvaluator.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
         assert str(ranking) == "Quad(2)"
         
         # Minimum straight
         cards_str = "As2h3d4c5h6s7s"
-        ranking = HandEvaluator.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(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.evaluateFromInput(cards_str)
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
         assert str(ranking) == "Straight(A high)"