public void Constructor_ShouldNotThrow()
        {
            StandardDeckProvider target = new StandardDeckProvider();

            Assert.IsNotNull(target);

            return;
        }
        public void CreateDeckTest_WithShuffle()
        {
            StandardDeckProvider provider = new StandardDeckProvider();
            List<StandardCard> cards = provider.OrderedSetOfCards.ToList();

            Deck<StandardCard> deck = provider.CreateDeck(3, true);
            bool isValid = IsValid_ShuffledDuplication(cards, deck, 3);
            Assert.IsTrue(isValid, "The creation a deck by the StandardDeckProvier did not return a shuffled deck.");
        }
        public void ProvideCards_ShouldReturnCorrectNumberOfCards()
        {
            StandardDeckProvider target = new StandardDeckProvider();
            IEnumerable <Card>   cards  = target.ProvideCards();
            int count = cards.Count <Card>();

            Assert.AreEqual(56, count); // This is the same as StandardDeckProvider.StandardDeckSize.

            return;
        }
        public void CreateDeckTest_MultiDeck()
        {
            StandardDeckProvider provider = new StandardDeckProvider();
            List<StandardCard> cards = provider.OrderedSetOfCards.ToList();

            Deck<StandardCard> deck = provider.CreateDeck(3, false);
            bool isValid = IsValid_CollatedDuplication(cards, deck, 3);
            Assert.IsTrue(isValid, "The creation a deck by the StandardDeckProvier did not return a non-shuffled deck in a collated manner as expected.");

            Deck<StandardCard> shuffledDeck = provider.CreateDeck(3, true);
            bool isInvalid = !IsValid_CollatedDuplication(cards, shuffledDeck, 3);
            Assert.IsTrue(isInvalid, "The creation of a shuffled deck by the StandardDeckProvider returned a deck that was fully collated and unshuffled. This maybe possible, but winning the lottery is more likely.");
        }
        public void ShuffleTest_SameContent()
        {
            StandardDeckProvider provider = new StandardDeckProvider();
            List<StandardCard> orderedCards = provider.OrderedSetOfCards.ToList();

            int numberOfCards = provider.OrderedSetOfCards.Count();
            Assert.IsTrue(numberOfCards > 0);

            IEnumerable<StandardCard> shuffledCards = provider.ShuffledCards;
            foreach (StandardCard card in shuffledCards)
            {
                orderedCards.Remove(card);
            }

            Assert.AreEqual<int>(0, orderedCards.Count);
        }
        public void ShuffleTest()
        {
            StandardDeckProvider provider = new StandardDeckProvider();
            IEnumerable<StandardCard> orderedCards = provider.OrderedSetOfCards;

            int numberOfCards = provider.OrderedSetOfCards.Count();
            Assert.IsTrue(numberOfCards > 0);

            IEnumerable<StandardCard> shuffledCards1 = provider.ShuffledCards;
            bool different = VerifyDifferentOrder(orderedCards, shuffledCards1);
            Assert.IsTrue(different);
            Assert.AreEqual<int>(numberOfCards, shuffledCards1.Count());

            IEnumerable<StandardCard> shuffledCards2 = provider.ShuffledCards;
            bool shuffledDifferent = VerifyDifferentOrder(shuffledCards1, shuffledCards2);
            Assert.IsTrue(shuffledDifferent);
            Assert.AreEqual<int>(numberOfCards, shuffledCards2.Count());
        }
        public void StandardDeckProviderConstructorTest()
        {
            StandardDeckProvider target = new StandardDeckProvider();

            int numberOfCards = 54;
            Assert.AreEqual<int>(numberOfCards, target.OrderedSetOfCards.Count());
            Assert.AreEqual<int>(0, target.OrderedSetOfCards.Where(Card => Card.Type == StandardCardTypes.Unknown).Count());
            Assert.AreEqual<int>(2, target.OrderedSetOfCards.Where(card => card.Type == StandardCardTypes.Joker).Count());
            Assert.AreEqual<int>(13, target.OrderedSetOfCards.Where(card => card.Type == StandardCardTypes.Clover).Select(card => card.Value.ToString()).Distinct().Count());
            Assert.AreEqual<int>(13, target.OrderedSetOfCards.Where(card => card.Type == StandardCardTypes.Diamond).Select(card => card.Value.ToString()).Distinct().Count());
            Assert.AreEqual<int>(13, target.OrderedSetOfCards.Where(card => card.Type == StandardCardTypes.Heart).Select(card => card.Value.ToString()).Distinct().Count());
            Assert.AreEqual<int>(13, target.OrderedSetOfCards.Where(card => card.Type == StandardCardTypes.Spade).Select(card => card.Value.ToString()).Distinct().Count());
            Assert.AreEqual<int>(5, target.OrderedSetOfCards.Select(card => card.Type).Distinct().Count());
        }