Example #1
0
        public void hand_with_the_same_cards_Tie()
        {
            List <Card> aceHighHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.King
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            Assert.AreEqual(null, Poker.CalculateWinningHand(aceHighHand, aceHighHand));
        }
        public void hand_with_two_pair_wins_by_high_card()
        {
            var fivesAndTwosAceHighHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            var fivesAndTwosQueenHighHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Queen
                },
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            var actualWinningHand = Poker.CalculateWinningHand(fivesAndTwosQueenHighHand, fivesAndTwosAceHighHand);

            var expectedWinningHand = fivesAndTwosAceHighHand;

            Assert.AreEqual(expectedWinningHand, actualWinningHand);
        }
        public void hand_with_two_pair_wins_against_a_pair()
        {
            var fivesAndTwosHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            var pairOfJacksHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Nine
                }
            };

            var actualWinningHand = Poker.CalculateWinningHand(pairOfJacksHand, fivesAndTwosHand);

            var expectedWinningHand = fivesAndTwosHand;

            Assert.AreEqual(expectedWinningHand, actualWinningHand);
        }
Example #4
0
        public void hand_with_the_same_high_card_but_high_kicker_Wins()
        {
            List <Card> aceHighHandQueenKicker = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Queen
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Ace
                }
            };

            List <Card> aceHighHandKingKicker = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.King
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            List <Card> actualWinningHand = Poker.CalculateWinningHand(aceHighHandKingKicker, aceHighHandQueenKicker);

            List <Card> expectedWinningHand = aceHighHandKingKicker;

            Assert.AreEqual(expectedWinningHand, actualWinningHand);
        }
Example #5
0
        public void hand_with_highest_card_wins()
        {
            List <Card> aceHighHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.King
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            List <Card> kingHighHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.King
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            List <Card> actualWinningHand = Poker.CalculateWinningHand(kingHighHand, aceHighHand);

            List <Card> expectedWinningHand = aceHighHand;

            Assert.AreEqual(expectedWinningHand, actualWinningHand);
        }
        public void hand_with_a_higher_pair_wins_against_lower_pair()
        {
            List <Card> PairOfAcesHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.King
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                }
            };

            List <Card> PairOfTwosHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            List <Card> actualWinningHand = Poker.CalculateWinningHand(PairOfTwosHand, PairOfAcesHand);

            List <Card> expectedWinningHand = PairOfAcesHand;

            Assert.AreEqual(expectedWinningHand, actualWinningHand);
        }
        public void hand_with_same_pair_but_higher_kicker_wins()
        {
            List <Card> PairOfAcesKingHighHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.King
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                }
            };

            List <Card> PairOfAcesJackHighHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Nine
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            List <Card> actualWinningHand = Poker.CalculateWinningHand(PairOfAcesJackHighHand, PairOfAcesKingHighHand);

            List <Card> expectedWinningHand = PairOfAcesKingHighHand;

            Assert.AreEqual(expectedWinningHand, actualWinningHand);
        }
        public void hand_with_better_trips_wins_against_lower_trips()
        {
            var tripFivesHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            var tripTwosHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Jack
                },
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Nine
                }
            };

            var actualWinningHand = Poker.CalculateWinningHand(tripTwosHand, tripFivesHand);

            var expectedWinningHand = tripFivesHand;

            Assert.AreEqual(expectedWinningHand, actualWinningHand);
        }
        public void hand_with_trips_but_better_kicker_wins()
        {
            var tripFivesAceKickerHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Ace
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                }
            };

            var tripFivesNineKickerHand = new List <Card>()
            {
                new Card()
                {
                    Rank = Rank.Two
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Five
                },
                new Card()
                {
                    Rank = Rank.Nine
                }
            };

            var actualWinningHand = Poker.CalculateWinningHand(tripFivesNineKickerHand, tripFivesAceKickerHand);

            var expectedWinningHand = tripFivesAceKickerHand;

            Assert.AreEqual(expectedWinningHand, actualWinningHand);
        }