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();
}
