public void TestContainsFaceValue()
        {
            DeckOfCards cards = new DeckOfCards();

            cards.InitialiseCards();
            int index = 0;

            foreach (Card c in cards.GetCardEnumerator())
            {
                Assert.IsTrue(cards.ContainsFaceValue(this.completeDeck[index++].faceValue));
            }

            List <Card> tinyOnlyTwoFaceValueListofCards = new List <Card>();

            tinyOnlyTwoFaceValueListofCards.Add(new Card(Suit.Clubs, FaceValue.Two));
            DeckOfCards tinyTwoDeck = new DeckOfCards(tinyOnlyTwoFaceValueListofCards);

            foreach (Card completeDeckCard in this.completeDeck)
            {
                if (completeDeckCard.faceValue != FaceValue.Two)
                {
                    Assert.IsFalse(tinyTwoDeck.ContainsFaceValue(completeDeckCard.faceValue));
                }
            }
        }
        public void TestDeckOfCardsGetEnumerator()
        {
            int         index = 0;
            DeckOfCards deck  = new DeckOfCards();

            deck.InitialiseCards();
            foreach (Card c in deck.GetCardEnumerator())
            {
                Assert.AreEqual(completeDeck[index++], c);
            }
            Assert.AreEqual(index, 52);// correct number of cards.
        }
        public void TestSetDeck()
        {
            DeckOfCards deck  = new DeckOfCards();
            List <Card> cards = new List <Card>();

            Card[] threeCards = { new Card(Suit.Spades, FaceValue.Two),
                                  new Card(Suit.Spades, FaceValue.Three),
                                  new Card(Suit.Spades, FaceValue.Four) };

            cards.Add(new Card(Suit.Spades, FaceValue.Two));
            cards.Add(new Card(Suit.Spades, FaceValue.Three));
            cards.Add(new Card(Suit.Spades, FaceValue.Four));

            deck.SetDeck(cards);
            IEnumerable <Tuple <Card, Card> > deckAndTestCardListMultpleEnumerator =
                MultipleIterate.Over(deck.GetCardEnumerator(), threeCards);

            foreach (var decksTuple in deckAndTestCardListMultpleEnumerator)
            {
                Assert.AreEqual(decksTuple.Item1, decksTuple.Item2);
            }
        }
        public void TestCloneDeck()
        {
            //completeDeck
            DeckOfCards deck       = new DeckOfCards();
            DeckOfCards clonedDeck = deck.CloneDeck();

            //Check that the cloneDeck is a different reference to private field DeckOfCards.cardDeck
            PrivateObject pObj = new PrivateObject(deck);
            List <Card>   useToCheckCloneMakesADifferentReference = (List <Card>)pObj.GetField("cardDeck");

            Assert.IsFalse(Object.ReferenceEquals(useToCheckCloneMakesADifferentReference, clonedDeck));

            //Check values of cards in the clonedDeck are the same as in the DeckOfCards.cardDeck
            IEnumerable <Tuple <Card, Card> > tupledEnumerator = MultipleIterate.Over(clonedDeck.GetCardEnumerator(), deck.GetCardEnumerator());

            foreach (var decksTuple in tupledEnumerator)
            {
                Assert.AreEqual(decksTuple.Item1, decksTuple.Item2);
                Assert.IsFalse(Object.ReferenceEquals(decksTuple.Item1, decksTuple.Item2));
            }
        }