public void IsValidHandShouldThrowAnExceptionIfNullHandIsPassed()
{
IHand hand = null;
var checker = new PokerHandsChecker();
checker.IsValidHand(hand);
}
public void IsValidHandShouldThrowAnExceptionIfNullListOfCardsIsPassed()
{
List<ICard> cards = null;
var checker = new PokerHandsChecker();
checker.IsValidHand(new Hand(cards));
}
public void isValidHandShouldThrowExceptionWhenHandContainesNotEnoughtCards()
{
var handChecker = new PokerHandsChecker();
var cards = new List<ICard>() { new Card(CardFace.Six, CardSuit.Clubs) };
var hand = new Hand(cards);
handChecker.IsValidHand(hand);
}
static void Main()
{
ICard card = new Card(CardFace.Ace, CardSuit.Clubs);
Console.WriteLine(card);
IHand hand = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Diamonds),
});
Console.WriteLine(hand);
IPokerHandsChecker checker = new PokerHandsChecker();
//Console.WriteLine(checker.IsValidHand(hand));
//Console.WriteLine(checker.IsOnePair(hand));
//Console.WriteLine(checker.IsTwoPair(hand));
// vasil test
IList<ICard> cards = new List<ICard>();
cards.Add(new Card(CardFace.Ace, CardSuit.Diamonds));
cards.Add(new Card(CardFace.Six, CardSuit.Diamonds));
cards.Add(new Card(CardFace.Two, CardSuit.Diamonds));
cards.Add(new Card(CardFace.Three, CardSuit.Diamonds));
cards.Add(new Card(CardFace.Five, CardSuit.Diamonds));
hand = new Hand(cards);
Console.WriteLine(checker.IsStraightFlush(hand));
}
public void IsFlushShouldThrowAnExceptionWhenAHandWithNullCardsIsPassed()
{
List<ICard> cards = null;
var checker = new PokerHandsChecker();
checker.IsFlush(new Hand(cards));
}
public void TestIsValidHand_WithNoCards()
{
Hand currentHand = new Hand(new List<ICard>());
PokerHandsChecker checker = new PokerHandsChecker();
bool isValidHand = checker.IsValidHand(currentHand);
Assert.AreEqual(false, isValidHand);
}
public void PokerHandCheckerIsFlushReturnsFalseIfItIsNot()
{
var handWithDiamondInBegining = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Jack, CardSuit.Spades),
new Card(CardFace.Four, CardSuit.Spades),
new Card(CardFace.Queen, CardSuit.Spades),
new Card(CardFace.Eight, CardSuit.Spades),
});
var handWithDiamondInMiddle = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Jack, CardSuit.Spades),
new Card(CardFace.Four, CardSuit.Diamonds),
new Card(CardFace.Queen, CardSuit.Spades),
new Card(CardFace.Eight, CardSuit.Spades),
});
var handWithDiamondInEnd = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Jack, CardSuit.Spades),
new Card(CardFace.Four, CardSuit.Spades),
new Card(CardFace.Queen, CardSuit.Spades),
new Card(CardFace.Eight, CardSuit.Diamonds),
});
var pokerHandChecker = new PokerHandsChecker();
Assert.IsFalse(pokerHandChecker.IsFlush(handWithDiamondInBegining));
Assert.IsFalse(pokerHandChecker.IsFlush(handWithDiamondInMiddle));
Assert.IsFalse(pokerHandChecker.IsFlush(handWithDiamondInEnd));
}
public void IsValidHandShouldThrowAnExceptionWhenFiveCardsWithTheSameFaceArePassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.King, CardSuit.Clubs), new Card(CardFace.King, CardSuit.Hearts), new Card(CardFace.King, CardSuit.Diamonds), new Card(CardFace.King, CardSuit.Diamonds) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
checker.IsValidHand(hand);
}
public void IsValidHandShouldThrowAnExceptionIfCountOfTheCardsInTheHandIsNotExactly5(int count)
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.Three, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Clubs), new Card(CardFace.Queen, CardSuit.Spades), new Card(CardFace.King, CardSuit.Diamonds), new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.Three, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Clubs), new Card(CardFace.Queen, CardSuit.Spades), new Card(CardFace.King, CardSuit.Diamonds) };
var hand = new Hand(cards.Take(count).ToList());
var checker = new PokerHandsChecker();
checker.IsValidHand(hand);
}
public void IsValidHandShouldReturnTrueIfValidHandIsPassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.Three, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Clubs), new Card(CardFace.Queen, CardSuit.Spades), new Card(CardFace.King, CardSuit.Diamonds) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsValidHand(hand));
}
public void IsValidHandShouldThrowAnExceptionWhenTwoEqualCardsArePassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.Three, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Clubs), new Card(CardFace.Queen, CardSuit.Spades), new Card(CardFace.King, CardSuit.Spades) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
checker.IsValidHand(hand);
}
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 TestFourOfAKind()
{
Hand hand = "4♣ 4♦ 4♥ 4♠ A♠";
bool actual = new PokerHandsChecker().IsFourOfAKind(hand);
Assert.AreEqual(true, actual);
}
public void IsFlushShouldThrowAnExceptionWhenAnInvalidHandWithMoreCardsIsPassed()
{
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.IsFlush(hand);
}
public void IsTwoPairShouldReturnFalseIfCardsMakeFlush()
{
var cards = new List<ICard>() { new Card(CardFace.Ace, CardSuit.Clubs), new Card(CardFace.Queen, CardSuit.Clubs), new Card(CardFace.Ten, CardSuit.Clubs), new Card(CardFace.Five, CardSuit.Clubs), new Card(CardFace.Three, CardSuit.Clubs) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsTwoPair(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 IsStraightShouldReturnFalseIfCardsAreTheSameSuit()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.Two, CardSuit.Spades), new Card(CardFace.Five, CardSuit.Spades), new Card(CardFace.Ten, CardSuit.Spades), new Card(CardFace.Seven, CardSuit.Spades) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsStraight(hand));
}
public void IsFullHouseShouldReturnFalseIfCardsAreThreeOfAKind()
{
var cards = new List<ICard>() { new Card(CardFace.Ace, CardSuit.Clubs), new Card(CardFace.Ace, CardSuit.Spades), new Card(CardFace.Ace, CardSuit.Hearts), new Card(CardFace.Five, CardSuit.Diamonds), new Card(CardFace.Three, CardSuit.Spades) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFullHouse(hand));
}
public void CompareHands_TestForNullCards_ShouldNotBeCorrect()
{
IHand first = null;
IHand second = null;
var checker = new PokerHandsChecker();
checker.CompareHands(first,second);
}
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 IsFlushShouldReturnTrueWhen5NotStraightSpadesArePassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.Queen, CardSuit.Spades), new Card(CardFace.Ten, CardSuit.Spades), new Card(CardFace.Two, CardSuit.Spades), new Card(CardFace.Three, CardSuit.Spades) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsFlush(hand));
}
public void TestStraightFlush()
{
Hand hand = "J♣ 10♣ 9♣ 8♣ 7♣";
bool actual = new PokerHandsChecker().IsStraightFlush(hand);
Assert.AreEqual(true, actual);
}
public void IsStraightShouldReturnFalseIfCardsMakeOnePair()
{
var cards = new List<ICard>() { new Card(CardFace.Ace, CardSuit.Clubs), new Card(CardFace.Ace, CardSuit.Spades), new Card(CardFace.Eight, CardSuit.Spades), new Card(CardFace.Five, CardSuit.Clubs), new Card(CardFace.Three, CardSuit.Clubs) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsStraight(hand));
}
static void Main()
{
Console.WriteLine(new Card(CardFace.Ace, CardSuit.Clubs));
IPokerHandsChecker checker = new PokerHandsChecker();
//Console.WriteLine(checker.IsStraightFlush((Hand)"J♣ 10♣ 9♣ 8♣ 7♣"));
}
public void CompareHands_TestForNullCards_ShouldNotBeCorrect()
{
IHand first = null;
IHand second = null;
var checker = new PokerHandsChecker();
Assert.Throws<ArgumentNullException>(() => checker.CompareHands(first, second));
}
public void IsTwoPairShouldReturnFalseIfCardsAreHigh()
{
var cards = new List<ICard>() { new Card(CardFace.Ace, CardSuit.Clubs), new Card(CardFace.Ten, CardSuit.Clubs), new Card(CardFace.Nine, CardSuit.Spades), new Card(CardFace.Five, CardSuit.Diamonds), new Card(CardFace.Four, CardSuit.Diamonds) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsTwoPair(hand));
}
public void IsStraightShouldReturnFalseIfCardsMakeFullHouse()
{
var cards = new List<ICard>() { new Card(CardFace.Ten, CardSuit.Clubs), new Card(CardFace.Ten, CardSuit.Spades), new Card(CardFace.Ten, CardSuit.Diamonds), new Card(CardFace.Four, CardSuit.Hearts), new Card(CardFace.Four, CardSuit.Clubs) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsStraight(hand));
}
public void IsTwoPairPairShouldThrowAnExceptionWhenAnInvalidHandWithLessThan5CardsIsPassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.King, CardSuit.Clubs), new Card(CardFace.Two, CardSuit.Clubs) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
checker.IsTwoPair(hand);
}
public void IsStraightShouldReturnFalseIfCardsMakeStraightFlush()
{
var cards = new List<ICard>() { new Card(CardFace.Eight, CardSuit.Clubs), new Card(CardFace.Seven, CardSuit.Clubs), new Card(CardFace.Six, CardSuit.Clubs), new Card(CardFace.Five, CardSuit.Clubs), new Card(CardFace.Four, CardSuit.Clubs) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsStraight(hand));
}
public void IsFlushShouldReturnFalseWhen4OfSameSuitArePassed()
{
var cards = new List<ICard>() { new Card(CardFace.King, CardSuit.Spades), new Card(CardFace.Five, CardSuit.Spades), new Card(CardFace.Nine, CardSuit.Spades), new Card(CardFace.Jack, CardSuit.Spades), new Card(CardFace.Two, CardSuit.Clubs) };
var hand = new Hand(cards);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFlush(hand));
}
public void TestIsStraightFlushFlush()
{
Card cardOne = new Card(CardFace.Two, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Jack, CardSuit.Diamonds);
Card cardThree = new Card(CardFace.Five, CardSuit.Diamonds);
Card cardFour = new Card(CardFace.Ace, CardSuit.Diamonds);
Card cardFive = new Card(CardFace.Ten, CardSuit.Diamonds);
IList <ICard> cards = new List <ICard>();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
cards.Add(cardFour);
cards.Add(cardFive);
Hand hand = new Hand(cards);
PokerHandsChecker poker = new PokerHandsChecker();
bool isStraightFlush = poker.IsStraightFlush(hand);
Assert.AreEqual(false, isStraightFlush, "IsStraightFlush() method in class PokerHandsChecker is not working correctly.");
}
public void TestIsThreeOfAKindSameCards()
{
Card cardOne = new Card(CardFace.Two, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Ten, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Ace, CardSuit.Clubs);
Card cardFour = new Card(CardFace.Ace, CardSuit.Clubs);
Card cardFive = new Card(CardFace.Ace, CardSuit.Clubs);
IList <ICard> cards = new List <ICard>();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
cards.Add(cardFour);
cards.Add(cardFive);
Hand hand = new Hand(cards);
PokerHandsChecker poker = new PokerHandsChecker();
bool isThreeOfAKind = poker.IsThreeOfAKind(hand);
Assert.AreEqual(false, isThreeOfAKind, "IsThreeOfAKind() method in class PokerHandsChecker is not working correctly.");
}
public void IsStraightFlush_ShouldReturnFalse_IfPlayerDoesNotHaveStraightFlushInHisHand()
{
// Arrange
IHand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Queen, CardSuit.Diamonds),
new Card(CardFace.Seven, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Six, CardSuit.Diamonds),
});
var expected = false;
// Act
var checker = new PokerHandsChecker();
var result = checker.IsStraightFlush(hand);
// Assert
NUnit.Core.NUnitFramework.Assert.AreEqual(expected, result);
}
public void IsStraightFlush_ShouldReturnTrue_IfPlayerHasStraightFlushInHisHand()
{
// Arrange
IHand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Seven, CardSuit.Clubs),
new Card(CardFace.Eight, CardSuit.Clubs),
new Card(CardFace.Nine, CardSuit.Clubs),
new Card(CardFace.Ten, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Clubs),
});
var expected = true;
// Act
var checker = new PokerHandsChecker();
var result = checker.IsStraightFlush(hand);
// Assert
NUnit.Core.NUnitFramework.Assert.AreEqual(expected, result);
}
public void IsHighCard_ShouldReturnTrue_IfPlayerHasFiveCardsInHisHand()
{
// Arrange
IHand hand = new Hand(new List <ICard>()
{
new Card(CardFace.King, CardSuit.Clubs),
new Card(CardFace.Queen, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Diamonds),
});
var expected = true;
// Act
var checker = new PokerHandsChecker();
var result = checker.IsHighCard(hand);
// Assert
NUnit.Core.NUnitFramework.Assert.AreEqual(expected, result);
}
public void TestIsStraightOtherCombination()
{
Card cardOne = new Card(CardFace.Ten, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Ten, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Ten, CardSuit.Spades);
Card cardFour = new Card(CardFace.Ten, CardSuit.Clubs);
Card cardFive = new Card(CardFace.King, CardSuit.Clubs);
IList <ICard> cards = new List <ICard>();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
cards.Add(cardFour);
cards.Add(cardFive);
Hand hand = new Hand(cards);
PokerHandsChecker poker = new PokerHandsChecker();
bool isStraight = poker.IsStraight(hand);
Assert.AreEqual(false, isStraight, "IsStraight() method in class PokerHandsChecker is not working correctly.");
}
public void TestIsTwoPairValid()
{
Card cardOne = new Card(CardFace.Ace, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Ace, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Seven, CardSuit.Spades);
Card cardFour = new Card(CardFace.Ten, CardSuit.Clubs);
Card cardFive = new Card(CardFace.Ten, CardSuit.Spades);
IList <ICard> cards = new List <ICard>();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
cards.Add(cardFour);
cards.Add(cardFive);
Hand hand = new Hand(cards);
PokerHandsChecker poker = new PokerHandsChecker();
bool isTwoPair = poker.IsTwoPair(hand);
Assert.AreEqual(true, isTwoPair, "IsTwoPair() method in class PokerHandsChecker is not working correctly.");
}
public void TestIsHighCardStraight()
{
Card cardOne = new Card(CardFace.Two, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Three, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Four, CardSuit.Spades);
Card cardFour = new Card(CardFace.Five, CardSuit.Clubs);
Card cardFive = new Card(CardFace.Six, CardSuit.Clubs);
IList <ICard> cards = new List <ICard>();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
cards.Add(cardFour);
cards.Add(cardFive);
Hand hand = new Hand(cards);
PokerHandsChecker poker = new PokerHandsChecker();
bool isHighCard = poker.IsHighCard(hand);
Assert.AreEqual(false, isHighCard, "IsHighCard() method in class PokerHandsChecker is not working correctly.");
}
public void TestCompareHandsEqualHands()
{
Card cardOne = new Card(CardFace.Jack, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Jack, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Five, CardSuit.Spades);
Card cardFour = new Card(CardFace.Ace, CardSuit.Clubs);
Card cardFive = new Card(CardFace.Ace, CardSuit.Spades);
IList <ICard> cards = new List <ICard>();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
cards.Add(cardFour);
cards.Add(cardFive);
Hand handOne = new Hand(cards);
Hand handTwo = new Hand(cards);
PokerHandsChecker poker = new PokerHandsChecker();
int result = poker.CompareHands(handOne, handTwo);
Assert.AreEqual(0, result, "CompareHands() method in class PokerHandsChecker is not working correctly.");
}
public void IsValidHand_HandHasFiveDifferentCards_ShouldReturnTrue()
{
// Arrange
var cards = new List <ICard>()
{
new ConstantStringFakeCard("card1"),
new ConstantStringFakeCard("card2"),
new ConstantStringFakeCard("card3"),
new ConstantStringFakeCard("card4"),
new ConstantStringFakeCard("card5"),
};
var hand = new FakeHand(cards);
var pokerHandChecker = new PokerHandsChecker();
// Act
var result = pokerHandChecker.IsValidHand(hand);
// Assert
Assert.IsTrue(result);
}
public void TestIsValidHandMoreCards()
{
Card cardOne = new Card(CardFace.Two, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Jack, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Five, CardSuit.Spades);
Card cardFour = new Card(CardFace.Ace, CardSuit.Clubs);
Card cardFive = new Card(CardFace.Ten, CardSuit.Clubs);
Card cardSix = new Card(CardFace.Seven, CardSuit.Spades);
IList <ICard> cards = new List <ICard>();
PokerHandsChecker pokerHandsChecker = new PokerHandsChecker();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
cards.Add(cardFour);
cards.Add(cardFive);
cards.Add(cardSix);
Hand hand = new Hand(cards);
Assert.AreEqual(false, pokerHandsChecker.IsValidHand(hand), "IsValidHand() is not working correctly.");
}
public void IsFourOfKind_IfHandDoNotContain4SameFaces_ShouldReturnFalse(int face1, int face2, int face3, int face4, int face5)
{
var faces = new List <int> {
face1, face2, face3, face4, face5
};
var collection = new List <ICard>();
foreach (var face in faces)
{
var card = Mock.Create <ICard>();
Mock.Arrange(() => card.Face).Returns((CardFace)face);
collection.Add(card);
}
var hand = Mock.Create <IHand>();
Mock.Arrange(() => hand.Cards).Returns(collection);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void IsValidHand_IfContainEqualsCards_ShouldReturnFalse()
{
var collection = new List <ICard>();
var mockedCard = Mock.Create <ICard>();
Mock.Arrange(() => mockedCard.Face).Returns(CardFace.King);
Mock.Arrange(() => mockedCard.Suit).Returns(CardSuit.Diamonds);
for (int i = 0; i < 5; i++)
{
collection.Add(mockedCard);
}
var hand = Mock.Create <IHand>();
Mock.Arrange(() => hand.Cards).Returns(collection);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsValidHand(hand));
}
internal static void Main()
{
ICard card = new Card(CardFace.Ace, CardSuit.Clubs);
System.Console.WriteLine(card);
IHand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Five, CardSuit.Diamonds),
new Card(CardFace.Five, CardSuit.Spades),
new Card(CardFace.Nine, CardSuit.Clubs),
new Card(CardFace.Nine, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Hearts),
});
System.Console.WriteLine(hand);
IHand otherHand = new Hand(new List <ICard>()
{
new Card(CardFace.Six, CardSuit.Hearts),
new Card(CardFace.Six, CardSuit.Spades),
new Card(CardFace.Three, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Clubs),
});
System.Console.WriteLine(otherHand);
IPokerHandsChecker checker = new PokerHandsChecker();
System.Console.WriteLine(checker.IsStraightFlush(hand));
System.Console.WriteLine(checker.IsStraight(hand));
System.Console.WriteLine(checker.IsThreeOfAKind(hand));
System.Console.WriteLine(checker.IsFlush(hand));
System.Console.WriteLine(checker.IsOnePair(hand));
System.Console.WriteLine(checker.IsTwoPair(hand));
System.Console.WriteLine(checker.CompareHands(hand, otherHand));
}
public void IsFlushShouldBeFalseIfOneCardsDiffers()
{
for (int i = 1; i <= 4; i++)
{
List <ICard> cards = new List <ICard>();
cards.Add(new Card(CardFace.Jack, (CardSuit)i));
cards.Add(new Card(CardFace.Eight, (CardSuit)i));
cards.Add(new Card(CardFace.Queen, CardSuit.Hearts));
cards.Add(new Card(CardFace.Six, (CardSuit)i));
cards.Add(new Card(CardFace.Three, (CardSuit)i));
Hand someHand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
if ((CardSuit)i != CardSuit.Hearts)
{
Assert.AreEqual(false, checker.IsFlush(someHand));
}
else
{
Assert.AreEqual(true, checker.IsFlush(someHand));
}
}
}
public void IsValidHand_IfContainsExactly5DiferentCards_ShouldReturnTrue()
{
var rng = new Random();
var faces = Enum.GetValues(typeof(CardFace));
var suits = Enum.GetValues(typeof(CardSuit));
var collection = new List <ICard>();
while (collection.Count < 5)
{
var mockedCard = Mock.Create <ICard>();
Mock.Arrange(() => mockedCard.Face).Returns((CardFace)faces.GetValue(rng.Next(faces.Length)));
Mock.Arrange(() => mockedCard.Suit).Returns((CardSuit)suits.GetValue(rng.Next(suits.Length)));
bool IsSameCard = false;
foreach (var c in collection)
{
if (c.Face == mockedCard.Face && c.Suit == mockedCard.Suit)
{
IsSameCard = true;
}
}
if (!IsSameCard)
{
collection.Add(mockedCard);
}
}
var hand = Mock.Create <IHand>();
Mock.Arrange(() => hand.Cards).Returns(collection);
var checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsValidHand(hand));
}
public void IsFlush_IfHandContainDiferentSuits_ShouldReturnFalse(int suit1, int suit2, int suit3, int suit4, int suit5)
{
var collection = new List <ICard>();
var suits = new List <int> {
suit1, suit2, suit3, suit4, suit5
};
foreach (var suit in suits)
{
var card = Mock.Create <ICard>();
Mock.Arrange(() => card.Suit).Returns((CardSuit)suit);
collection.Add(card);
}
var hand = Mock.Create <IHand>();
Mock.Arrange(() => hand.Cards).Returns(collection);
var checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFlush(hand));
}
public void ValidHandShouldConsistsOfFiveCards()
{
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.IsValidHand(someHand));
for (int i = 0; i < 3; i++)
{
cards.Add(new Card((CardFace)i + 1, CardSuit.Diamonds));
}
Hand someOtherHand = new Hand(cards);
Assert.AreEqual(false, checker.IsValidHand(someOtherHand));
}
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 IsFourOfKind_IfHandContain4OfSameFaces_ShouldReturnTrue(int face, int otherFace)
{
var collection = new List <ICard>();
for (int i = 0; i < 4; i++)
{
var card = Mock.Create <ICard>();
Mock.Arrange(() => card.Face).Returns((CardFace)face);
collection.Add(card);
}
var fifthCard = Mock.Create <ICard>();
Mock.Arrange(() => fifthCard.Face).Returns((CardFace)otherFace);
collection.Add(fifthCard);
var hand = Mock.Create <IHand>();
Mock.Arrange(() => hand.Cards).Returns(collection);
var checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void PokerHandsShouldReturnTrueIfIs_FourOfAKind()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
Assert.IsTrue(pokerChecker.IsFourOfAKind(FourOfAKind));
}
public void PokerHandsShouldThrowIfHandContainsMoreThanFiveCards()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
pokerChecker.IsValidHand(InvalidHandWithSixCards);
}
public void PokerHandsShouldThrowIfHandContainsEqualCards()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
pokerChecker.IsValidHand(InvalidHandWithEqualCards);
}
public void PokerHandsShouldReturnFalseIfIs_FlushHand_ButIs_StaithFlushHand()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
Assert.IsFalse(pokerChecker.IsFlush(StraitFlush));
}
public void PokerHandsShouldReturnTrueIfIs_FlushHand()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
Assert.IsTrue(pokerChecker.IsFlush(Flush));
}
public void PokerHandsCheckerConstructorTest()
{
PokerHandsChecker target = new PokerHandsChecker();
Assert.Inconclusive("TODO: Implement code to verify target");
}
public void PokerHandsShouldReturnTrueIfIsValidHand()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
Assert.IsTrue(pokerChecker.IsValidHand(ValidHand));
}
public void PokerHandsShouldReturnFalseIfItIsNot_FourOfAKind()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
Assert.IsFalse(pokerChecker.IsFourOfAKind(ValidHand));
}
public void PokerHandsShouldReturnFalseIfItIsNot_StraitFlush()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
Assert.IsFalse(pokerChecker.IsStraightFlush(ValidHand));
}
public void PokerHandsShouldReturnTrueTenToAce_StraightFlush()
{
PokerHandsChecker pokerChecker = new PokerHandsChecker();
Assert.IsTrue(pokerChecker.IsStraightFlush(StraitFlushTenToAce));
}
