Example #1
0
        public void Active_ActivateCellManyTimes_CellShouldBeStillActive()
        {
            var grid = new Grid(10);

            grid.Active(2, 5);
            grid.Active(2, 5);
            var result = grid.GetCellState(2, 5);

            result.Should().Be(true);
        }
Example #2
0
        public void CountActiveCells_ActiveCellsExists_MethodShouldReturnPositiveNumber()
        {
            var grid = new Grid(10);

            grid.Active(3, 2);
            grid.Active(4, 2);
            grid.Active(4, 3);
            var result = grid.CountActiveCells();

            result.Should().Be(3);
        }
        public void GetNextGeneration_TwoActiveCellsNextToEachOtherExists_NewGenerationShouldBeEmpty(int x, int y)
        {
            var grid = new Grid(10);

            grid.Active(5, 5);
            grid.Active(x, y);
            var evolution = new Evolution();

            var newGeneration = evolution.GetNextGeneration(grid);

            newGeneration.CountActiveCells().Should().Be(0);
        }
        public void GetNextGeneration_TwoPairsOfSeparatedCellsExists_NewGenerationShouldBeEmpty()
        {
            var grid = new Grid(10);

            grid.Active(3, 3);
            grid.Active(3, 4);

            grid.Active(7, 6);
            grid.Active(7, 7);
            var evolution = new Evolution();

            var newGeneration = evolution.GetNextGeneration(grid);

            newGeneration.CountActiveCells().Should().Be(0);
        }
        public void GetNextGeneration_ThreeCellsAreDiagonallyAdjacentToEachOther_NewGenerationShouldBeReturned()
        {
            var grid = new Grid(10);

            grid.Active(3, 3);
            grid.Active(4, 4);
            grid.Active(5, 3);
            var evolution = new Evolution();

            var newGeneration = evolution.GetNextGeneration(grid);

            newGeneration.CountActiveCells().Should().Be(2);
            newGeneration.GetCellState(4, 3).Should().Be(true);
            newGeneration.GetCellState(4, 4).Should().Be(true);
        }
Example #6
0
        public void Kill_AllCellsAreActive_AllCellsShouldBeKilled()
        {
            int n    = 10;
            var grid = new Grid(n);

            for (int i = 0; i < grid.Size; ++i)
            {
                for (int j = 0; j < grid.Size; ++j)
                {
                    grid.Active(i, j);
                }
            }

            for (int i = 0; i < grid.Size; ++i)
            {
                for (int j = 0; j < grid.Size; ++j)
                {
                    grid.Kill(i, j);
                }
            }

            var activeCount = grid.CountActiveCells();

            activeCount.Should().Be(0);
        }
        public void GetNextGeneration_ThreeCellsInRowExists_NewGenerationShouldBeReturned()
        {
            var grid = new Grid(10);

            grid.Active(3, 4);
            grid.Active(3, 5);
            grid.Active(3, 6);
            var evolution = new Evolution();

            var newGeneration = evolution.GetNextGeneration(grid);

            newGeneration.CountActiveCells().Should().Be(3);
            newGeneration.GetCellState(2, 5).Should().Be(true);
            newGeneration.GetCellState(3, 5).Should().Be(true);
            newGeneration.GetCellState(4, 5).Should().Be(true);
        }
Example #8
0
        public void Active_YIndexOfCellIsOutOfRange_MethodThrowException()
        {
            var grid      = new Grid(10);
            var exception = Assert.Throws <IndexOutOfRangeException>(()
                                                                     => grid.Active(5, 20));

            Assert.IsType <IndexOutOfRangeException>(exception);
        }
Example #9
0
        public void GetCellState_CellIsActive_StateIsTrue()
        {
            var grid = new Grid(10);

            grid.Active(4, 5);
            var result = grid.GetCellState(4, 5);

            result.Should().Be(true);
        }
Example #10
0
        public void Kill_CellIsActive_ActiveCellShouldBeKilled()
        {
            var grid = new Grid(10);

            grid.Active(3, 5);
            grid.Kill(3, 5);
            var result = grid.GetCellState(3, 5);

            result.Should().Be(false);
        }
Example #11
0
        public void GetNextGeneration_OneActiveCellExists_NewGenerationShouldBeEmpty()
        {
            var grid = new Grid(10);

            grid.Active(3, 4);
            var evolution = new Evolution();

            var newGeneration = evolution.GetNextGeneration(grid);

            newGeneration.CountActiveCells().Should().Be(0);
        }
Example #12
0
        public Grid GetNextGeneration(Grid currentGrid)
        {
            var newGrid = new Grid(currentGrid.Size);

            for (int l = 1; l < currentGrid.Size - 1; l++)
            {
                for (int m = 1; m < currentGrid.Size - 1; m++)
                {
                    int activeNeighbours = GetNumberOfActiveNeighbours(currentGrid, l, m);

                    if ((currentGrid.GetCellState(l, m) == true) && (activeNeighbours < 2))
                    {
                        newGrid.Kill(l, m);
                    }

                    else if ((currentGrid.GetCellState(l, m) == true) && (activeNeighbours > 3))
                    {
                        newGrid.Kill(l, m);
                    }

                    else if ((currentGrid.GetCellState(l, m) == false) && (activeNeighbours == 3))
                    {
                        newGrid.Active(l, m);
                    }

                    else
                    {
                        if (currentGrid.GetCellState(l, m))
                        {
                            newGrid.Active(l, m);
                        }
                        else
                        {
                            newGrid.Kill(l, m);
                        }
                    }
                }
            }
            return(newGrid);
        }
Example #13
0
        public void GetNextGeneration_GliderTest_After10InterationsThereShouldBe5ActiveCells()
        {
            var grid = new Grid(10);

            grid.Active(2, 3);
            grid.Active(3, 4);
            grid.Active(4, 2);
            grid.Active(4, 3);
            grid.Active(4, 4);

            var evolution = new Evolution();

            for (int i = 0; i < 10; ++i)
            {
                grid = evolution.GetNextGeneration(grid);
            }
            grid.CountActiveCells().Should().Be(5);
            grid.GetCellState(5, 6).Should().Be(true);
            grid.GetCellState(6, 4).Should().Be(true);
            grid.GetCellState(6, 6).Should().Be(true);
            grid.GetCellState(7, 5).Should().Be(true);
            grid.GetCellState(7, 6).Should().Be(true);
        }
Example #14
0
    private static void SetupWithSampleData()
    {
        //glider
        _grid.Active(2, 3);
        _grid.Active(3, 4);
        _grid.Active(4, 2);
        _grid.Active(4, 3);
        _grid.Active(4, 4);

        //some random cells
        _grid.Active(6, 8);
        _grid.Active(6, 9);
        _grid.Active(7, 9);
        _grid.Active(10, 8);
        _grid.Active(10, 9);
        _grid.Active(11, 7);
        _grid.Active(11, 13);
        _grid.Active(12, 10);
        _grid.Active(13, 9);
    }