示例#1
0
        public void BuildTest()
        {
            GameState G = new GameState(DeckChoiceUI.COMBO_DECK, DeckChoiceUI.COMBO_DECK, true, 0);
            // For a minion
            CardBuilder MinionBuilder = new CardBuilder
            {
                TypeID           = CardBuilder.CardType.Minion,
                AttackData       = 2,
                HealthData       = 3,
                NameData         = "MIN1",
                DescriptionData  = "ABCXYZ",
                MinionOnPlayData = (s, m) =>
                {
                },
                MinionEffectData = new EffectData <MinionCard>()
                {
                    {
                        Effect.CardDrawn, (s, m) =>
                        {
                        }
                    }
                },
            };
            MinionCard Minion = MinionBuilder.Build(G, G.PlayerOne) as MinionCard;

            Assert.AreEqual(MinionBuilder.AttackData, Minion.Attack);
            Assert.AreEqual(MinionBuilder.HealthData, Minion.Health);
            Assert.AreEqual(MinionBuilder.NameData, Minion.Name);
            Assert.AreEqual(MinionBuilder.DescriptionData, Minion.Description);
            Assert.AreEqual(MinionBuilder.MinionOnPlayData, Minion.OnPlay);
            Assert.AreEqual(MinionBuilder.MinionEffectData, Minion.Effects);
        }
示例#2
0
        //Not adding all input tests due to time constraint and jumping to Transaction tests
        private Card CreateValidCard()
        {
            CardBuilder cardBuilder = new CardBuilder()
                                      .WithName(validName)
                                      .WithNumber(CardNumberProvider.GetNewCardNumber())
                                      .WithCvv(CardNumberProvider.GetNewCvv())
                                      .WithPin(validPin)
                                      .WithExpiry(DateTime.Now.AddDays(2));

            return(cardBuilder.Build());
        }
示例#3
0
        public void Given_InputSuppliedByRandomise_BuilderShould_AbleToCreateCardSuccessfuly()
        {
            CardBuilder cardBuilder = new CardBuilder()
                                      .WithName(validName)
                                      .WithNumber(CardNumberProvider.GetNewCardNumber())
                                      .WithCvv(CardNumberProvider.GetNewCvv())
                                      .WithPin(CardNumberProvider.GetNewPin())
                                      .WithExpiry(DateTime.Now.AddDays(2));

            Assert.DoesNotThrow(() => cardBuilder.Build());
        }
示例#4
0
        public void Contains()
        {
            var cards = new List <Card>
            {
                CardBuilder.Build(new Guid("0541D8C7-60F1-4B17-8EF8-B0CF7DC84AAB")).WithPoints(5, 6, 5, 4),
                CardBuilder.Build(new Guid("3DF588B1-EDB8-43B4-8E81-9A740D1575A7")).WithPoints(5, 7, 2, 3),
                CardBuilder.Build(new Guid("A30E1A89-6C5A-4B57-8B46-833D97C99788")).WithPoints(3, 6, 2, 6),
                CardBuilder.Build(new Guid("F85DD7C4-4FD1-4D0E-A359-D7AA0DFD37BF")).WithPoints(7, 1, 6, 4),
                CardBuilder.Build(new Guid("FD9E90D1-F053-4AD7-BDB2-625B757B8C5D")).WithPoints(3, 6, 2, 7)
            };

            foreach (var card in cards)
            {
                Assert.IsTrue(cards.Contains(card.Id));
            }

            for (var i = 0; i < 1000; i++)
            {
                Assert.IsFalse(cards.Contains(Guid.NewGuid()));
            }
        }
示例#5
0
        public void TestCardBuilder()
        {
            const string testcase0 = "";
            CardBuilder  builder   = new CardBuilder(new Tokenizer(new StringReader(testcase0)));

            Assert.IsNull(builder.Build());

            const string testcase1 = "2S";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase1)));
            var card = builder.Build();

            Assert.IsNotNull(card);
            Assert.AreEqual('S', card.Suit);
            Assert.AreEqual("2", card.Rank);
            Assert.AreEqual(1, card.SuitIndex);
            Assert.AreEqual(0, card.RankIndex);

            const string testcase2 = "10H";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase2)));
            card    = builder.Build();
            Assert.IsNotNull(card);
            Assert.AreEqual('H', card.Suit);
            Assert.AreEqual("10", card.Rank);
            Assert.AreEqual(3, card.SuitIndex);
            Assert.AreEqual(8, card.RankIndex);

            const string testcase3 = "AD";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase3)));
            card    = builder.Build();
            Assert.IsNotNull(card);
            Assert.AreEqual('D', card.Suit);
            Assert.AreEqual("A", card.Rank);
            Assert.AreEqual(2, card.SuitIndex);
            Assert.AreEqual(12, card.RankIndex);

            const string testcase4 = "JC";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase4)));
            card    = builder.Build();
            Assert.IsNotNull(card);
            Assert.AreEqual('C', card.Suit);
            Assert.AreEqual("J", card.Rank);
            Assert.AreEqual(0, card.SuitIndex);
            Assert.AreEqual(9, card.RankIndex);

            const string testcase5 = "2";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase5)));
            var ex = Assert.ThrowsException <Exception>(() => builder.Build());

            Assert.AreEqual(ex.Message, "Invalid card format");

            const string testcase6 = "2A";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase6)));
            ex      = Assert.ThrowsException <Exception>(() => builder.Build());
            Assert.AreEqual(ex.Message, "Invalid card format");

            const string testcase7 = "1C";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase7)));
            ex      = Assert.ThrowsException <Exception>(() => builder.Build());
            Assert.AreEqual(ex.Message, "Invalid card format");

            const string testcase8 = "PC";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase8)));
            ex      = Assert.ThrowsException <Exception>(() => builder.Build());
            Assert.AreEqual(ex.Message, "Invalid card format");

            const string testcase9 = "A";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase9)));
            ex      = Assert.ThrowsException <Exception>(() => builder.Build());
            Assert.AreEqual(ex.Message, "Invalid card format");

            const string testcase10 = "as";

            builder = new CardBuilder(new Tokenizer(new StringReader(testcase10)));
            card    = builder.Build();
            Assert.IsNotNull(card);
            Assert.AreEqual('S', card.Suit);
            Assert.AreEqual("A", card.Rank);
            Assert.AreEqual(1, card.SuitIndex);
            Assert.AreEqual(12, card.RankIndex);
        }
        public void Run()
        {
            var player01 = new Player
            {
                Id    = 1.ToGuid(),
                Name  = "Squall Leonhart",
                Color = Color.Magenta,
                Cards = new List <Card>
                {
                    CardBuilder.Build(1).WithPoints(5, 6, 5, 4),
                    CardBuilder.Build(2).WithPoints(5, 7, 2, 3),
                    CardBuilder.Build(3).WithPoints(3, 6, 2, 6),
                    CardBuilder.Build(4).WithPoints(7, 1, 6, 4),
                    CardBuilder.Build(5).WithPoints(3, 6, 2, 7)
                }
            };

            var player02 = new Player
            {
                Id    = 2.ToGuid(),
                Name  = "Rinoa Heartilly",
                Color = Color.Blue,
                Cards = new List <Card>
                {
                    CardBuilder.Build(6).WithPoints(4, 6, 9, 10),
                    CardBuilder.Build(7).WithPoints(10, 4, 10, 2),
                    CardBuilder.Build(8).WithPoints(6, 8, 5, 10),
                    CardBuilder.Build(9).WithPoints(2, 9, 6, 10),
                    CardBuilder.Build(10).WithPoints(3, 5, 10, 8)
                }
            };

            var newGameCommand = new NewGameCommand
            {
                Rows                    = 3,
                Columns                 = 3,
                EnableSameRule          = false,
                EnableSameWallRule      = false,
                EnablePlusRule          = false,
                EnableComboRule         = false,
                EnableElementalRule     = false,
                ProbabilityOfElementary = 0.2d,
                StartPlayerId           = player02.Id,
                Players                 = new List <Player>
                {
                    player01,
                    player02
                }
            };

            var cardValidator           = new CardValidator();
            var playerValidator         = new PlayerValidator(cardValidator);
            var newGameCommandValidator = new NewGameCommandValidator(playerValidator);

            var gameService = new GameService(newGameCommandValidator);

            var game = gameService.CreateNewGame(newGameCommand);

            Assert.AreEqual(game.Board.Rows, 3);
            Assert.AreEqual(game.Board.Columns, 3);

            for (var row = 0; row < game.Board.Rows; row++)
            {
                for (var column = 0; column < game.Board.Columns; column++)
                {
                    Assert.IsTrue(game.Board[row, column].Empty);
                }
            }

            Assert.AreEqual(player01.Cards.Count, 5);
            Assert.AreEqual(player02.Cards.Count, 5);
            Assert.AreEqual(game.CurrentPlayer.Id, player02.Id);

            Assert.AreEqual(5, game.Scoreboard[player01.Id]);
            Assert.AreEqual(5, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 1º JOGADA */

            game.Play(new PlayCommand(player02.Id, 10, 0, 0));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[0, 1].Empty);
            Assert.IsTrue(game.Board[0, 2].Empty);

            Assert.IsTrue(game.Board[1, 0].Empty);
            Assert.IsTrue(game.Board[1, 1].Empty);
            Assert.IsTrue(game.Board[1, 2].Empty);

            Assert.IsTrue(game.Board[2, 0].Empty);
            Assert.IsTrue(game.Board[2, 1].Empty);
            Assert.IsTrue(game.Board[2, 2].Empty);

            Assert.AreEqual(5, game.Scoreboard[player01.Id]);
            Assert.AreEqual(5, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 2º JOGADA */

            game.Play(new PlayCommand(player01.Id, 1, 2, 0));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[0, 1].Empty);
            Assert.IsTrue(game.Board[0, 2].Empty);

            Assert.IsTrue(game.Board[1, 0].Empty);
            Assert.IsTrue(game.Board[1, 1].Empty);
            Assert.IsTrue(game.Board[1, 2].Empty);

            Assert.IsFalse(game.Board[2, 0].Empty);
            Assert.AreEqual(game.Board[2, 0].Card.Id, 1.ToGuid());
            Assert.AreEqual(game.Board[2, 0].Owner.Id, player01.Id);
            Assert.IsTrue(game.Board[2, 1].Empty);
            Assert.IsTrue(game.Board[2, 2].Empty);

            Assert.AreEqual(5, game.Scoreboard[player01.Id]);
            Assert.AreEqual(5, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 3º JOGADA */

            game.Play(new PlayCommand(player02.Id, 6, 1, 0));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[0, 1].Empty);
            Assert.IsTrue(game.Board[0, 2].Empty);

            Assert.IsFalse(game.Board[1, 0].Empty);
            Assert.AreEqual(game.Board[1, 0].Card.Id, 6.ToGuid());
            Assert.AreEqual(game.Board[1, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[1, 1].Empty);
            Assert.IsTrue(game.Board[1, 2].Empty);

            Assert.IsFalse(game.Board[2, 0].Empty);
            Assert.AreEqual(game.Board[2, 0].Card.Id, 1.ToGuid());
            Assert.AreEqual(game.Board[2, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[2, 1].Empty);
            Assert.IsTrue(game.Board[2, 2].Empty);

            Assert.AreEqual(4, game.Scoreboard[player01.Id]);
            Assert.AreEqual(6, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 4º JOGADA */

            game.Play(new PlayCommand(player01.Id, 2, 1, 2));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[0, 1].Empty);
            Assert.IsTrue(game.Board[0, 2].Empty);

            Assert.IsFalse(game.Board[1, 0].Empty);
            Assert.AreEqual(game.Board[1, 0].Card.Id, 6.ToGuid());
            Assert.AreEqual(game.Board[1, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[1, 1].Empty);
            Assert.IsFalse(game.Board[1, 2].Empty);
            Assert.AreEqual(game.Board[1, 2].Card.Id, 2.ToGuid());
            Assert.AreEqual(game.Board[1, 2].Owner.Id, player01.Id);

            Assert.IsFalse(game.Board[2, 0].Empty);
            Assert.AreEqual(game.Board[2, 0].Card.Id, 1.ToGuid());
            Assert.AreEqual(game.Board[2, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[2, 1].Empty);
            Assert.IsTrue(game.Board[2, 2].Empty);

            Assert.AreEqual(4, game.Scoreboard[player01.Id]);
            Assert.AreEqual(6, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 5º JOGADA */

            game.Play(new PlayCommand(player02.Id, 8, 2, 2));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[0, 1].Empty);
            Assert.IsTrue(game.Board[0, 2].Empty);

            Assert.IsFalse(game.Board[1, 0].Empty);
            Assert.AreEqual(game.Board[1, 0].Card.Id, 6.ToGuid());
            Assert.AreEqual(game.Board[1, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[1, 1].Empty);
            Assert.IsFalse(game.Board[1, 2].Empty);
            Assert.AreEqual(game.Board[1, 2].Card.Id, 2.ToGuid());
            Assert.AreEqual(game.Board[1, 2].Owner.Id, player02.Id);

            Assert.IsFalse(game.Board[2, 0].Empty);
            Assert.AreEqual(game.Board[2, 0].Card.Id, 1.ToGuid());
            Assert.AreEqual(game.Board[2, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[2, 1].Empty);
            Assert.IsFalse(game.Board[2, 2].Empty);
            Assert.AreEqual(game.Board[2, 2].Card.Id, 8.ToGuid());
            Assert.AreEqual(game.Board[2, 2].Owner.Id, player02.Id);

            Assert.AreEqual(3, game.Scoreboard[player01.Id]);
            Assert.AreEqual(7, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 6º JOGADA */

            game.Play(new PlayCommand(player01.Id, 3, 2, 1));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[0, 1].Empty);
            Assert.IsTrue(game.Board[0, 2].Empty);

            Assert.IsFalse(game.Board[1, 0].Empty);
            Assert.AreEqual(game.Board[1, 0].Card.Id, 6.ToGuid());
            Assert.AreEqual(game.Board[1, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[1, 1].Empty);
            Assert.IsFalse(game.Board[1, 2].Empty);
            Assert.AreEqual(game.Board[1, 2].Card.Id, 2.ToGuid());
            Assert.AreEqual(game.Board[1, 2].Owner.Id, player02.Id);

            Assert.IsFalse(game.Board[2, 0].Empty);
            Assert.AreEqual(game.Board[2, 0].Card.Id, 1.ToGuid());
            Assert.AreEqual(game.Board[2, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[2, 1].Empty);
            Assert.AreEqual(game.Board[2, 1].Card.Id, 3.ToGuid());
            Assert.AreEqual(game.Board[2, 1].Owner.Id, player01.Id);
            Assert.IsFalse(game.Board[2, 2].Empty);
            Assert.AreEqual(game.Board[2, 2].Card.Id, 8.ToGuid());
            Assert.AreEqual(game.Board[2, 2].Owner.Id, player02.Id);

            Assert.AreEqual(3, game.Scoreboard[player01.Id]);
            Assert.AreEqual(7, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 7º JOGADA */

            game.Play(new PlayCommand(player02.Id, 9, 1, 1));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsTrue(game.Board[0, 1].Empty);
            Assert.IsTrue(game.Board[0, 2].Empty);

            Assert.IsFalse(game.Board[1, 0].Empty);
            Assert.AreEqual(game.Board[1, 0].Card.Id, 6.ToGuid());
            Assert.AreEqual(game.Board[1, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[1, 1].Empty);
            Assert.AreEqual(game.Board[1, 1].Card.Id, 9.ToGuid());
            Assert.AreEqual(game.Board[1, 1].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[1, 2].Empty);
            Assert.AreEqual(game.Board[1, 2].Card.Id, 2.ToGuid());
            Assert.AreEqual(game.Board[1, 2].Owner.Id, player02.Id);

            Assert.IsFalse(game.Board[2, 0].Empty);
            Assert.AreEqual(game.Board[2, 0].Card.Id, 1.ToGuid());
            Assert.AreEqual(game.Board[2, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[2, 1].Empty);
            Assert.AreEqual(game.Board[2, 1].Card.Id, 3.ToGuid());
            Assert.AreEqual(game.Board[2, 1].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[2, 2].Empty);
            Assert.AreEqual(game.Board[2, 2].Card.Id, 8.ToGuid());
            Assert.AreEqual(game.Board[2, 2].Owner.Id, player02.Id);

            Assert.AreEqual(2, game.Scoreboard[player01.Id]);
            Assert.AreEqual(8, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 8º JOGADA */

            game.Play(new PlayCommand(player01.Id, 4, 0, 1));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[0, 1].Empty);
            Assert.AreEqual(game.Board[0, 1].Card.Id, 4.ToGuid());
            Assert.AreEqual(game.Board[0, 1].Owner.Id, player01.Id);
            Assert.IsTrue(game.Board[0, 2].Empty);

            Assert.IsFalse(game.Board[1, 0].Empty);
            Assert.AreEqual(game.Board[1, 0].Card.Id, 6.ToGuid());
            Assert.AreEqual(game.Board[1, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[1, 1].Empty);
            Assert.AreEqual(game.Board[1, 1].Card.Id, 9.ToGuid());
            Assert.AreEqual(game.Board[1, 1].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[1, 2].Empty);
            Assert.AreEqual(game.Board[1, 2].Card.Id, 2.ToGuid());
            Assert.AreEqual(game.Board[1, 2].Owner.Id, player02.Id);

            Assert.IsFalse(game.Board[2, 0].Empty);
            Assert.AreEqual(game.Board[2, 0].Card.Id, 1.ToGuid());
            Assert.AreEqual(game.Board[2, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[2, 1].Empty);
            Assert.AreEqual(game.Board[2, 1].Card.Id, 3.ToGuid());
            Assert.AreEqual(game.Board[2, 1].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[2, 2].Empty);
            Assert.AreEqual(game.Board[2, 2].Card.Id, 8.ToGuid());
            Assert.AreEqual(game.Board[2, 2].Owner.Id, player02.Id);

            Assert.AreEqual(2, game.Scoreboard[player01.Id]);
            Assert.AreEqual(8, game.Scoreboard[player02.Id]);

            Assert.IsFalse(game.Finished);

            /* 9º JOGADA */

            game.Play(new PlayCommand(player02.Id, 7, 0, 2));

            Assert.IsFalse(game.Board[0, 0].Empty);
            Assert.AreEqual(game.Board[0, 0].Card.Id, 10.ToGuid());
            Assert.AreEqual(game.Board[0, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[0, 1].Empty);
            Assert.AreEqual(game.Board[0, 1].Card.Id, 4.ToGuid());
            Assert.AreEqual(game.Board[0, 1].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[0, 2].Empty);
            Assert.AreEqual(game.Board[0, 2].Card.Id, 7.ToGuid());
            Assert.AreEqual(game.Board[0, 2].Owner.Id, player02.Id);

            Assert.IsFalse(game.Board[1, 0].Empty);
            Assert.AreEqual(game.Board[1, 0].Card.Id, 6.ToGuid());
            Assert.AreEqual(game.Board[1, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[1, 1].Empty);
            Assert.AreEqual(game.Board[1, 1].Card.Id, 9.ToGuid());
            Assert.AreEqual(game.Board[1, 1].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[1, 2].Empty);
            Assert.AreEqual(game.Board[1, 2].Card.Id, 2.ToGuid());
            Assert.AreEqual(game.Board[1, 2].Owner.Id, player02.Id);

            Assert.IsFalse(game.Board[2, 0].Empty);
            Assert.AreEqual(game.Board[2, 0].Card.Id, 1.ToGuid());
            Assert.AreEqual(game.Board[2, 0].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[2, 1].Empty);
            Assert.AreEqual(game.Board[2, 1].Card.Id, 3.ToGuid());
            Assert.AreEqual(game.Board[2, 1].Owner.Id, player02.Id);
            Assert.IsFalse(game.Board[2, 2].Empty);
            Assert.AreEqual(game.Board[2, 2].Card.Id, 8.ToGuid());
            Assert.AreEqual(game.Board[2, 2].Owner.Id, player02.Id);

            Assert.AreEqual(1, game.Scoreboard[player01.Id]);
            Assert.AreEqual(9, game.Scoreboard[player02.Id]);

            Assert.IsTrue(game.Finished);
        }
示例#7
0
        public void AllHaveTheCorrectNumberOfCards()
        {
            Assert.IsTrue(new List <Player>
            {
                new Player
                {
                    Cards = new List <Card>
                    {
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid())
                    }
                },
                new Player
                {
                    Cards = new List <Card>
                    {
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid())
                    }
                }
            }.AllHaveTheCorrectNumberOfCards(3, 3));


            Assert.IsFalse(new List <Player>
            {
                new Player
                {
                    Cards = new List <Card>
                    {
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid())
                    }
                },
                new Player
                {
                    Cards = new List <Card>
                    {
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid())
                    }
                }
            }.AllHaveTheCorrectNumberOfCards(3, 3));

            Assert.IsFalse(new List <Player>
            {
                new Player
                {
                    Cards = new List <Card>
                    {
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid())
                    }
                },
                new Player
                {
                    Cards = new List <Card>
                    {
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid()),
                        CardBuilder.Build(Guid.NewGuid())
                    }
                }
            }.AllHaveTheCorrectNumberOfCards(3, 3));
        }