public void poker_hand_evaluator_test_two_pair()
        {
            RankedHand hand1 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Three, CardSuit.Clubs),
                new Card(CardValue.Three, CardSuit.Hearts),
                new Card(CardValue.Two, CardSuit.Diamonds),
                new Card(CardValue.Jack, CardSuit.Clubs),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Two, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.TwoPair, hand1.Rank);
            Assert.AreEqual(new Card(CardValue.Jack, CardSuit.Clubs).ToString(), new List <Card>(hand1.Kickers).First().ToString());
            Assert.AreEqual(1, hand1.Kickers.Length);

            RankedHand hand2 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Ten, CardSuit.Hearts),
                new Card(CardValue.Nine, CardSuit.Diamonds),
                new Card(CardValue.Seven, CardSuit.Hearts),
                new Card(CardValue.Seven, CardSuit.Clubs),
                new Card(CardValue.Nine, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.TwoPair, hand2.Rank);
            Assert.AreEqual(CardValue.Seven, new List <Card>(hand2.Kickers).First().Value);
            Assert.AreEqual(1, hand2.Kickers.Length);
        }
        public void poker_hand_evaluator_test_four_of_a_kind()
        {
            RankedHand hand1 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Nine, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Clubs),
                new Card(CardValue.Nine, CardSuit.Spades),
                new Card(CardValue.Nine, CardSuit.Diamonds),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Nine, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.FourOfAKind, hand1.Rank);
            Assert.AreEqual(new Card(CardValue.King, CardSuit.Clubs).ToString(), new List <Card>(hand1.Kickers).First().ToString());
            Assert.AreEqual(1, hand1.Kickers.Length);

            RankedHand hand2 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Nine, CardSuit.Clubs),
                new Card(CardValue.Five, CardSuit.Clubs),
                new Card(CardValue.Nine, CardSuit.Spades),
                new Card(CardValue.Nine, CardSuit.Diamonds),
                new Card(CardValue.Six, CardSuit.Clubs),
                new Card(CardValue.Nine, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.FourOfAKind, hand2.Rank);
            Assert.AreEqual(CardValue.Six, new List <Card>(hand2.Kickers).First().Value);
            Assert.AreEqual(4, hand2.RankCards.Length);
            Assert.AreEqual(1, hand2.Kickers.Length);
        }
        public void poker_hand_evaluator_test_royal_flush()
        {
            RankedHand rankedHand1 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Ace, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Clubs),
                new Card(CardValue.Queen, CardSuit.Clubs),
                new Card(CardValue.Jack, CardSuit.Clubs),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Two, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.RoyalFlush, rankedHand1.Rank);

            Assert.AreEqual(Rank.RoyalFlush, _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Ace, CardSuit.Hearts),
                new Card(CardValue.King, CardSuit.Clubs),
                new Card(CardValue.Queen, CardSuit.Clubs),
                new Card(CardValue.Jack, CardSuit.Clubs),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Two, CardSuit.Hearts),
                new Card(CardValue.Ace, CardSuit.Clubs),
            }).Rank);
        }
        public void poker_hand_evaluator_test_three_of_a_kind()
        {
            RankedHand hand1 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Three, CardSuit.Clubs),
                new Card(CardValue.Three, CardSuit.Hearts),
                new Card(CardValue.Three, CardSuit.Diamonds),
                new Card(CardValue.Jack, CardSuit.Clubs),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Two, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.ThreeOfAKind, hand1.Rank);
            Assert.AreEqual(new Card(CardValue.Jack, CardSuit.Clubs).ToString(), new List <Card>(hand1.Kickers).First().ToString());
            Assert.AreEqual(2, hand1.Kickers.Length);

            RankedHand hand2 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Seven, CardSuit.Clubs),
                new Card(CardValue.Seven, CardSuit.Hearts),
                new Card(CardValue.Seven, CardSuit.Diamonds),
                new Card(CardValue.Five, CardSuit.Clubs),
                new Card(CardValue.Four, CardSuit.Clubs),
                new Card(CardValue.Two, CardSuit.Hearts),
                new Card(CardValue.Three, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.ThreeOfAKind, hand2.Rank);
            Assert.AreEqual(new Card(CardValue.Five, CardSuit.Clubs).ToString(), new List <Card>(hand2.Kickers).First().ToString());
            Assert.AreEqual(2, hand2.Kickers.Length);

            RankedHand hand3 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Seven, CardSuit.Clubs),
                new Card(CardValue.Seven, CardSuit.Hearts),
                new Card(CardValue.Seven, CardSuit.Diamonds),
                new Card(CardValue.King, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Diamonds),
                new Card(CardValue.King, CardSuit.Hearts),
                new Card(CardValue.Three, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.ThreeOfAKind, hand3.Rank);
            Assert.AreEqual(CardValue.King, hand3.RankCards[0].Value);
            Assert.AreEqual(2, hand3.Kickers.Length);
        }
        public void poker_hand_evaluator_test_full_house()
        {
            RankedHand hand = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Nine, CardSuit.Diamonds),
                new Card(CardValue.Nine, CardSuit.Hearts),
                new Card(CardValue.Nine, CardSuit.Clubs),
                new Card(CardValue.Jack, CardSuit.Diamonds),
                new Card(CardValue.Jack, CardSuit.Clubs),
                new Card(CardValue.Two, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.FullHouse, hand.Rank);
            Assert.AreEqual(5, hand.RankCards.Length);
            Assert.AreEqual(5, hand.Hand.Length);
        }
        public void poker_hand_evaluator_test_high_card()
        {
            RankedHand hand1 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Eight, CardSuit.Clubs),
                new Card(CardValue.Three, CardSuit.Hearts),
                new Card(CardValue.Ace, CardSuit.Diamonds),
                new Card(CardValue.Jack, CardSuit.Clubs),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Two, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.HighCard, hand1.Rank);
            Assert.AreEqual(new Card(CardValue.Jack, CardSuit.Clubs).ToString(), hand1.Kickers[0].ToString());
            Assert.AreEqual(new Card(CardValue.Ten, CardSuit.Clubs).ToString(), hand1.Kickers[1].ToString());
            Assert.AreEqual(new Card(CardValue.Eight, CardSuit.Clubs).ToString(), hand1.Kickers[2].ToString());
            Assert.AreEqual(new Card(CardValue.Five, CardSuit.Diamonds).ToString(), hand1.Kickers[3].ToString());
            Assert.AreEqual(4, hand1.Kickers.Length);
        }
        public void poker_hand_evaluator_test_straight()
        {
            Assert.AreEqual(Rank.Straight, _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Nine, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Hearts),
                new Card(CardValue.Queen, CardSuit.Diamonds),
                new Card(CardValue.Jack, CardSuit.Clubs),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Two, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Diamonds),
            }).Rank);

            Assert.AreEqual(Rank.Straight, _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Nine, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Hearts),
                new Card(CardValue.Queen, CardSuit.Clubs),
                new Card(CardValue.Jack, CardSuit.Diamonds),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Nine, CardSuit.Hearts),
                new Card(CardValue.Nine, CardSuit.Diamonds),
            }).Rank);

            Assert.AreEqual(Rank.Straight, _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Ace, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Hearts),
                new Card(CardValue.Queen, CardSuit.Clubs),
                new Card(CardValue.Jack, CardSuit.Diamonds),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Nine, CardSuit.Hearts),
                new Card(CardValue.Nine, CardSuit.Diamonds),
            }).Rank);

            RankedHand hand1 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Ace, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Hearts),
                new Card(CardValue.Queen, CardSuit.Clubs),
                new Card(CardValue.Jack, CardSuit.Diamonds),
                new Card(CardValue.Ten, CardSuit.Clubs),
                new Card(CardValue.Nine, CardSuit.Hearts),
                new Card(CardValue.Nine, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.Straight, hand1.Rank);
            Assert.AreEqual(5, hand1.RankCards.Length);


            RankedHand hand2 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Jack, CardSuit.Clubs),
                new Card(CardValue.Ace, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Diamonds),
                new Card(CardValue.Three, CardSuit.Clubs),
                new Card(CardValue.Four, CardSuit.Hearts),
                new Card(CardValue.Two, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.Straight, hand2.Rank);
            Assert.AreEqual(5, hand2.RankCards.Length);

            RankedHand hand3 = _pokerHandEvaluator.EvaluateHand(new Card[]
            {
                new Card(CardValue.Ace, CardSuit.Clubs),
                new Card(CardValue.Ace, CardSuit.Hearts),
                new Card(CardValue.Five, CardSuit.Clubs),
                new Card(CardValue.King, CardSuit.Diamonds),
                new Card(CardValue.Three, CardSuit.Clubs),
                new Card(CardValue.Four, CardSuit.Hearts),
                new Card(CardValue.Two, CardSuit.Diamonds),
            });

            Assert.AreEqual(Rank.Straight, hand3.Rank);
            Assert.AreEqual(5, hand3.RankCards.Length);
        }