public void GameFieldHavingCellsWithNumbersIsNotReordered()
        {
            var strategy = new ReorderBalloonsStrategyFly();
            var field = new GameField(2, 2);
            field[0, 0] = new BalloonOne();
            field[0, 1] = new BalloonTwo();
            field[1, 0] = new BalloonThree();
            field[1, 1] = new BalloonFour();

            strategy.ReorderBalloons(field);
            var isChanged = false;
            int nextSymbol = 0;

            for (int i = 0; i < field.Rows; i++)
            {
                for (int j = 0; j < field.Columns; j++)
                {
                    nextSymbol++;
                    if (field[i, j].Symbol != nextSymbol.ToString())
                    {
                        isChanged = true;
                    }
                }
            }

            Assert.IsFalse(isChanged);
        }
        public void GameFieldCreatedWith4RowsShouldHave4Rows()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            var actualRows = field.Rows;

            Assert.AreEqual(4, actualRows);
        }
        public void FilledGameFieldPositionShouldReturnBalloon()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            field[1, 1] = new BalloonOne();
            var balloon = field[1, 1];

            Assert.IsNotNull(balloon);
        }
        public void FillMethodShouldFillGmaeFieldWithBalloons()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);
            var filler = new Filler(new BalloonsFactory());
            field.Filler = filler;

            field.Fill();
            var balloon = field[1, 1];

            Assert.IsInstanceOfType(balloon, typeof(Balloon));
        }
 public void PopBallonsCommandThrowWithNegativeInput()
 {
     Setup();
     var originalField = new GameField(2, 2);
     originalField[0, 0] = new BalloonOne();
     originalField[0, 1] = new BalloonTwo();
     originalField[1, 0] = new BalloonThree();
     originalField[1, 1] = new BalloonFour();
     var popC = new PopBalloonsCommand(this.balloonsFactory, this.field, -2, -2);
     popC.Execute();
 }
        public void TwoDimensionalGameFieldWithFirstCellHavingSymbolDotIsMovedAtBottom()
        {
            var strategy = new ReorderBalloonsStrategyFly();
            var field = new GameField(2, 2);
            field[0, 0] = new BalloonPoped();
            field[0, 1] = new BalloonTwo();
            field[1, 0] = new BalloonThree();
            field[1, 1] = new BalloonFour();

            strategy.ReorderBalloons(field);

            Assert.IsInstanceOfType(field[1, 0], typeof(BalloonPoped));
        }
        public void TwoDimensionalGameFieldWithThirdCellHavingSymbolDotIsMovedAtTop()
        {
            var strategy = new ReorderBalloonsStrategyDefault();
            var field = new GameField(2, 2);
            field[0, 0] = new BalloonOne();
            field[0, 1] = new BalloonTwo();
            field[1, 0] = new BalloonPoped();
            field[1, 1] = new BalloonFour();

            strategy.ReorderBalloons(field);

            Assert.IsInstanceOfType(field[0, 0], typeof(BalloonPoped));
        }
        public void PopBallonsCommandShouldWorkProperlyWithValidInput()
        {
            Setup();
            var originalField = new GameField(2, 2);
            originalField[0, 0] = new BalloonOne();
            originalField[0, 1] = new BalloonTwo();
            originalField[1, 0] = new BalloonThree();
            originalField[1, 1] = new BalloonFour();
            var popC = new PopBalloonsCommand(this.balloonsFactory, this.field, 1, 1);
            popC.Execute();

            Assert.AreNotEqual(field, originalField);
        }
        public void RenderGameFieldWhenPassedFieldHavingNonNullCellsShouldWriteOnConsole()
        {
            var mockConsole = new Mock<IConsoleWriter>();
            var console = mockConsole.Object;

            var renderer = new ConsoleRenderer(console);
            var field = new GameField(2, 2);
            var filler = new Filler(new BalloonsFactory());
            field.Filler = filler;
            field.Fill();

            renderer.RenderGameField(field);

            mockConsole.Verify(c => c.Write(It.IsAny<string>()), Times.AtLeastOnce);
        }
        public void GettingNegativeRowFromGameFieldShouldThrowException()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            var expectedBalloon = field[-1, FieldValidColumns];
        }
        public void RenderGameFieldWhenPassedFieldHavingNullCellShouldThrowException()
        {
            var renderer = new ConsoleRenderer();
            var field = new GameField(2, 2);

            renderer.RenderGameField(field);
        }
        public void GameFieldFillerShouldNotBeNullWhenPassed()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);
            var filler = new Filler(new BalloonsFactory());

            field.Filler = filler;
            var actualFiller = field.Filler;

            Assert.IsNotNull(actualFiller);
        }
        public void SettingBallonOnWrongRowAndColumnShouldThrowException()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            field[-1, -1] = new BalloonOne();
        }
 public void GameFieldCreatedWithNegativeCountColumnsShouldThrowException()
 {
     var field = new GameField(FieldValidRows, -5);
 }
        public void GettingRowBiggerThanRowsCountFromGameFieldShouldThrowException()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            var expectedBalloon = field[5, FieldValidColumns];
        }
        public void GameFieldShouldThrowWhenExceptionWhenNullFillerPassed()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            field.Filler = null;
        }
        public void NotFilledGameFieldShouldReturnNullBalloon()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            var balloon = field[1, 1];

            Assert.IsNull(balloon);
        }
        public void SettingOnRowBiggerThanRowsCountFromGameFieldShouldThrowException()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            field[5, FieldValidColumns] = new BalloonOne();
        }
        public void SettingOnNegativeRowFromGameFieldShouldThrowException()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            field[-2, FieldValidColumns] = new BalloonOne();
        }
        public void SettingNullBalloonToGameFieldShouldThrowException()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            field[1, 1] = null;
        }
 public void GameFieldCreatedWithNegativeCountRowsShouldThrowException()
 {
     var field = new GameField(-2, FieldValidColumns);
 }
        public void GameFieldFillerWhenNotPassedShouldBeNull()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);

            Assert.IsNull(field.Filler);
        }
        public void SaveFieldMethodShouldReturnFieldMemoryObject()
        {
            var field = new GameField(FieldValidRows, FieldValidColumns);
            var saveField = field.SaveField();

            Assert.IsInstanceOfType(saveField, typeof(FieldMemory));
        }