public void HandIsStraightFlush5High() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Hearts, 3)); cards.Add(new Card(Suits.Hearts, 2)); cards.Add(new Card(Suits.Clubes, 3)); cards.Add(new Card(Suits.Hearts, 5)); cards.Add(new Card(Suits.Hearts, Constancts.CardValues.Ten)); cards.Add(new Card(Suits.Hearts, 4)); cards.Add(new Card(Suits.Hearts, Constancts.CardValues.Ace)); //Act StraightFlush h = new StraightFlush(); Hand straightFlush = h.IsMatch(cards).Value; //Assert Assert.IsNotNull(straightFlush); Assert.AreEqual(5, straightFlush.CardsInTheHand.Count); Assert.AreEqual <int>(5, straightFlush.CardsInTheHand[0].Value); Assert.AreEqual <int>(1, straightFlush.CardsInTheHand[4].Value); Assert.AreEqual("❤A", straightFlush.CardsInTheHand[4].ToString()); }
public void AceAsOne() { var hand1 = new StraightFlush(); hand1.SetCards(Cards.New() .Ace(Suit.Clubs) .Two(Suit.Clubs) .Three(Suit.Clubs) .Four(Suit.Clubs) .Five(Suit.Clubs) .Nine(Suit.Spades) .Ten(Suit.Spades)); var hand2 = new StraightFlush(); hand2.SetCards(Cards.New() .Two(Suit.Clubs) .Three(Suit.Clubs) .Four(Suit.Clubs) .Five(Suit.Clubs) .Six(Suit.Clubs) .Nine(Suit.Spades) .Jack(Suit.Spades)); Assert.IsTrue(hand1.IsPresent()); Assert.IsTrue(hand2.IsPresent()); Assert.Less(hand1, hand2); }
public void test_scores() { var highCard = new HighCard(); Assert.AreEqual(0, highCard.Score); var onePair = new OnePair(); Assert.AreEqual(1, onePair.Score); var twoPairs = new TwoPairs(); Assert.AreEqual(2, twoPairs.Score); var set = new Set(); Assert.AreEqual(3, set.Score); var straight = new Straight(); Assert.AreEqual(4, straight.Score); var flush = new Flush(); Assert.AreEqual(5, flush.Score); var fullHouse = new FullHouse(); Assert.AreEqual(6, fullHouse.Score); var quads = new Quads(); Assert.AreEqual(7, quads.Score); var straightFlush = new StraightFlush(); Assert.AreEqual(8, straightFlush.Score); var royalFlush = new RoyalFlush(); Assert.AreEqual(9, royalFlush.Score); }
public void Test_StraightFlush_CreateInstance(string strCards, bool isValid) { var cards = Utils.ParseCards(strCards); var straightFlush = StraightFlush.CreateInstance(cards); CreateInstanceHelper(straightFlush, HandRanks.StraightFlush, cards, isValid); }
public void GivenHandCardThenCheckIfStraightFlush(string handCard, bool expectedResult) { var handCardFormatted = Common.ConvertCardStringToList(handCard); var isStraightFlush = new StraightFlush().IsThisType(handCardFormatted); Assert.True(isStraightFlush == expectedResult); }
public void ShouldSayIfStraightFlush() { Hand theHand = new Hand("7H, 8H, 9H, 10H, JH"); StraightFlush sFlush = new StraightFlush(); var result = sFlush.IsTypeOf(theHand); Assert.That(result, Is.EqualTo(true)); }
public void Test_StraightFlush_EqualityOperators(string strStraightFlushOne, string strStraightFlushTwo, bool areEqual) { var cardsA = Utils.ParseCards(strStraightFlushOne); var cardsB = Utils.ParseCards(strStraightFlushTwo); var straightFlushOne = StraightFlush.CreateInstance(cardsA); var straightFlushTwo = StraightFlush.CreateInstance(cardsB); EqualityOperatorsHelper(straightFlushOne, straightFlushTwo, areEqual); }
public void Test_StraightFlush_ComparableTests(string strInputA, string strInputB, int comp) { var cardsA = Utils.ParseCards(strInputA); var cardsB = Utils.ParseCards(strInputB); var straightFlushOne = StraightFlush.CreateInstance(cardsA); var straightFlushTwo = StraightFlush.CreateInstance(cardsB); ComparableTestsHelper(straightFlushOne, straightFlushTwo, comp); }
public void SpadesTwoToSix() { // ARRANGE var game = StraightFlushGameBuilder.Spades() .From(Rank.TWO).To(Rank.SIX); // ACT var result = new StraightFlush().Evaluate(game); // ASSERT Assert.IsTrue(result.Success()); Assert.AreSame(game.Cards, result.UsedCards); }
public void DiamondsFiveToNine() { // ARRANGE var game = StraightFlushGameBuilder.Diamonds() .From(Rank.FIVE).To(Rank.NINE); // ACT var result = new StraightFlush().Evaluate(game); // ASSERT Assert.IsTrue(result.Success()); Assert.AreSame(game.Cards, result.UsedCards); }
public void HandStraightFlushTestDuplicate() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Clubes, "A")); cards.Add(new Card(Suits.Clubes, "A")); //Act StraightFlush hand = new StraightFlush(); //Assert Assert.ThrowsException <InvalidOperationException>(() => hand.IsMatch(cards)); }
public void IsStraightFlush() { _cardHand = new List <Card> { new Card(CardRank.Six, CardSuit.Clubs), new Card(CardRank.Five, CardSuit.Clubs), new Card(CardRank.Four, CardSuit.Clubs), new Card(CardRank.Three, CardSuit.Clubs), new Card(CardRank.Two, CardSuit.Clubs) }; var hand = new StraightFlush(); Assert.IsTrue(hand.HasHand(_cardHand)); }
public void Test_StraightFlush_EqualityOperators_ForNull() { var cards = Utils.ParseCards("4H 5H 6H 7H 8H"); var straintFlush = StraightFlush.CreateInstance(cards); Assert.False(straintFlush.Equals(null)); Assert.True((StraightFlush)null == (StraightFlush)null); Assert.False((StraightFlush)null == straintFlush); Assert.False(straintFlush == (StraightFlush)null); Assert.False((StraightFlush)null != (StraightFlush)null); Assert.True((StraightFlush)null != straintFlush); Assert.True(straintFlush != (StraightFlush)null); }
public void WrapAround() { // ARRANGE var game = new Game( CardBuilder.King().Hearths(), CardBuilder.Ace().Hearths(), CardBuilder.Two().Hearths(), CardBuilder.Three().Hearths(), CardBuilder.Four().Hearths()); // ACT var result = new StraightFlush().Evaluate(game); // ASSERT Assert.IsFalse(result.Success()); }
public void straightflush_no() { var set = new StraightFlush(); var cards = new List <Card> { new Card(Suit.Clubs, Rank.Ace), new Card(Suit.Diamonds, Rank.Ace), new Card(Suit.Spades, Rank.Ace), new Card(Suit.Hearts, Rank.King), new Card(Suit.Spades, Rank.Ten), new Card(Suit.Spades, Rank.King) }; set.SetCards(cards); var result = set.IsPresent(); Assert.IsFalse(result); }
/// <summary> /// Checks if 7 element StraightFlush combination is RoyalFlush /// </summary> /// <param name="cards"> /// Array of 5 cards /// </param> /// <returns> /// Cards in RoyalFlush combination if exits otherwise null /// </returns> public override Combination Check(Card[] cards) { Combination straightFlush = new StraightFlush(null).Check(cards, false); if (straightFlush == null) { Data.Combinations[CombinationType.StraightFlush] = null; return(null); } Data.Combinations[CombinationType.StraightFlush] = straightFlush.Cards; if (straightFlush.Cards[0].Rank == CardRank.Ace && straightFlush.Cards[4].Rank == CardRank.King) { return(new Combination(Type, cards)); } return(null); }
public void straightflush_yes() { var set = new StraightFlush(); var cards = new List <Card> { new Card(Suit.Spades, Rank.King), new Card(Suit.Spades, Rank.Jack), new Card(Suit.Spades, Rank.Queen), new Card(Suit.Spades, Rank.Nine), new Card(Suit.Spades, Rank.Ten), new Card(Suit.Diamonds, Rank.Six), new Card(Suit.Spades, Rank.Two) }; set.SetCards(cards); var result = set.IsPresent(); Assert.IsTrue(result); }
public void HandIsNotStraightFlush() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Clubes, 9)); cards.Add(new Card(Suits.Clubes, "J")); cards.Add(new Card(Suits.Clubes, 5)); cards.Add(new Card(Suits.Hearts, "A")); cards.Add(new Card(Suits.Clubes, "A")); cards.Add(new Card(Suits.Clubes, 8)); cards.Add(new Card(Suits.Clubes, 7)); //Act StraightFlush straightFlush = new StraightFlush(); //Assert Assert.IsFalse(straightFlush.IsMatch(cards).HasValue); }
public void StraightFlush_6_Is_Better_Than_StraightFlush_5() { const long straightFlushHand1 = 0x000000000000700F; // 0000 0000 0000/0000 0000.0000 0/000.0000 0000.00/00 0000.0000 011/1.0000 0000.1111 const long straightFlushHand2 = 0x000000000000301F; // 00000000 0000//0000 0000.0000 0/000.0000 0000.00/00 0000.0000 001/1.0000 0001.1111 var pht1 = new StraightFlush(); var ph1 = new PokerHand(straightFlushHand1); pht1.Parse(ph1); var ph2 = new PokerHand(straightFlushHand2); pht1.Parse(ph2); Assert.Equal(1, ph1.CompareTo(ph2)); Assert.Equal(-1, ph2.CompareTo(ph1)); ph2 = new PokerHand(straightFlushHand1); pht1.Parse(ph2); Assert.Equal(0, ph1.CompareTo(ph2)); }
public void StraightFlush_1() { var straightFlushHands = new Dictionary <long, string>() { { 0x000000000040201F, string.Empty }, // 00000000 0000//0000 0000.0000 0/000.0000 0000.00/00 0100.0000 001/0.0000 0001.1111 { 0x00000000004020F8, string.Empty }, { 0x00000F8000000000, string.Empty }, { 0x000F800000000000, string.Empty }, { 0x000000000040300F, "Hand got a `petite` straight flush i.e. 12345 " }, // 00000000 0000//0000 0000.0000 0/000.0000 0000.00/00 0100.0000 001/1.0000 0000.1111 }; var pht = new StraightFlush(); foreach (var hand in straightFlushHands) { var ph = new PokerHand(hand.Key); Assert.True(pht.Parse(ph), hand.Value); Assert.Equal(PokerHandAnalyzer.Strength.StraightFlush, ph.Strength); } }
public void StraightFlush_Is_Better_Than_FourOfAKind() { const long straightFlushHand = 0x000000000040201F; // 00000000 0000//0000 0000.0000 0/000.0000 0000.00/00 0100.0000 001/0.0000 0001.1111 const long fourOfAKindHand = 0x0008004002001000; // 0000 0000 0000/1000 0000.0000 0/100.0000 0000.00/10 0000.0000 000/1.0000 0000.0000 var pht1 = new StraightFlush(); var pht2 = new FourOfAKind(); var ph1 = new PokerHand(straightFlushHand); pht1.Parse(ph1); var ph2 = new PokerHand(fourOfAKindHand); pht2.Parse(ph2); Assert.Equal(-1, ph1.CompareTo(ph2)); Assert.Equal(1, ph2.CompareTo(ph1)); ph2 = new PokerHand(straightFlushHand); pht1.Parse(ph2); Assert.Equal(0, ph1.CompareTo(ph2)); }
public void HandIsRoyalFlush() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Hearts, "A")); cards.Add(new Card(Suits.Hearts, 3)); cards.Add(new Card(Suits.Hearts, "Q")); cards.Add(new Card(Suits.Clubes, 3)); cards.Add(new Card(Suits.Hearts, "K")); cards.Add(new Card(Suits.Hearts, "T")); cards.Add(new Card(Suits.Hearts, "J")); //Act StraightFlush h = new StraightFlush(); Hand straightFlush = h.IsMatch(cards).Value; //Assert Assert.IsNotNull(straightFlush); Assert.AreEqual(5, straightFlush.CardsInTheHand.Count); }
public void HandIsStraightFlush6High() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Hearts, 3)); cards.Add(new Card(Suits.Hearts, 2)); cards.Add(new Card(Suits.Clubes, 3)); cards.Add(new Card(Suits.Hearts, "A")); cards.Add(new Card(Suits.Hearts, 5)); cards.Add(new Card(Suits.Hearts, 4)); cards.Add(new Card(Suits.Hearts, 6)); //Act StraightFlush h = new StraightFlush(); Hand straightFlush = h.IsMatch(cards).Value; //Assert Assert.IsNotNull(straightFlush); Assert.AreEqual(5, straightFlush.CardsInTheHand.Count); Assert.AreEqual <int>(6, straightFlush.CardsInTheHand[0].Value); Assert.AreEqual <int>(2, straightFlush.CardsInTheHand[4].Value); }
public void HandIsStraightFlushJackHigh() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Clubes, 9)); cards.Add(new Card(Suits.Clubes, "J")); cards.Add(new Card(Suits.Clubes, "T")); cards.Add(new Card(Suits.Clubes, "K")); cards.Add(new Card(Suits.Clubes, "A")); cards.Add(new Card(Suits.Clubes, 8)); cards.Add(new Card(Suits.Clubes, 7)); //Act StraightFlush h = new StraightFlush(); Hand straightFlush = h.IsMatch(cards).Value; //Assert Assert.IsNotNull(straightFlush); Assert.AreEqual(5, straightFlush.CardsInTheHand.Count); Assert.AreEqual <int>(11, straightFlush.CardsInTheHand[0].Value); Assert.AreEqual <int>(7, straightFlush.CardsInTheHand[4].Value); Assert.AreEqual(Constancts.HandRanks.StraightFlush, straightFlush.Rank); }
public void SetupCardPattern() { var highCard = new HighCard(); var onePair = new OnePair(highCard); var twoPair = new TwoPair(onePair); var threeOfAKind = new ThreeOfAKind(twoPair); var straight = new Straight(threeOfAKind); var flush = new Flush(straight); var fullHouse = new FullHouse(flush); var fourOfAKind = new FourOfAKind(fullHouse); var straightFlush = new StraightFlush(fourOfAKind, straight, flush); var royalFlush = new RoyalFlush(straightFlush, straight, flush); cardHandIdentifier = royalFlush; pokerEngine = new PokerEngine(); }
private string GetScore(IPokerHand hand) { var royalFlush = new RoyalFlush(hand); if (royalFlush.IsHighRank) { return(royalFlush.Title); } var straightFlush = new StraightFlush(hand); if (straightFlush.IsHighRank) { return(straightFlush.Title); } var fourOfAKind = new FourOfAKind(hand); if (fourOfAKind.IsHighRank) { return(fourOfAKind.Title); } var fullHouse = new FullHouse(hand); if (fullHouse.IsHighRank) { return(fullHouse.Title); } var flush = new Flush(hand); if (flush.IsHighRank) { return(flush.Title); } var straight = new Straight(hand); if (straight.IsHighRank) { return(straight.Title); } var threeOfAKind = new ThreeOfAKind(hand); if (threeOfAKind.IsHighRank) { return(threeOfAKind.Title); } var twoPair = new TwoPair(hand); if (twoPair.IsHighRank) { return(twoPair.Title); } var onePair = new OnePair(hand); if (onePair.IsHighRank) { return(onePair.Title); } return("High Card"); }
public void Setup() { _straightFlush = new StraightFlush(); }