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));
            }
        }
        public void TestDeckOfCardsShuffle()
        {
            DeckOfCards deck  = new DeckOfCards();
            List <Card> cards = new List <Card>();

            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);
            Random anotherRandom           = new Random();
            List <List <Card> > binOfDecks = new List <List <Card> >();
            DeckOfCards         temp       = new DeckOfCards();

            int TWO_THREE_FOUR  = 0;
            int TWO_FOUR_THREE  = 0;
            int THREE_TWO_FOUR  = 0;
            int THREE_FOUR_TWO  = 0;
            int FOUR_TWO_FOUR   = 0;
            int FOUR_THREE_FOUR = 0;

            for (int shuffleOverload = 0; shuffleOverload < 3; shuffleOverload++)
            {
                for (int i = 0; i < 1000; i++)
                {
                    switch (shuffleOverload)
                    {
                    case 0:
                        deck.Shuffle();
                        break;

                    case 1:
                        deck.Shuffle(new DeckOfCards(cards));
                        break;

                    case 2:
                        deck.Shuffle(new DeckOfCards(cards), anotherRandom);
                        break;

                    default:
                        throw new IndexOutOfRangeException("Shuffle only has three overloads but the shuffleOverload index is not 0,1 or 2");
                    }
                    temp = deck.CloneDeck();
                    //each permumtation
                    Card[] twoThreeFour  = new Card[] { new Card(Suit.Spades, FaceValue.Two), new Card(Suit.Spades, FaceValue.Three), new Card(Suit.Spades, FaceValue.Four) };
                    Card[] twoFourThree  = new Card[] { new Card(Suit.Spades, FaceValue.Two), new Card(Suit.Spades, FaceValue.Four), new Card(Suit.Spades, FaceValue.Three) };
                    Card[] threeTwoFour  = new Card[] { new Card(Suit.Spades, FaceValue.Three), new Card(Suit.Spades, FaceValue.Two), new Card(Suit.Spades, FaceValue.Four) };
                    Card[] threeFourTwo  = new Card[] { new Card(Suit.Spades, FaceValue.Three), new Card(Suit.Spades, FaceValue.Four), new Card(Suit.Spades, FaceValue.Two) };
                    Card[] fourTwoThree  = new Card[] { new Card(Suit.Spades, FaceValue.Four), new Card(Suit.Spades, FaceValue.Two), new Card(Suit.Spades, FaceValue.Three) };
                    Card[] fourThreeFour = new Card[] { new Card(Suit.Spades, FaceValue.Four), new Card(Suit.Spades, FaceValue.Three), new Card(Suit.Spades, FaceValue.Two) };

                    //bins
                    TWO_THREE_FOUR  += temp.CardDeck.SequenceEqual(twoThreeFour) == true ? 1 : 0;
                    TWO_FOUR_THREE  += temp.CardDeck.SequenceEqual(twoFourThree) == true ? 1 : 0;
                    THREE_TWO_FOUR  += temp.CardDeck.SequenceEqual(threeTwoFour) == true ? 1 : 0;
                    THREE_FOUR_TWO  += temp.CardDeck.SequenceEqual(threeFourTwo) == true ? 1 : 0;
                    FOUR_TWO_FOUR   += temp.CardDeck.SequenceEqual(fourTwoThree) == true ? 1 : 0;
                    FOUR_THREE_FOUR += temp.CardDeck.SequenceEqual(fourThreeFour) == true ? 1 : 0;
                }
                ///TODO find a good way to test randomness. This is not a good way. See commments above this function.
                Assert.IsTrue((TWO_THREE_FOUR < 333) && (TWO_THREE_FOUR > 88));
                Assert.IsTrue((TWO_FOUR_THREE < 333) && (TWO_FOUR_THREE > 88));
                Assert.IsTrue((THREE_TWO_FOUR < 333) && (THREE_TWO_FOUR > 88));
                Assert.IsTrue((THREE_FOUR_TWO < 333) && (THREE_FOUR_TWO > 88));
                Assert.IsTrue((FOUR_TWO_FOUR < 333) && (FOUR_TWO_FOUR > 88));
                Assert.IsTrue((FOUR_THREE_FOUR < 333) && (FOUR_THREE_FOUR > 88));

                TWO_THREE_FOUR  = 0;
                TWO_FOUR_THREE  = 0;
                THREE_TWO_FOUR  = 0;
                THREE_FOUR_TWO  = 0;
                FOUR_TWO_FOUR   = 0;
                FOUR_THREE_FOUR = 0;
                ///TODO go here and read and finish data base connection

                /* https://msdn.microsoft.com/en-us/library/bb384428.aspx
                 * using (var db = new TestShuffleResults())
                 * {
                 *   db.(new TestDeckOfCardsShuffleUnitTestResult
                 *  { tWO_THREE_FOUR = TWO_THREE_FOUR, tWO_FOUR_THREE  = TWO_FOUR_THREE , tHREE_TWO_FOUR = THREE_TWO_FOUR,
                 *      tHREE_FOUR_TWO = THREE_TWO_FOUR, fOUR_TWO_FOUR = FOUR_TWO_FOUR, fOUR_THREE_FOUR = FOUR_THREE_FOUR });
                 *   db.SaveChanges();
                 *
                 *
                 */
            }
        }