IsFourOfAKindShouldReturnTrueOnValidHand()
{
foreach (var hand in validHands)
{
Assert.IsTrue(pokerHandsChecker.IsFourOfAKind(hand), hand.ToString());
}
}
public void PokerHandsShouldReturnFalseIfIsInvalidInput_FourOfAKind()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
pokerChecker.IsFourOfAKind(InvalidHandWithEqualCards);
pokerChecker.IsFourOfAKind(InvalidHandWithSixCards);
pokerChecker.IsFourOfAKind(InvalidHandWithFourCards);
}
public void TestIsFourOfaKindInvalidHandShouldReturnFalse()
{
Card firstCard = new Card(CardFace.Ace, CardSuit.Clubs);
Card secondCard = new Card(CardFace.Ace, CardSuit.Hearts);
Card thirdCard = new Card(CardFace.Queen, CardSuit.Clubs);
Card fourthCard = new Card(CardFace.Jack, CardSuit.Clubs);
Card fifthCard = new Card(CardFace.Ace, CardSuit.Clubs);
List <ICard> Cards = new List <ICard>(new ICard[] { firstCard, secondCard, thirdCard, fourthCard, fifthCard });
Hand myHand = new Hand(Cards);
Assert.AreEqual(false, handTester.IsFourOfAKind(myHand));
}
public void PokerHandsChecker_IsFourOfAKind_MustBeTrue()
{
IList <ICard> cards = new List <ICard>
{
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Ten, CardSuit.Diamonds)
};
Hand hand = new Hand(cards);
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKindShouldReturnFalseIfLessThanFourOfTheCardsHasSameFace()
{
// Arrange
var firstCard = new Card(CardFace.Ace, CardSuit.Clubs);
var secondCard = new Card(CardFace.Jack, CardSuit.Hearts);
var thirdCard = new Card(CardFace.King, CardSuit.Clubs);
var fourthCard = new Card(CardFace.Ace, CardSuit.Clubs);
var fifthCard = new Card(CardFace.Ace, CardSuit.Clubs);
var cards = new List <ICard>()
{
firstCard,
secondCard,
thirdCard,
fourthCard,
fifthCard
};
var hand = new Hand(cards);
var handChecker = new PokerHandsChecker();
// Act
var result = handChecker.IsFourOfAKind(hand);
// Assert
Assert.IsFalse(result);
}
public void IsFourOfAKindShouldThrowAnExceptionWhenAHandWithNullCardsIsPassed()
{
List<ICard> cards = null;
var checker = new PokerHandsChecker();
checker.IsFourOfAKind(new Hand(cards));
}
public void IsFourOfAKind_ShouldReturnTrue_IfHandIsFourOfAKind()
{
IList <ICard> cards = new List <ICard>
{
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Queen, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Diamonds)
};
var hand = new Hand(cards);
var result = pokerHandsChecker.IsFourOfAKind(hand);
Assert.IsTrue(result);
}
public void IsFourOfAKind_ShouldReturnTrue_IfHandIsValidAndContainsFourCardsOfTheSameType()
{
var handChecker = new PokerHandsChecker();
var hand = new Hand(new List <ICard>
{
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Nine, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Clubs)
});
bool isTrue = handChecker.IsFourOfAKind(hand);
Assert.IsTrue(handChecker.IsFourOfAKind(hand));
}
public void IsFourOfAKindShouldReturnFalseWhenTwoPairsArePassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.King, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Hearts), new Card(CardFace.Ten, CardSuit.Diamonds) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKindShouldThrowAnExceptionWhenAnInvalidHandWithMoreThan5CardsIsPassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.King, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Clubs), new Card(CardFace.Three, CardSuit.Spades), new Card(CardFace.Four, CardSuit.Clubs), new Card(CardFace.Five, CardSuit.Clubs) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
checker.IsFourOfAKind(hand);
}
public void IsFourOfAKindShouldReturnTrueWhenAValidHandWithFourOfAKindCardsIsPassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.King, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Clubs), new Card(CardFace.King, CardSuit.Hearts), new Card(CardFace.King, CardSuit.Diamonds) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void PokerHandsChecker_IsFourOfAKindWithValidFourOfAKindHand_ShoudReturnTrue()
{
PokerHandsChecker checker = new PokerHandsChecker();
var actual = checker.IsFourOfAKind(ValidFourOfAKind);
var expected = true;
Assert.AreEqual(expected, actual);
}
public void IsFourOfAKindShouldReturnFalseWhenOnePairIsPassed()
{
var checker = new PokerHandsChecker();
var cards = new List<ICard> { new Card(CardFace.Four, CardSuit.Spades), new Card(CardFace.Four, CardSuit.Diamonds), new Card(CardFace.Six, CardSuit.Hearts), new Card(CardFace.Seven, CardSuit.Hearts), new Card(CardFace.Four, CardSuit.Hearts) };
var hand = new Hand(cards);
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void PokerHandsChecker_IsFourOfAKindWithInvalidFourOfAKindHand_ShoudReturnFalse()
{
PokerHandsChecker checker = new PokerHandsChecker();
var actual = checker.IsFourOfAKind(ValidFlush);
var expected = false;
Assert.AreEqual(expected, actual);
}
public void IsFourOfAKindShouldThrowNullReferenceException()
{
List <ICard> cards = null;
var hand = new Hand(cards);
var pokerHandsChecker = new PokerHandsChecker();
pokerHandsChecker.IsFourOfAKind(hand);
}
public void TestIsFourOfAKindHandWithInvalidFourOfAKind()
{
PokerHandsChecker checker = new PokerHandsChecker();
var cards = GenerateCorectCards();
var hand = new Hand(cards);
bool isFourOfAKind = checker.IsFourOfAKind(hand);
Assert.IsFalse(isFourOfAKind, "Hand is invalid flush and result mast be false.");
}
public void TestISFourOfAKindEmptyHand()
{
IList <ICard> cards = new List <ICard>();
Hand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
bool expected = false;
bool actual = checker.IsFourOfAKind(hand);
Assert.AreEqual(expected, actual);
}
public bool IsFourOfAKind_HandHasFourCardsOfTheSameFaceValue_ShouldReturnTrue(IHand hand)
{
// Arrange
var pokerHandChecker = new PokerHandsChecker();
// Act
var actualResult = pokerHandChecker.IsFourOfAKind(hand);
//Assert
return(actualResult);
}
public void IsFourOfAKind_HandHasThreeCardsOfTheSameFaceValue_ShouldReturnFalse()
{
// Arrange
var hand = new HandTypePresetsFakeHand(HandType.IsThreeOfAKind);
var pokerHandChecker = new PokerHandsChecker();
// Act
var actualResult = pokerHandChecker.IsFourOfAKind(hand);
//Assert
Assert.IsFalse(actualResult);
}
public void TestFourOfAKind()
{
List<ICard> cards = new List<ICard>();
cards.Add(new Card(CardFace.King, CardSuit.Diamonds));
cards.Add(new Card(CardFace.King, CardSuit.Spades));
cards.Add(new Card(CardFace.King, CardSuit.Hearts));
cards.Add(new Card(CardFace.King, CardSuit.Clubs));
cards.Add(new Card(CardFace.Ace, CardSuit.Clubs));
Hand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKindTrueTest1()
{
Card card1 = new Card(CardFace.Ace, CardSuit.Clubs);
Card card2 = new Card(CardFace.Ace, CardSuit.Spades);
Card card3 = new Card(CardFace.Ace, CardSuit.Diamonds);
Card card4 = new Card(CardFace.Ace, CardSuit.Hearts);
Card card5 = new Card(CardFace.Queen, CardSuit.Hearts);
Hand hand = new Hand(card1, card2, card3, card4, card5);
PokerHandsChecker checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void TestHighCard()
{
List<ICard> cards = new List<ICard>();
cards.Add(new Card(CardFace.Five, CardSuit.Diamonds));
cards.Add(new Card(CardFace.Eight, CardSuit.Spades));
cards.Add(new Card(CardFace.Three, CardSuit.Diamonds));
cards.Add(new Card(CardFace.Jack, CardSuit.Clubs));
cards.Add(new Card(CardFace.Queen, CardSuit.Spades));
Hand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void FourThrees()
{
PokerHandsChecker checker = new PokerHandsChecker();
Hand hand = new Hand(new List<ICard>() {
new Card(CardFace.Three, CardSuit.Clubs),
new Card(CardFace.Three, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Spades),
});
Assert.AreEqual(true, checker.IsFourOfAKind(hand));
}
public void InvalidFourOfAKind()
{
PokerHandsChecker checker = new PokerHandsChecker();
Hand hand = new Hand(new List<ICard>() {
new Card(CardFace.Ten, CardSuit.Spades),
new Card(CardFace.Five, CardSuit.Clubs),
new Card(CardFace.Five, CardSuit.Hearts),
new Card(CardFace.Five, CardSuit.Spades),
new Card(CardFace.King, CardSuit.Diamonds),
});
Assert.AreEqual(false, checker.IsFourOfAKind(hand));
}
public void FourTensTest()
{
PokerHandsChecker checker = new PokerHandsChecker();
List<ICard> cards = new List<ICard>()
{
new Card(CardFace.Ten, CardSuit.Spades),
new Card(CardFace.Ten, CardSuit.Diamonds),
new Card(CardFace.Ten, CardSuit.Hearts),
new Card(CardFace.Eight, CardSuit.Spades),
new Card(CardFace.Ten, CardSuit.Clubs),
};
Hand hand = new Hand(cards);
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKindIsValidOnlyIfTheHandIsValid()
{
List <ICard> cards = new List <ICard>();
for (int i = 0; i < 3; i++)
{
cards.Add(new Card((CardFace)i + 1, CardSuit.Diamonds));
}
Hand someHand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
Assert.AreEqual(false, checker.IsFourOfAKind(someHand));
}
public void TestHandChecker_PassValidFourOfKind_ShouldReturnTrue()
{
IList <ICard> cards = new List <ICard>
{
new Card(CardFace.Five, CardSuit.Diamonds),
new Card(CardFace.Five, CardSuit.Clubs),
new Card(CardFace.Five, CardSuit.Hearts),
new Card(CardFace.Four, CardSuit.Spades),
new Card(CardFace.Five, CardSuit.Spades)
};
var hand = new Hand(cards);
Assert.IsTrue(pokerChecker.IsFourOfAKind(hand));
}
public void TestForValidFourOfAKind()
{
Hand hand = new Hand(new List <ICard>());
PokerHandsChecker checker = new PokerHandsChecker();
hand.Cards.Add(new Card(CardFace.Jack, CardSuit.Diamonds));
hand.Cards.Add(new Card(CardFace.Jack, CardSuit.Clubs));
hand.Cards.Add(new Card(CardFace.Jack, CardSuit.Spades));
hand.Cards.Add(new Card(CardFace.Jack, CardSuit.Hearts));
hand.Cards.Add(new Card(CardFace.Two, CardSuit.Diamonds));
Assert.AreEqual(true, checker.IsValidHand(hand), "The test hand is valid so the checker does not work properly.");
Assert.AreEqual(true, checker.IsFourOfAKind(hand), "The test hand is valid four of a kind so the checker does not work properly.");
}
public void ThreeQueensTwoKindsTest()
{
PokerHandsChecker checker = new PokerHandsChecker();
List<ICard> cards = new List<ICard>()
{
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Queen, CardSuit.Spades),
new Card(CardFace.Queen, CardSuit.Diamonds),
new Card(CardFace.Queen, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Clubs),
};
Hand hand = new Hand(cards);
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void FourThrees()
{
PokerHandsChecker checker = new PokerHandsChecker();
Hand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Three, CardSuit.Clubs),
new Card(CardFace.Three, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Spades),
});
Assert.AreEqual(true, checker.IsFourOfAKind(hand));
}
public void InvalidHandWithMoreCardsForFourOfAKindTest()
{
var kingOfDiamonds = new Card(CardFace.King, CardSuit.Diamonds);
var queenOfDiamonds = new Card(CardFace.Queen, CardSuit.Diamonds);
var jackOfDiamonds = new Card(CardFace.Jack, CardSuit.Diamonds);
var fourOfHearts = new Card(CardFace.Four, CardSuit.Hearts);
var twoOfDiamongs = new Card(CardFace.Two, CardSuit.Diamonds);
var twoOfSpades = new Card(CardFace.Two, CardSuit.Spades);
var cards = new List <ICard>()
{
kingOfDiamonds,
queenOfDiamonds,
jackOfDiamonds,
fourOfHearts,
twoOfDiamongs,
twoOfSpades
};
var hand = new Hand(cards);
handsChecker.IsFourOfAKind(hand);
}
public void IsFourOfAKindShouldReturnTrueIfFourOfAKind()
{
var checker = new PokerHandsChecker();
var hand = new Hand(new List<ICard>
{
new Card(CardFace.Jack,CardSuit.Hearts),
new Card(CardFace.Queen,CardSuit.Hearts),
new Card(CardFace.Queen,CardSuit.Clubs),
new Card(CardFace.Queen,CardSuit.Spades),
new Card(CardFace.Queen,CardSuit.Diamonds)
});
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void InvalidFourOfAKind()
{
PokerHandsChecker checker = new PokerHandsChecker();
Hand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Ten, CardSuit.Spades),
new Card(CardFace.Five, CardSuit.Clubs),
new Card(CardFace.Five, CardSuit.Hearts),
new Card(CardFace.Five, CardSuit.Spades),
new Card(CardFace.King, CardSuit.Diamonds),
});
Assert.AreEqual(false, checker.IsFourOfAKind(hand));
}
public void IsFourOfAKindShouldReturnFalseWhenWorksWithMoreOrLessThanFiveCards()
{
var cards = new List <ICard>
{
new Card(CardFace.Eight, CardSuit.Diamonds),
new Card(CardFace.Eight, CardSuit.Clubs),
new Card(CardFace.Eight, CardSuit.Spades),
new Card(CardFace.Eight, CardSuit.Hearts),
};
var hand = new Hand(cards);
var pokerHandsChecker = new PokerHandsChecker();
Assert.IsFalse(pokerHandsChecker.IsFourOfAKind(hand), "IsFourOfAkind don't return correct result");
}
public void IsFourOfAKind_TestFourOfAKind_ShouldBeCorrect()
{
var checker = new PokerHandsChecker();
var cards = new List<ICard>
{
new Card(CardFace.Four, CardSuit.Spades),
new Card(CardFace.Five, CardSuit.Diamonds),
new Card(CardFace.Four, CardSuit.Diamonds),
new Card(CardFace.Four, CardSuit.Clubs),
new Card(CardFace.Four, CardSuit.Hearts)
};
var hand = new Hand(cards);
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKind_FourOfAKindWhithValidHand_ShouldReturnFalse()
{
Hand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Queen, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.King, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Diamonds),
new Card(CardFace.Jack, CardSuit.Diamonds),
});
IPokerHandsChecker checker = new PokerHandsChecker();
Assert.AreEqual(false, checker.IsFourOfAKind(hand));
}
public void IsFourOfAKind_WhithInValidHand_ShouldThrow()
{
Hand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Queen, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Diamonds),
});
IPokerHandsChecker checker = new PokerHandsChecker();
Assert.Throws(typeof(ArgumentException), new TestDelegate(() => { checker.IsFourOfAKind(hand); }), "IsFlush() with invalid hand should throw!");
}
public void IsFourOfAKindShouldReturnTrue()
{
var checker = new PokerHandsChecker();
var cards = new List <ICard>
{
new Card(CardFace.Four, CardSuit.Spades),
new Card(CardFace.Five, CardSuit.Diamonds),
new Card(CardFace.Four, CardSuit.Diamonds),
new Card(CardFace.Four, CardSuit.Clubs),
new Card(CardFace.Four, CardSuit.Hearts)
};
var hand = new Hand(cards);
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKindShouldReturnFalseWhenNotFourCardsWithTheSameFace_ThreeOfAKind()
{
var checker = new PokerHandsChecker();
var cards = new List<ICard>
{
new Card(CardFace.Four, CardSuit.Spades),
new Card(CardFace.Four, CardSuit.Diamonds),
new Card(CardFace.Four, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Clubs),
new Card(CardFace.Six, CardSuit.Hearts)
};
var hand = new Hand(cards);
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void TestIfIsFourOfAKindWillReturnFalseWithoutFourOfAKindCards()
{
var cards = new List <ICard>
{
new Card(CardFace.Eight, CardSuit.Diamonds),
new Card(CardFace.Eight, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Four, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Clubs),
};
var hand = new Hand(cards);
var pokerHandsChecker = new PokerHandsChecker();
Assert.IsFalse(pokerHandsChecker.IsFourOfAKind(hand), "IsFourOfAkind don't return correct result");
}
public void TestIfIsFourOfAKindReturnsCorrectResult()
{
var cards = new List <ICard>
{
new Card(CardFace.Eight, CardSuit.Diamonds),
new Card(CardFace.Eight, CardSuit.Clubs),
new Card(CardFace.Eight, CardSuit.Spades),
new Card(CardFace.Eight, CardSuit.Hearts),
new Card(CardFace.Seven, CardSuit.Spades),
};
var hand = new Hand(cards);
var pokerHandsChecker = new PokerHandsChecker();
Assert.IsTrue(pokerHandsChecker.IsFourOfAKind(hand), "IsFourOfAkind don't return correct result");
}
public void TestIsFourOfAKind()
{
Hand hand = new Hand(new List<ICard>{
new Card(CardFace.Jack, CardSuit.Spades),
new Card(CardFace.Jack, CardSuit.Hearts),
new Card(CardFace.Jack, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Diamonds),
new Card(CardFace.Ten, CardSuit.Spades)});
bool expected = true;
PokerHandsChecker checker = new PokerHandsChecker();
bool actual = checker.IsFourOfAKind(hand);
Assert.AreEqual(expected, actual);
}
public void TestValidFourOfKind()
{
IList<ICard> hand = new List<ICard>
{
new Card(CardFace.Jack, CardSuit.Spades),
new Card(CardFace.Jack, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Diamonds),
new Card(CardFace.Jack, CardSuit.Hearts),
new Card(CardFace.Seven, CardSuit.Spades)
};
Hand currentHand = new Hand(hand);
PokerHandsChecker checker = new PokerHandsChecker();
bool isValidFourOfAKind = checker.IsFourOfAKind(currentHand);
Assert.AreEqual(true, isValidFourOfAKind);
}
public void TestIsFourOfAKindLessCards()
{
Card cardOne = new Card(CardFace.Two, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Two, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Two, CardSuit.Spades);
IList <ICard> cards = new List <ICard>();
PokerHandsChecker pokerHandsChecker = new PokerHandsChecker();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
Hand hand = new Hand(cards);
Assert.AreEqual(false, pokerHandsChecker.IsFourOfAKind(hand), "IsFourOfAKind() is not working correctly.");
}
public void IsFourOfAKindSevensTest()
{
IHand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Seven, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Seven, CardSuit.Clubs),
new Card(CardFace.Seven, CardSuit.Hearts),
new Card(CardFace.Seven, CardSuit.Diamonds)
});
PokerHandsChecker checker = new PokerHandsChecker();
bool isFourOfAKind = checker.IsFourOfAKind(hand);
Assert.AreEqual(true, isFourOfAKind);
}
public void IsFourOfAKind_ShouldReturnFalse_IfThereAreNot4SameCardFace()
{
IList <ICard> cards = new List <ICard>()
{
new Card(CardFace.King, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Clubs)
};
IHand hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKindIsNotValidIfThereAreNotFourCardsOfOneFace()
{
Random generator = new Random();
for (int i = 2; i <= 14; i++)
{
List <ICard> cards = new List <ICard>();
cards.Add(new Card((CardFace)i, (CardSuit)generator.Next(1, 4)));
cards.Add(new Card((CardFace)i, (CardSuit)generator.Next(1, 4)));
cards.Add(new Card((CardFace)i, (CardSuit)generator.Next(1, 4)));
cards.Add(new Card(CardFace.Three, (CardSuit)generator.Next(1, 4)));
cards.Add(new Card(CardFace.Three, (CardSuit)i));
Hand someHand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
if (someHand.Cards[4].Face != CardFace.Three)
{
Assert.AreEqual(false, checker.IsFourOfAKind(someHand));
}
else
{
Assert.AreEqual(true, checker.IsFourOfAKind(someHand));
}
}
}
public void FourOfaKind_TwoSevenCards()
{
var hand = new Hand(new List<ICard>()
{
new Card(CardFace.Seven,CardSuit.Diamonds),
new Card(CardFace.Two,CardSuit.Spades),
new Card(CardFace.Seven,CardSuit.Hearts),
new Card(CardFace.Eight,CardSuit.Clubs),
new Card(CardFace.Five,CardSuit.Hearts)
});
var pokerChecker = new PokerHandsChecker();
bool result = pokerChecker.IsFourOfAKind(hand);
Assert.IsFalse(result);
}
public void FourOfaKind_DifferentCards()
{
var hand = new Hand(new List<ICard>()
{
new Card(CardFace.Seven,CardSuit.Diamonds),
new Card(CardFace.King,CardSuit.Diamonds),
new Card(CardFace.Queen,CardSuit.Diamonds),
new Card(CardFace.Two,CardSuit.Diamonds),
new Card(CardFace.Three,CardSuit.Clubs),
});
var pokerChecker = new PokerHandsChecker();
bool result = pokerChecker.IsFourOfAKind(hand);
Assert.IsFalse(result);
}
public void FourOfAKindMixedTest()
{
List<Card> cards = new List<Card>()
{
new Card(CardFace.Nine, CardSuit.Hearts),
new Card(CardFace.Jack, CardSuit.Spades),
new Card(CardFace.Jack, CardSuit.Diamonds),
new Card(CardFace.Jack, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Hearts)
};
Hand hand = new Hand(cards.ToArray());
PokerHandsChecker checker = new PokerHandsChecker();
var excpected = true;
var actual = checker.IsFourOfAKind(hand);
Assert.AreEqual(excpected, actual);
}
public void IsFourOfAKindWithFourSameUnsorted()
{
var hand = new Hand(new List<ICard>()
{
new Card(CardFace.Ace,CardSuit.Clubs),
new Card(CardFace.Ace,CardSuit.Diamonds),
new Card(CardFace.King,CardSuit.Clubs),
new Card(CardFace.Ace,CardSuit.Hearts),
new Card(CardFace.Ace,CardSuit.Spades)
});
var handChecker = new PokerHandsChecker();
var isValid = handChecker.IsFourOfAKind(hand);
Assert.IsTrue(isValid);
}
public void IsFourOfAKindShouldThrowException_FiveOfAKind()
{
var checker = new PokerHandsChecker();
var cards = new List<ICard>
{
new Card(CardFace.Three, CardSuit.Spades),
new Card(CardFace.Three, CardSuit.Diamonds),
new Card(CardFace.Three, CardSuit.Clubs),
new Card(CardFace.Three, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Spades)
};
var hand = new Hand(cards);
checker.IsFourOfAKind(hand);
}
public void TestHandFourOfKindLastDifferent()
{
IPokerHandsChecker handsChecker = new PokerHandsChecker();
IHand hand = new Hand(
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Eight, CardSuit.Spades));
Assert.IsTrue(handsChecker.IsFourOfAKind(hand));
}
public void PokerHandsIsFourOfAKindReturnFalseWhenHaveNotFourOfKind()
{
IHand hand = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Jack, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Diamonds),
new Card(CardFace.Seven, CardSuit.Diamonds)
});
var checker = new PokerHandsChecker();
Assert.IsTrue(!checker.IsFourOfAKind(hand));
}
public void PokerHandsIsFourOfAKindReturnTrueWhenHaveFourOfKind()
{
IHand hand = new Hand(new List<ICard>() {
new Card(CardFace.King, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Clubs),
new Card(CardFace.King, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Diamonds)
});
var checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKindWithDifferentCards()
{
var hand = new Hand(new List<ICard>()
{
new Card(CardFace.Queen,CardSuit.Clubs),
new Card(CardFace.Ace,CardSuit.Diamonds),
new Card(CardFace.Ten,CardSuit.Hearts),
new Card(CardFace.King,CardSuit.Clubs),
new Card(CardFace.Two,CardSuit.Clubs)
});
var handChecker = new PokerHandsChecker();
var isValid = handChecker.IsFourOfAKind(hand);
Assert.IsFalse(isValid);
}
public void IsFourOfAKindIsValidOnlyIfTheHandIsValid()
{
List<ICard> cards = new List<ICard>();
for (int i = 0; i < 3; i++)
{
cards.Add(new Card((CardFace)i + 1, CardSuit.Diamonds));
}
Hand someHand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
Assert.AreEqual(false, checker.IsFourOfAKind(someHand));
}
public void IsFourOfAKindIsNotValidIfThereAreNotFourCardsOfOneFace()
{
Random generator = new Random();
for (int i = 2; i <= 14; i++)
{
List<ICard> cards = new List<ICard>();
cards.Add(new Card((CardFace)i, (CardSuit)generator.Next(1, 4)));
cards.Add(new Card((CardFace)i, (CardSuit)generator.Next(1, 4)));
cards.Add(new Card((CardFace)i, (CardSuit)generator.Next(1, 4)));
cards.Add(new Card(CardFace.Three, (CardSuit)generator.Next(1, 4)));
cards.Add(new Card(CardFace.Three, (CardSuit)i));
Hand someHand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
if (someHand.Cards[4].Face != CardFace.Three)
{
Assert.AreEqual(false, checker.IsFourOfAKind(someHand));
}
else
{
Assert.AreEqual(true, checker.IsFourOfAKind(someHand));
}
}
}
public void IsFourOfAKindWithFourSameCardsWithSameSuit()
{
var hand = new Hand(new List<ICard>()
{
new Card(CardFace.Ace,CardSuit.Clubs),
new Card(CardFace.Ace,CardSuit.Clubs),
new Card(CardFace.Ace,CardSuit.Clubs),
new Card(CardFace.Ace,CardSuit.Clubs),
new Card(CardFace.King,CardSuit.Clubs)
});
var handChecker = new PokerHandsChecker();
var isValid = handChecker.IsFourOfAKind(hand);
Assert.IsFalse(isValid);
}
public void IsFourOfAKindShouldReturnTrueWhenGivenACorrectValue()
{
var checker = new PokerHandsChecker();
var cards = new List<ICard>
{
new Card(CardFace.Three, CardSuit.Diamonds),
new Card(CardFace.Five, CardSuit.Diamonds),
new Card(CardFace.Three, CardSuit.Clubs),
new Card(CardFace.Three, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Spades)
};
var hand = new Hand(cards);
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
