public void ThreeOfAKindShouldReturnSumOfThreeNumbers(List <int> rolledDice, int expectedOutcome)
{
var threeOfAKind = new ThreeOfAKind();
var result = threeOfAKind.CalculateScore(rolledDice);
Assert.Equal(expectedOutcome, result);
}
public void ShouldSayIfThreeOfAKind()
{
Hand theHand = new Hand("7H, 4D, 8S, 7C, 7H");
ThreeOfAKind tOaKind = new ThreeOfAKind();
var result = tOaKind.IsTypeOf(theHand);
Assert.That(result, Is.EqualTo(true));
}
public void GivenHandCardThenCheckIfThreeOfAKind(string handCard, bool expectedResult)
{
var handCardFormatted = Common.ConvertCardStringToList(handCard);
var isStraightFlush = new ThreeOfAKind().IsThisType(handCardFormatted);
Assert.True(isStraightFlush == expectedResult);
}
public bool IsTypeOf(Hand theHand)
{
var tOAKind = new ThreeOfAKind();
var pair = new Pair();
var isTOAKind = tOAKind.IsTypeOf(theHand);
var isPair = pair.IsTypeOf(theHand);
return(isPair && isTOAKind);
}
public void Constructor_WithValidCardsForThreeOfAKind_StoresSortedThreeOfAKindCards()
{
List <Card> cards = TestUtil.CreateDefaultThreeOfAKindCards();
ThreeOfAKind hand = new ThreeOfAKind(cards);
Assert.IsTrue(hand.highestThreeOfAKind.Contains(new Card(CardValue.Seven, Suit.Heart)));
Assert.IsTrue(hand.highestThreeOfAKind.Contains(new Card(CardValue.Seven, Suit.Spade)));
Assert.IsTrue(hand.highestThreeOfAKind.Contains(new Card(CardValue.Seven, Suit.Club)));
Assert.AreEqual(hand.kickerCards[0], new Card(CardValue.Eight, Suit.Diamond));
Assert.AreEqual(hand.kickerCards[1], new Card(CardValue.Four, Suit.Heart));
}
private List <Category> GetFullHouse(Dice dice)
{
var pairs = GetFrequencyTable(dice).Where(ValueIs(2)).Select(x => new Pair(x.Key, x.Key));
Pair pair = Head(pairs);
ThreeOfAKind threeOfAKind = Head(GetThreeOfAKind(dice));
return((IsAnyNull(pair, threeOfAKind))
? new List <Category>()
: new List <Category> {
new FullHouse(pair, threeOfAKind)
});
}
public void IsThreeOfAKind()
{
_cardHand = new List <Card> {
new Card(CardRank.Ace, CardSuit.Spades),
new Card(CardRank.Eight, CardSuit.Hearts),
new Card(CardRank.Eight, CardSuit.Spades),
new Card(CardRank.Eight, CardSuit.Clubs),
new Card(CardRank.Two, CardSuit.Spades)
};
var hand = new ThreeOfAKind();
Assert.IsTrue(hand.HasHand(_cardHand));
}
public void CompareTo_ComparesThreeOfAKindHands_ReturnsComparison()
{
List <Card> cards1 = TestUtil.CreateDefaultThreeOfAKindCards();
ThreeOfAKind hand1 = new ThreeOfAKind(cards1);
List <Card> cards2 = new List <Card>
{
new Card(CardValue.Five, Suit.Heart),
new Card(CardValue.Five, Suit.Spade),
new Card(CardValue.Five, Suit.Club),
new Card(CardValue.Seven, Suit.Diamond),
new Card(CardValue.Three, Suit.Heart)
};
ThreeOfAKind hand2 = new ThreeOfAKind(cards2);
Assert.IsTrue(hand1.CompareTo(hand2) > 0);
}
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 ThreeOfAKindUnitTests_1()
{
var threeOfAKindHands = new Dictionary <long, string>()
{
//{0x0008004002001000, string.Empty}, // 0000 0000 0000/0000 0000.0000 0/100.0000 0000.00/10 0000.0000 001/1.0001 0001.0001
{ 0x0000000004002117, string.Empty }, // 0000 0000 0000/0000 0000.0000 0/000.0000 0000.01/00 0000.0000 001/0.0001 0001.0111
{ 0x000000000C007003, string.Empty }, // 0000 0000 0000/0000 0000.0000 0/000.0000 0000.11/00 0000.0000 011/1.0000 0000.0011
{ 0x0004000008007003, string.Empty } // 0000 0000 0000/0100 0000.0000 0/000.0000 0000.01/00 0000.0000 011/1.0000 0000.0011
};
var pht = new ThreeOfAKind();
foreach (var hand in threeOfAKindHands)
{
var ph = new PokerHand(hand.Key);
Assert.True(pht.Parse(ph), hand.Value);
Assert.Equal(PokerHandAnalyzer.Strength.ThreeOfAKind, ph.Strength);
}
}
private static Subset GetSubset(SubsetType type, List<Card> sortedCards)
{
Subset result = new HighCard(sortedCards);
switch (type) {
case SubsetType.FourOfAKind:
result = new FourOfAKind(sortedCards);
break;
case SubsetType.Flush:
result = new Flush(sortedCards);
break;
case SubsetType.ThreeOfAKind:
result = new ThreeOfAKind(sortedCards);
break;
case SubsetType.TwoOfAKind:
result = new TwoOfAKind(sortedCards);
break;
default:
break;
}
return result;
}
public void SetUp()
{
_sut = new ThreeOfAKind();
}
public ThreeOfAKindTests()
{
_threeOfAKind = new ThreeOfAKind();
}
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()
{
_threeOfAKind = new ThreeOfAKind();
}
private void AssertArgumentNullException(Pair pair, ThreeOfAKind threeOfAKind) => Assert.Throws <ArgumentNullException>(() => new FullHouse(pair, threeOfAKind));
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);
}
