def test_expected(self):
        low_straight_flush_hand = Hand(
            [
                Ace(Suit.Clubs),
                Two(Suit.Clubs),
                Three(Suit.Clubs),
                Four(Suit.Clubs),
                Five(Suit.Clubs)
            ]
        )

        self.assertTrue(StraightFlushVerifier.verify_hand_ranking(low_straight_flush_hand))

        high_straight_flush_hand = Hand(
            [
                Ace(Suit.Clubs),
                Queen(Suit.Clubs),
                Ten(Suit.Clubs),
                King(Suit.Clubs),
                Jack(Suit.Clubs)
            ]
        )

        self.assertTrue(StraightFlushVerifier.verify_hand_ranking(high_straight_flush_hand))

        straight_hand = Hand(
            [
                Ace(Suit.Hearts),
                Queen(Suit.Clubs),
                Ten(Suit.Clubs),
                King(Suit.Diamonds),
                Jack(Suit.Clubs)
            ]
        )

        self.assertFalse(StraightFlushVerifier.verify_hand_ranking(straight_hand))

        flush_hand = Hand(
            [
                Ace(Suit.Clubs),
                Three(Suit.Clubs),
                Ten(Suit.Clubs),
                King(Suit.Clubs),
                Jack(Suit.Clubs)
            ]
        )

        self.assertFalse(StraightFlushVerifier.verify_hand_ranking(flush_hand))
 def calculate_hand_ranking(hand):
     if StraightFlushVerifier.verify_hand_ranking(hand):
         return StraightFlushCalculator.calculate_hand_ranking(hand)
     else:
         if FourOfAKindVerifier.verify_hand_ranking(hand):
             return FourOfAKindCalculator.calculate_hand_ranking(hand)
         else:
             if FullHouseVerifier.verify_hand_ranking(hand):
                 return FullHouseCalculator.calculate_hand_ranking(hand)
             else:
                 if FlushVerifier.verify_hand_ranking(hand):
                     return FlushCalculator.calculate_hand_ranking(hand)
                 else:
                     if StraightVerifier.verify_hand_ranking(hand):
                         return StraightCalculator.calculate_hand_ranking(hand)
                     else:
                         if ThreeOfAKindVerifier.verify_hand_ranking(hand):
                             return ThreeOfAKindCalculator.calculate_hand_ranking(hand)
                         else:
                             if TwoPairVerifier.verify_hand_ranking(hand):
                                 return TwoPairCalculator.calculate_hand_ranking(hand)
                             else:
                                 if OnePairVerifier.verify_hand_ranking(hand):
                                     return OnePairCalculator.calculate_hand_ranking(hand)
                                 else:
                                     if HighCardVerifier.verify_hand_ranking(hand):
                                         return HighCardCalculator.calculate_hand_ranking(hand)
                                     else:
                                         raise RuntimeError("unknown hand ranking")
 def calculate_hand_ranking(hand):
     if StraightVerifier.verify_hand_ranking(hand) and not StraightFlushVerifier.verify_hand_ranking(hand):
         # Check for low straight case
         if any(isinstance(card, Ace) for card in hand.cards) and any(isinstance(card, Two) for card in hand.cards) and any(isinstance(card, Three) for card in hand.cards) and any(isinstance(card, Four) for card in hand.cards) and any(isinstance(card, Five) for card in hand.cards):
             high_value = [card for card in hand.cards if isinstance(card, Five)][0].value
             return Straight(high_value)
         high_value = sorted([card.value for card in hand.cards], reverse=True)[0]
         return Straight(high_value)
     else:
         raise RuntimeError("hand is not straight")
 def calculate_hand_ranking(hand):
     if FlushVerifier.verify_hand_ranking(hand) and not StraightFlushVerifier.verify_hand_ranking(hand):
         suit = hand.cards[0].suit
         sorted_card_values = sorted([card.value for card in hand.cards], reverse=True)
         return Flush(
             suit,
             first_kicker=sorted_card_values[0],
             second_kicker=sorted_card_values[1],
             third_kicker=sorted_card_values[2],
             fourth_kicker=sorted_card_values[3],
             fifth_kicker=sorted_card_values[4]
         )
     else:
         raise RuntimeError("hand is not flush")
 def calculate_hand_ranking(hand):
     if StraightFlushVerifier.verify_hand_ranking(hand):
         # Check for low straight case
         if any(isinstance(card, Ace) for card in hand.cards) and any(isinstance(card, Two) for card in hand.cards) and any(isinstance(card, Three) for card in hand.cards) and any(isinstance(card, Four) for card in hand.cards) and any(isinstance(card, Five) for card in hand.cards):
             high_card = [card for card in hand.cards if isinstance(card, Five)][0]
             return StraightFlush(high_card)
         high_card_value = 0
         high_card = None
         for card in hand.cards:
             if card.value > high_card_value:
                 high_card = card
                 high_card_value = card.value
         return StraightFlush(high_card)
     else:
         raise RuntimeError("hand is not straight flush")