private static void Main()
{
try
{
IHand hand = new Hand(new List<ICard>()
{
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Queen, CardSuit.Clubs),
new Card(CardFace.King, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Clubs),
new Card(CardFace.Ten, CardSuit.Clubs),
});
Console.WriteLine(hand);
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine(checker.IsValidHand(hand) ? "Hand is valid." : "Hand is not valid!");
Console.WriteLine(checker.IsRoyalFlush(hand) ? "Royal flush." : "Hand is not Royal flush!");
Console.WriteLine(checker.IsStraightFlush(hand) ? "Straight flush." : "Hand is not Straight flush!");
Console.WriteLine(checker.IsFlush(hand) ? "Flush." : "Hand is not Flush!");
Console.WriteLine(checker.IsStraight(hand) ? "Straight." : "Hand is not Straight!");
Console.WriteLine(checker.IsFullHouse(hand) ? "Full house." : "Hand is not Full house!");
Console.WriteLine(checker.IsFourOfAKind(hand) ? "Four of a kind." : "Hand is not Four of a kind!");
Console.WriteLine(checker.IsThreeOfAKind(hand) ? "Three of a kind." : "Hand is not Three of a kind!");
IHand hand1 = new Hand("K♥ J♥ 8♣ 7♦ 4♠");
Console.WriteLine(hand1);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
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);
IHand forhand = new Hand(new List <ICard>()
{
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Diamonds),
});
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine(checker.IsValidHand(hand));
Console.WriteLine(checker.IsTwoPair(hand));
Console.WriteLine(checker.IsOnePair(hand));
Console.WriteLine(checker.IsFourOfAKind(forhand));
Console.WriteLine(checker.IsStraight(forhand));
}
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.IsStraight(hand));
Console.WriteLine(checker.IsOnePair(hand));
Console.WriteLine(checker.IsTwoPair(hand));
Console.WriteLine(checker.IsStraightFlush(hand));
Console.WriteLine(checker.IsFlush(hand));
Console.WriteLine(checker.IsFourOfAKind(hand));
Console.WriteLine(checker.IsThreeOfAKind(hand));
Console.WriteLine(checker.IsHighCard(hand));
Console.WriteLine(checker.IsFullHouse(hand));
}
public void IsFourOfAKindTest()
{
Hand pokerHand = new Hand(new List<ICard>(){
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Jack, CardSuit.Diamonds),
new Card(CardFace.Jack, CardSuit.Spades),
new Card(CardFace.Jack, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Hearts)});
PokerHandsChecker checker = new PokerHandsChecker();
Assert.AreEqual(true, checker.IsFourOfAKind(pokerHand));
}
public void TestForFourOfAKind()
{
IList<ICard> cardList = new List<ICard>();
cardList.Add(new Card(CardFace.King, CardSuit.Spades));
cardList.Add(new Card(CardFace.King, CardSuit.Hearts));
cardList.Add(new Card(CardFace.King, CardSuit.Diamonds));
cardList.Add(new Card(CardFace.King, CardSuit.Clubs));
cardList.Add(new Card(CardFace.Ten, CardSuit.Hearts));
var hand = new Hand(cardList);
var handChecker = new PokerHandsChecker();
Assert.AreEqual(true, handChecker.IsFourOfAKind(hand));
}
public void TestForOfKindWithValidCards()
{
Hand hand = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Queen, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Spades)
});
IPokerHandsChecker checker = new PokerHandsChecker();
Assert.AreEqual(true, checker.IsFourOfAKind(hand));
}
public void TestForOfKindWithInvalidCards()
{
Hand hand = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.King, CardSuit.Clubs),
new Card(CardFace.Queen, CardSuit.Hearts),
new Card(CardFace.Jack, CardSuit.Clubs),
new Card(CardFace.Ten, CardSuit.Clubs),
});
IPokerHandsChecker checker = new PokerHandsChecker();
Assert.AreEqual(false, checker.IsFourOfAKind(hand));
}
public void ExpectIsFourOfAKindToReturnTrueWhenThereIsFourOfAKindCombinationTest3()
{
List<ICard> cards = new List<ICard>();
cards.Add(new Card(CardFace.Two, CardSuit.Clubs));
cards.Add(new Card(CardFace.Two, CardSuit.Hearts));
cards.Add(new Card(CardFace.Ace, CardSuit.Diamonds));
cards.Add(new Card(CardFace.Two, CardSuit.Spades));
cards.Add(new Card(CardFace.Two, CardSuit.Diamonds));
Hand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
Assert.AreEqual(true, checker.IsFourOfAKind(hand));
}
public void NotFourOfAKindHand()
{
var hand = new Hand(new List<ICard>() {
new Card(CardFace.Seven, CardSuit.Hearts),
new Card(CardFace.Seven, CardSuit.Spades),
new Card(CardFace.King, CardSuit.Diamonds),
new Card(CardFace.Ten, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Clubs)
});
var checker = new PokerHandsChecker();
Assert.IsFalse(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_CheckWith4CardsOfSameKind()
{
var cards = new List<ICard>() {
new Card(CardFace.Two, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Clubs),
new Card(CardFace.Two, CardSuit.Hearts),
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Clubs)
};
var hand = new Hand(cards);
var pokerHandsChecker = new PokerHandsChecker();
Assert.IsTrue(pokerHandsChecker.IsFourOfAKind(hand));
}
public void IsFourOfAKind_CheckWithout4CardsOfSameKind()
{
var cards = new List<ICard>() {
new Card(CardFace.Two, CardSuit.Clubs),
new Card(CardFace.Three, CardSuit.Spades),
new Card(CardFace.Four, CardSuit.Clubs),
new Card(CardFace.Five, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Clubs)
};
var hand = new Hand(cards);
var pokerHandsChecker = new PokerHandsChecker();
Assert.IsFalse(pokerHandsChecker.IsFourOfAKind(hand));
}
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>();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
Hand hand = new Hand(cards);
PokerHandsChecker poker = new PokerHandsChecker();
bool isFourOfAKind = poker.IsFourOfAKind(hand);
Assert.AreEqual(false, isFourOfAKind, "IsFourOfAKind() method in class PokerHandsChecker is not working correctly.");
}
public void IsFourOfAKindTrue()
{
Hand hand = new Hand(new List<ICard>()
{
new Card(CardFace.Three, CardSuit.Diamonds),
new Card(CardFace.Three, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Clubs),
new Card(CardFace.Three, CardSuit.Spades),
new Card(CardFace.Ten, CardSuit.Clubs)
});
PokerHandsChecker checkHand = new PokerHandsChecker();
bool isValidHand = checkHand.IsFourOfAKind(hand);
Assert.IsTrue(isValidHand);
}
public void TestFourOfAKindIncorrectHand_TwoSameCards()
{
IList<ICard> cards = new List<ICard>()
{
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Hearts),
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Diamonds)
};
Hand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void FourOfAKindFiveCards_FourWithSameFace_IsTrue()
{
IHand hand = new Hand(new List<ICard>()
{
new Card(CardFace.Ace, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Five, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Hearts),
});
PokerHandsChecker checker = new PokerHandsChecker();
Assert.IsTrue(checker.IsFourOfAKind(hand));
}
public void IsFourOfAKind_TrueSecond()
{
PokerHandsChecker checker = new PokerHandsChecker();
List<ICard> cardList = new List<ICard>
{
new Card(CardFace.Ten,CardSuit.Diamonds),
new Card(CardFace.Ten,CardSuit.Clubs),
new Card(CardFace.Ace,CardSuit.Diamonds),
new Card(CardFace.Ten,CardSuit.Spades),
new Card(CardFace.Ten,CardSuit.Hearts)
};
Hand hand = new Hand(cardList);
bool isFourOfAKind = checker.IsFourOfAKind(hand);
Assert.IsTrue(isFourOfAKind);
}
public void TestingPokerHandCheckerIsFourOFAKindShouldFail()
{
IList<ICard> list = new List<ICard>();
list.Add(new Card(CardFace.Nine, CardSuit.Clubs));
list.Add(new Card(CardFace.Two, CardSuit.Spades));
list.Add(new Card(CardFace.Ten, CardSuit.Spades));
list.Add(new Card(CardFace.Two, CardSuit.Spades));
list.Add(new Card(CardFace.Two, CardSuit.Spades));
var hand = new Hand(list);
var test = new PokerHandsChecker();
Assert.IsFalse(test.IsFourOfAKind(hand));
}
public void TestingPokerHandCheckerIsFourOFAKindShouldPass()
{
IList<ICard> list = new List<ICard>();
list.Add(new Card(CardFace.Ace, CardSuit.Clubs));
list.Add(new Card(CardFace.Ace, CardSuit.Spades));
list.Add(new Card(CardFace.Ace, CardSuit.Diamonds));
list.Add(new Card(CardFace.Ace, CardSuit.Spades));
list.Add(new Card(CardFace.Ace, CardSuit.Hearts));
var hand = new Hand(list);
var test = new PokerHandsChecker();
Assert.IsTrue(test.IsFourOfAKind(hand));
}
public void IsFourOfAKind_ReturnsFalseOnFullHouse()
{
IList<ICard> cards = new List<ICard>();
cards.Add(new Card(CardFace.Ace, CardSuit.Spades));
cards.Add(new Card(CardFace.Jack, CardSuit.Hearts));
cards.Add(new Card(CardFace.Ace, CardSuit.Diamonds));
cards.Add(new Card(CardFace.Ace, CardSuit.Clubs));
cards.Add(new Card(CardFace.Jack, CardSuit.Diamonds));
IHand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
bool isFourOfAKind = checker.IsFourOfAKind(hand);
Assert.AreEqual(false, isFourOfAKind);
}
public void TestIsFourOfAKindWithFiveKings()
{
PokerHandsChecker handChecker = new PokerHandsChecker();
Hand 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.King, CardSuit.Spades)
});
bool result = handChecker.IsFourOfAKind(hand);
Assert.AreEqual(false, result);
}
public void TestIsFourOfAKind_WithThreeEqualCars_ReturnsFalse()
{
List<ICard> fiveCardsNoFlush = new List<ICard>();
fiveCardsNoFlush.Add(new Card(CardFace.Ace, CardSuit.Hearts));
fiveCardsNoFlush.Add(new Card(CardFace.Ace, CardSuit.Diamonds));
fiveCardsNoFlush.Add(new Card(CardFace.Ace, CardSuit.Spades));
fiveCardsNoFlush.Add(new Card(CardFace.Ten, CardSuit.Clubs));
fiveCardsNoFlush.Add(new Card(CardFace.King, CardSuit.Spades));
Hand newHand = new Hand(fiveCardsNoFlush);
PokerHandsChecker game = new PokerHandsChecker();
Assert.AreEqual(false, game.IsFourOfAKind(newHand));
}
public void TestIsThreeOfAKind()
{
Hand hand = new Hand(new List<ICard>{
new Card(CardFace.Two, CardSuit.Hearts),
new Card(CardFace.Two, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Clubs),
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.King, CardSuit.Diamonds),
});
PokerHandsChecker checker = new PokerHandsChecker();
var excpected = true;
var actual = checker.IsFourOfAKind(hand);
Assert.AreEqual(excpected, actual);
}
public void FourOfAKindCheckerShouldReturnFalseWhenThereAreThreeDifferentFacesInTheHand()
{
IPokerHandsChecker checker = new PokerHandsChecker();
IHand hand = new Hand(new List<ICard>()
{
new Card(CardFace.Six, CardSuit.Clubs),
new Card(CardFace.Six, CardSuit.Diamonds),
new Card(CardFace.Six, CardSuit.Hearts),
new Card(CardFace.Five, CardSuit.Clubs),
new Card(CardFace.King, CardSuit.Clubs)
});
bool result = checker.IsFourOfAKind(hand);
bool expected = false;
Assert.AreEqual(result, expected);
}
public void IsFourOfAKind_LastThreeOfWithTheSameFace()
{
IList<ICard> cards = new List<ICard>
{
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.Six, CardSuit.Diamonds),
new Card(CardFace.Eight, CardSuit.Clubs),
new Card(CardFace.Eight, CardSuit.Hearts),
new Card(CardFace.Eight, CardSuit.Spades),
};
Hand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
Assert.IsFalse(checker.IsFourOfAKind(hand));
}
public void TestIsFourOfAKindHandStartWithValidFourOfAKind()
{
PokerHandsChecker checker = new PokerHandsChecker();
var cards = GenerateCorectCards();
// make first 4 cards face Queen
for (int i = 0; i < cards.Count - 1; i++)
{
cards[i] = new Card(CardFace.Queen, cards[i].Suit);
}
var hand = new Hand(cards);
bool isFourOfAKind = checker.IsFourOfAKind(hand);
Assert.IsTrue(isFourOfAKind, "Hand is valid isFourOfAKind and result mast be true.");
}
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.IsFourOfAKind(hand));
}
public void ThreeOfAKind()
{
IList<ICard> cards = new List<ICard>();
cards.Add(new Card(CardFace.King, CardSuit.Clubs));
cards.Add(new Card(CardFace.King, CardSuit.Diamonds));
cards.Add(new Card(CardFace.King, CardSuit.Hearts));
cards.Add(new Card(CardFace.Jack, CardSuit.Spades));
cards.Add(new Card(CardFace.Ten, CardSuit.Clubs));
Hand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
bool result = checker.IsFourOfAKind(hand);
bool expected = false;
Assert.AreEqual(expected, result);
}
public void IsFourOfAKindTestNotValidHand()
{
PokerHandsChecker checker = new PokerHandsChecker();
Hand hand = new Hand(new List<ICard>()
{
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.Ace, CardSuit.Spades)
});
bool expectedFourOfAKindHand = false;
bool actual;
actual = checker.IsFourOfAKind(hand);
Assert.AreEqual(expectedFourOfAKindHand, actual);
}
public void TestIfFourOfAKindReturnsTrueWhenGivenAnInValidFourOfAKindHand()
{
var twoHearts = new Card(CardFace.Two, CardSuit.Hearts);
var fourSpades = new Card(CardFace.Four, CardSuit.Spades);
var sevenHearts = new Card(CardFace.Seven, CardSuit.Hearts);
var eightClubs = new Card(CardFace.Eight, CardSuit.Clubs);
var fiveDiamons = new Card(CardFace.Five, CardSuit.Diamonds);
var handList = new List<ICard>();
handList.Add(twoHearts);
handList.Add(fourSpades);
handList.Add(sevenHearts);
handList.Add(eightClubs);
handList.Add(fiveDiamons);
var hand = new Hand(handList);
var checker = new PokerHandsChecker();
Assert.AreEqual(false, checker.IsFourOfAKind(hand), "The method IsFourOfAKind should return true when given a non-four of a kind hand");
}
public void TestIsFourOfAKindSameCards()
{
Card cardOne = new Card(CardFace.Two, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Ace, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Ace, CardSuit.Spades);
Card cardFour = new Card(CardFace.Ace, CardSuit.Clubs);
Card cardFive = new Card(CardFace.Ace, CardSuit.Clubs);
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);
Hand hand = new Hand(cards);
Assert.AreEqual(false, pokerHandsChecker.IsFourOfAKind(hand), "IsFourOfAKind() is not working correctly.");
}
static void Main()
{
ICard card = new Card(CardFace.Ace, CardSuit.Clubs);
Console.WriteLine(card);
IHand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Five, CardSuit.Clubs),
new Card(CardFace.Five, CardSuit.Hearts),
new Card(CardFace.Five, CardSuit.Diamonds),
new Card(CardFace.Nine, CardSuit.Diamonds),
new Card(CardFace.Five, CardSuit.Spades),
});
Console.WriteLine(hand);
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine(checker.IsValidHand(hand));
Console.WriteLine(checker.IsFlush(hand));
Console.WriteLine(checker.IsOnePair(hand));
Console.WriteLine(checker.IsFourOfAKind(hand));
}
internal static int CompareTwoFourOfAKindHands(IHand firstHand, IHand secondHand)
{
if (checker.IsFourOfAKind(firstHand) && !checker.IsFourOfAKind(secondHand))
{
return(1);
}
else if (!checker.IsFourOfAKind(firstHand) && checker.IsFourOfAKind(secondHand))
{
return(-1);
}
int firstHandFourCardsValue = 0;
int firstHandIOtherCardValue = 0;
int secondHnadFourCardssValue = 0;
int secondHandOtherCardValue = 0;
Dictionary <CardFace, int> firstHandCountsOfSameTypeCards = new Dictionary <CardFace, int>();
Dictionary <CardFace, int> secondHandCountsOfSameTypeCards = new Dictionary <CardFace, int>();
for (int i = 0; i < firstHand.Cards.Count; i++)
{
if (firstHandCountsOfSameTypeCards.Keys.Contains(firstHand.Cards[i].Face))
{
firstHandCountsOfSameTypeCards[firstHand.Cards[i].Face] += 1;
}
else
{
firstHandCountsOfSameTypeCards.Add(firstHand.Cards[i].Face, 1);
}
}
for (int u = 0; u < secondHand.Cards.Count; u++)
{
if (secondHandCountsOfSameTypeCards.Keys.Contains(secondHand.Cards[u].Face))
{
secondHandCountsOfSameTypeCards[secondHand.Cards[u].Face] += 1;
}
else
{
secondHandCountsOfSameTypeCards.Add(secondHand.Cards[u].Face, 1);
}
}
foreach (var item in firstHandCountsOfSameTypeCards)
{
if (item.Value == 4)
{
firstHandFourCardsValue = (int)item.Key;
}
if (item.Value == 1)
{
firstHandIOtherCardValue = (int)item.Key;
}
}
foreach (var item in secondHandCountsOfSameTypeCards)
{
if (item.Value == 4)
{
secondHnadFourCardssValue = (int)item.Key;
}
if (item.Value == 1)
{
secondHandOtherCardValue = (int)item.Key;
}
}
if (firstHandFourCardsValue > secondHnadFourCardssValue)
{
return(1);
}
else if (firstHandFourCardsValue < secondHnadFourCardssValue)
{
return(-1);
}
else if (firstHandIOtherCardValue > secondHandOtherCardValue)
{
return(1);
}
else if (firstHandIOtherCardValue < secondHandOtherCardValue)
{
return(-1);
}
else
{
return(0);
}
}
static void Main()
{
ICard card = new Card(CardFace.Ace, CardSuit.Clubs);
Console.WriteLine("Current card is: " + card + Environment.NewLine);
///Normal hand\\\
IHand hand = new Hand(new List <ICard>()
{
new Card(CardFace.Three, CardSuit.Clubs),
new Card(CardFace.Six, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Hearts),
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Diamonds),
});
/////Flush\\\
//IHand hand = new Hand(new List<ICard>() {
// new Card(CardFace.Ace, CardSuit.Clubs),
// new Card(CardFace.Ace, CardSuit.Clubs),
// new Card(CardFace.King, CardSuit.Clubs),
// new Card(CardFace.King, CardSuit.Clubs),
// new Card(CardFace.Seven, CardSuit.Clubs),
//});
/////Four of a kind\\\
//IHand hand = new Hand(new List<ICard>() {
// new Card(CardFace.Ace, CardSuit.Clubs),
// new Card(CardFace.Ace, CardSuit.Diamonds),
// new Card(CardFace.Ace, CardSuit.Hearts),
// new Card(CardFace.Ace, CardSuit.Spades),
// new Card(CardFace.Eight, CardSuit.Clubs),
//});
/////One pair\\\
//IHand hand = new Hand(new List<ICard>() {
// new Card(CardFace.Ace, CardSuit.Clubs),
// new Card(CardFace.Ace, CardSuit.Diamonds),
// new Card(CardFace.Five, CardSuit.Hearts),
// new Card(CardFace.Jack, CardSuit.Spades),
// new Card(CardFace.Eight, CardSuit.Clubs),
//});
/////Two pairs\\\
//IHand hand = new Hand(new List<ICard>() {
// new Card(CardFace.Ace, CardSuit.Clubs),
// new Card(CardFace.Ace, CardSuit.Diamonds),
// new Card(CardFace.Five, CardSuit.Hearts),
// new Card(CardFace.Jack, CardSuit.Spades),
// new Card(CardFace.Jack, CardSuit.Clubs),
//});
/////Straight Flush\\\
//IHand hand = new Hand(new List<ICard>() {
// new Card(CardFace.Jack, CardSuit.Clubs),
// new Card(CardFace.Ten, CardSuit.Clubs),
// new Card(CardFace.Nine, CardSuit.Clubs),
// new Card(CardFace.Eight, CardSuit.Clubs),
// new Card(CardFace.Seven, CardSuit.Clubs),
//});
/////Full House\\\
//IHand hand = new Hand(new List<ICard>() {
// new Card(CardFace.Six, CardSuit.Diamonds),
// new Card(CardFace.Six, CardSuit.Hearts),
// new Card(CardFace.Nine, CardSuit.Clubs),
// new Card(CardFace.Nine, CardSuit.Spades),
// new Card(CardFace.Nine, CardSuit.Clubs),
//});
/////Straight\\\
//IHand hand = new Hand(new List<ICard>() {
// new Card(CardFace.King, CardSuit.Diamonds),
// new Card(CardFace.Queen, CardSuit.Hearts),
// new Card(CardFace.Jack, CardSuit.Clubs),
// new Card(CardFace.Ten, CardSuit.Spades),
// new Card(CardFace.Nine, CardSuit.Clubs),
//});
Console.WriteLine(hand + Environment.NewLine);
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine("Is this hand valid: " + checker.IsValidHand(hand));
Console.WriteLine("Do you have one pair: " + checker.IsOnePair(hand));
Console.WriteLine("Do you have two pairs: " + checker.IsTwoPair(hand));
Console.WriteLine("Do you have a flush: " + checker.IsFlush(hand));
Console.WriteLine("Do you have four of a kind: " + checker.IsFourOfAKind(hand));
Console.WriteLine("Do you have three of a kind: " + checker.IsThreeOfAKind(hand));
Console.WriteLine("Do you have straight flush: " + checker.IsStraightFlush(hand));
Console.WriteLine("Do you have a full house: " + checker.IsFullHouse(hand));
Console.WriteLine("Do you have a straight: " + checker.IsStraight(hand));
Console.WriteLine("Do you have high card: " + checker.IsHighCard(hand));
}
