public void FourOfAKindShouldReturnSumOfFourNumbers(List <int> rolledDice, int expectedOutcome) { var fourOfAKind = new FourOfAKind(); var result = fourOfAKind.CalculateScore(rolledDice); Assert.Equal(expectedOutcome, result); }
public void Test_FourOfAKind_CreateInstance(string strCards, bool isValid) { var cards = Utils.ParseCards(strCards); var fourOfAKind = FourOfAKind.CreateInstance(cards); CreateInstanceHelper(fourOfAKind, HandRanks.FourOfAKind, cards, isValid); }
public void ShouldReturnFalseIfCountOfCardsIsLessThan4() { var myHand = new Hand("7H, 7C, 7S"); var result = new FourOfAKind().IsTypeOf(myHand); Assert.That(result, Is.EqualTo(false)); }
public void FourEightsAndNine() { // ARRANGE var fourAces = FourAcesAndANine().Cards.Where( c => Rank.ACE == c.Rank); var fourEights = fourAces.Select( c => new Card(Rank.EIGHT, c.Suit)).ToArray(); var game = new Game( fourEights[0], fourEights[1], fourEights[2], fourEights[3], CardBuilder.Nine().Spades()); // ACT var result = new FourOfAKind().Evaluate(game); // ASSERT Assert.IsTrue(result.Success()); CollectionAssert.AreEquivalent(fourEights.ToList(), result.UsedCards.ToList()); }
public void GivenHandCardThenCheckIfFourOfAKind(string handCard, bool expectedResult) { var handCardFormatted = Common.ConvertCardStringToList(handCard); var isStraightFlush = new FourOfAKind().IsThisType(handCardFormatted); Assert.True(isStraightFlush == expectedResult); }
public void ShouldSayIfFourOfAKind() { Hand theHand = new Hand("8D, 7D, 7S, 7C, 7H"); FourOfAKind fOaKind = new FourOfAKind(); var result = fOaKind.IsTypeOf(theHand); Assert.That(result, Is.EqualTo(true)); }
public void Test_FourOfAKind_EqualityOperators(string strInputA, string strInputB, bool areEqual) { var cardsA = Utils.ParseCards(strInputA); var cardsB = Utils.ParseCards(strInputB); var FourOfAKindOne = FourOfAKind.CreateInstance(cardsA); var FourOfAKindTwo = FourOfAKind.CreateInstance(cardsB); EqualityOperatorsHelper(FourOfAKindOne, FourOfAKindTwo, areEqual); }
public void Test_FourOfAKind_ComparableTests(string strInputA, string strInputB, int comp) { var cardsA = Utils.ParseCards(strInputA); var cardsB = Utils.ParseCards(strInputB); var fourOfAKindOne = FourOfAKind.CreateInstance(cardsA); var fourOfAKindTwo = FourOfAKind.CreateInstance(cardsB); ComparableTestsHelper(fourOfAKindOne, fourOfAKindTwo, comp); }
public void FourAcesAndNine() { // ARRANGE var game = FourAcesAndANine(); // ACT var result = new FourOfAKind().Evaluate(game); // ASSERT Assert.IsTrue(result.Success()); CollectionAssert.AreEquivalent(game.Cards.Where(c => Rank.ACE == c.Rank).ToList(), result.UsedCards.ToList()); }
public void IsFourOfAKind() { _cardHand = new List <Card> { new Card(CardRank.Ace, CardSuit.Clubs), new Card(CardRank.Ace, CardSuit.Spades), new Card(CardRank.Ace, CardSuit.Diamonds), new Card(CardRank.Ace, CardSuit.Hearts), new Card(CardRank.Two, CardSuit.Spades) }; var hand = new FourOfAKind(); Assert.IsTrue(hand.HasHand(_cardHand)); }
public void HandFourOfAKindTestDuplicate() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Clubes, "A")); cards.Add(new Card(Suits.Clubes, "A")); //Act FourOfAKind hand = new FourOfAKind(); //Assert Assert.ThrowsException <InvalidOperationException>(() => hand.IsMatch(cards)); }
public void Test_FourOfAKind_EqualityOperators_ForNull() { var cards = Utils.ParseCards("7H 7C 7D 7S 8H"); var fourOfAKind = FourOfAKind.CreateInstance(cards); Assert.False(fourOfAKind.Equals(null)); Assert.True((FourOfAKind)null == (FourOfAKind)null); Assert.False((FourOfAKind)null == fourOfAKind); Assert.False(fourOfAKind == (FourOfAKind)null); Assert.False((FourOfAKind)null != (FourOfAKind)null); Assert.True((FourOfAKind)null != fourOfAKind); Assert.True(fourOfAKind != (FourOfAKind)null); }
public void FourOfAKindUnitTests_1() { var fourOfAKindHands = new Dictionary <long, string>() { { 0x0008004002001000, string.Empty }, // 0000 0000 0000/1000 0000.0000 0/100.0000 0000.00/10 0000.0000 000/1.0000 0000.0000 { 0x0008004002001007, string.Empty } // 0000 0000 0000/1000 0000.0000 0/100.0000 0000.00/10 0000.0000 000/1.0000 0000.0111 }; var pht = new FourOfAKind(); foreach (var hand in fourOfAKindHands) { var ph = new PokerHand(hand.Key); Assert.True(pht.Parse(ph), hand.Value); Assert.Equal(PokerHandAnalyzer.Strength.FourOfAKind, ph.Strength); } }
public void HandIsNotHandFourOfAKind() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Hearts, 3)); cards.Add(new Card(Suits.Hearts, "A")); cards.Add(new Card(Suits.Spades, 4)); cards.Add(new Card(Suits.Clubes, 3)); cards.Add(new Card(Suits.Hearts, "K")); cards.Add(new Card(Suits.Dimensions, 3)); cards.Add(new Card(Suits.Hearts, "J")); //Act FourOfAKind fourOfAKind = new FourOfAKind(); //Assert Assert.IsFalse(fourOfAKind.IsMatch(cards).HasValue); }
public void ShouldAcceptDifferentCategories() { var value = 5; var sut = new Player(); var foak = new FourOfAKind(value, value, value, value); var toak = new ThreeOfAKind(value, value, value); var pair = new Pair(value, value); var expected = new List <Category> { foak, toak, pair }; sut.AddCategory(foak); sut.AddCategory(toak); sut.AddCategory(pair); var actual = sut.GetOccupiedCategories(); Assert.Equal(expected, actual); }
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 HandIsHandFourOfAKind() { //Arrange List <Card> cards = new List <Card>(); cards.Add(new Card(Suits.Hearts, 3)); cards.Add(new Card(Suits.Hearts, "A")); cards.Add(new Card(Suits.Spades, 3)); cards.Add(new Card(Suits.Clubes, 3)); cards.Add(new Card(Suits.Hearts, "K")); cards.Add(new Card(Suits.Dimensions, 3)); cards.Add(new Card(Suits.Hearts, "J")); //Act FourOfAKind h = new FourOfAKind(); Hand fourOfAKind = h.IsMatch(cards).Value; //Assert Assert.IsNotNull(fourOfAKind); Assert.AreEqual(5, fourOfAKind.CardsInTheHand.Count); Assert.AreEqual <int>(14, fourOfAKind.CardsInTheHand[4].Value); Assert.AreEqual(Constancts.HandRanks.FourOfAKind, fourOfAKind.Rank); }
private static decimal EvaluateDeck(List <Card> deck, out string playerHand) { deck.Sort(); SortBySuit(ref deck); playerHand = string.Empty; decimal res = 0; Combination var; var keys = new List <Card>(); if (Combination.IsStraight(deck) && Combination.IsFlush(deck)) { var = new StraightFlush(deck); playerHand = var.PlayerHand; res = var.Score; } else if (Combination.IsNofAKind(4, deck, out keys)) { var = new FourOfAKind(deck); playerHand = var.PlayerHand; res = var.Score; } else if (Combination.IsFullHouse(deck, out Card key)) { var = new FullHouse(deck); playerHand = var.PlayerHand; res = var.Score; } else if (Combination.IsFlush(deck)) { var = new Flush(deck); playerHand = var.PlayerHand; res = var.Score; } else if (Combination.IsStraight(deck)) { var = new Straight(deck); playerHand = var.PlayerHand; res = var.Score; } else if (Combination.IsNofAKind(3, deck, out keys)) { var = new ThreeOfAKind(deck); playerHand = var.PlayerHand; res = var.Score; } else if (Combination.IsTwoPairs(deck, out keys)) { var = new TwoPairs(deck); playerHand = var.PlayerHand; res = var.Score; } else if (Combination.IsNofAKind(2, deck, out keys)) { var = new Pair(deck); playerHand = var.PlayerHand; res = var.Score; } else { deck.Sort(); deck.Reverse(); var = new HighCard(deck); playerHand = var.PlayerHand; res = var.Score; } return(res); }
public void shouldBeAbleToIdentifyFourOfAKindWhereHighCardIsNotOneOfTheFourOfAKind() { var ProvidedCards = new string[] {"K-C", "Q-S", "J-H", "9-D", "6-D", "5-S", "3-S", "3-H", "3-C", "3-D"}.Select( cardString => { var cb = new CardBuilder(); return cb.fromString(cardString); } ).ToList(); var ExpectedBestHand = new FourOfAKind( new string[] {"K-C", "3-S", "3-H", "3-C", "3-D"}.Select( cardString => { var cb = new CardBuilder(); return cb.fromString(cardString); } ).ToList() ); IdentifiedHand = HandIdentifier.identify(ProvidedCards); Assert.AreEqual(ExpectedBestHand, IdentifiedHand, "{0} was expected but {1} was identified", ExpectedBestHand, IdentifiedHand); }
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() { _sut = new FourOfAKind(); }
public FourOfAKindTests() { _fourOfAKind = new FourOfAKind(); }