Пример #1
0
        public void Test_Game_Shuffle(bool createDeck)
        {
            const int numberOfShuffles = 1;

            IBattleOutput battleOutput = new Fake_BattleOutput();
            Game          game         = new Game(battleOutput);
            CardPile      deck         = new CardPile();

            if (createDeck)
            {
                game.CreateDeck(deck);
            }

            List <Card> preShuffleCards = deck.GetAll();

            deck.Shuffle(numberOfShuffles);
            List <Card> postShuffleCards = deck.GetAll();

            Assert.True(preShuffleCards.Count == postShuffleCards.Count);

            if (!createDeck)
            {
                Assert.Equal <Card>(preShuffleCards, postShuffleCards);
            }
            else
            {
                Assert.NotEqual <Card>(preShuffleCards, postShuffleCards);
                foreach (Card card in preShuffleCards)
                {
                    Assert.Contains(postShuffleCards, c => (string.Equals(c.Name, card.Name) && (c.Value == card.Value)));
                }
            }
        }
Пример #2
0
        public void Test_CardPile_GetAll(int numberOfCards)
        {
            List <Card> cards    = Enumerable.Repeat(new Card(CardSuit.SPADE, CardRank.RANK_KING), numberOfCards).ToList();
            CardPile    cardPile = new CardPile(cards);

            Assert.True(cards.Count == cardPile.GetAll().Count);
            Assert.Equal <Card>(cards, cardPile.GetAll());
        }
Пример #3
0
        public void Test_CardPile_RemoveAll(int numberOfCards)
        {
            List <Card> cards    = Enumerable.Repeat(new Card(CardSuit.DIAMOND, CardRank.RANK_QUEEN), numberOfCards).ToList();
            CardPile    cardPile = new CardPile(cards);

            cardPile.RemoveAll();

            Assert.Empty(cardPile.GetAll());
        }
Пример #4
0
        public void Test_CardPile_AddCards(int numberOfCards)
        {
            List <Card> cards = Enumerable.Repeat(new Card(CardSuit.HEART, CardRank.RANK_JACK), numberOfCards).ToList();

            CardPile cardPile = new CardPile();

            cardPile.AddCards(cards);

            Assert.True(cards.Count == cardPile.NumberOfCards);
            Assert.Equal <Card>(cards, cardPile.GetAll());
        }
Пример #5
0
        public void Test_Game_CreateDeck()
        {
            IBattleOutput battleOutput = new Fake_BattleOutput();
            Game          game         = new Game(battleOutput);
            CardPile      deck         = new CardPile();

            game.CreateDeck(deck);

            List <Card> cards = CreateCardDeck();

            List <Card> deckCards = deck.GetAll();

            foreach (Card card in cards)
            {
                Assert.Contains(deckCards, c => (string.Equals(c.Name, card.Name) && (c.Value == card.Value)));
            }

            Assert.True(cards.Count == deckCards.Count);
        }
Пример #6
0
        public void Test_CardPile_Shuffle(int?numberOfShuffles)
        {
            List <Card> cards = new List <Card>();

            foreach (CardSuit suit in Enum.GetValues(typeof(CardSuit)))
            {
                foreach (CardRank rank in Enum.GetValues(typeof(CardRank)))
                {
                    cards.Add(new Card(suit, rank));
                }
            }

            CardPile cardPile = new CardPile(cards);


            if (numberOfShuffles == null)
            {
                cardPile.Shuffle();
            }
            else
            {
                cardPile.Shuffle(numberOfShuffles ?? 0);
            }


            List <Card> actualCards = cardPile.GetAll();

            if (numberOfShuffles <= 0)
            {
                Assert.Equal <Card>(cards, actualCards);
            }
            else
            {
                Assert.NotEqual <Card>(cards, actualCards);
            }

            Assert.True(cards.Count == actualCards.Count);
        }