Esempio n. 1
0
        public void BlinkersFirstGenerationShouldGiveADifferentPattern()
        {
            var pattern = CreatePattern(new[]
            {
                new[] { 2, 1 },
                new[] { 2, 2 },
                new[] { 2, 3 },
            });

            var game   = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);

            AssertCollectionsNotEquivalent(result.ToList(), pattern);
        }
Esempio n. 2
0
        public void BlockShouldNotChange()
        {
            var pattern = CreatePattern(new[]
            {
                new[] { 1, 1 },
                new[] { 1, 2 },
                new[] { 2, 1 },
                new[] { 2, 2 },
            });

            var game   = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);

            AssertCollectionsEqual(result.ToList(), pattern);
        }
Esempio n. 3
0
        public void BlinkerShouldHaveAPeriodOfTwo()
        {
            var pattern = CreatePattern(new[]
            {
                new[] { 2, 1 },
                new[] { 2, 2 },
                new[] { 2, 3 },
            });

            var game   = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);

            result = game.NextGeneration(result);

            AssertCollectionsEquivalent(result.ToList(), pattern);
        }
Esempio n. 4
0
        public void DiehardShouldNotDieAfter1Generation()
        {
            var pattern = CreatePattern(new[]
            {
                new[] { 1, 7 },
                new[] { 2, 1 },
                new[] { 2, 2 },
                new[] { 3, 2 },
                new[] { 3, 6 },
                new[] { 3, 7 },
                new[] { 3, 8 },
            });

            var game   = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);

            Assert.IsTrue(result.Any());
        }
        public void BeaconsFirstGenerationShouldGiveADifferentPattern()
        {
            var pattern = CreatePattern(new[]
                                      {
                                          new[] {1, 1},
                                          new[] {1, 2},
                                          new[] {2, 1},
                                          new[] {2, 2},
                                          new[] {3, 3},
                                          new[] {3, 4},
                                          new[] {4, 3},
                                          new[] {4, 4},
                                      });

            var game = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);

            AssertCollectionsNotEquivalent(result.ToList(), pattern);
        }
        public void BeaconShouldHaveAPeriodOfTwo()
        {
            var pattern = CreatePattern(new[]
                                      {
                                          new[] {1, 1},
                                          new[] {1, 2},
                                          new[] {2, 1},
                                          new[] {2, 2},
                                          new[] {3, 3},
                                          new[] {3, 4},
                                          new[] {4, 3},
                                          new[] {4, 4},
                                      });

            var game = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);
            result = game.NextGeneration(result);

            AssertCollectionsEquivalent(result.ToList(), pattern);
        }
Esempio n. 7
0
        public void DiehardShouldDieAfter130Generations()
        {
            var pattern = CreatePattern(new[]
            {
                new[] { 1, 7 },
                new[] { 2, 1 },
                new[] { 2, 2 },
                new[] { 3, 2 },
                new[] { 3, 6 },
                new[] { 3, 7 },
                new[] { 3, 8 },
            });

            var game   = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);

            for (int i = 1; i < 130; i++)
            {
                result = game.NextGeneration(result);
            }

            Assert.IsFalse(result.Any());
        }
        public void BeehiveShouldNotChange()
        {
            var pattern = CreatePattern(new[]
                              {
                                  new[] {1, 2},
                                  new[] {1, 3},
                                  new[] {2, 1},
                                  new[] {2, 4},
                                  new[] {3, 2},
                                  new[] {3, 3},
                              });

            var game = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);

            AssertCollectionsEqual(result.ToList(), pattern);
        }
        public void DiehardShouldNotDieAfter1Generation()
        {
            var pattern = CreatePattern(new[]
                                      {
                                          new[] {1, 7},
                                          new[] {2, 1},
                                          new[] {2, 2},
                                          new[] {3, 2},
                                          new[] {3, 6},
                                          new[] {3, 7},
                                          new[] {3, 8},
                                      });

            var game = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);

            Assert.IsTrue(result.Any());
        }
Esempio n. 10
0
        public void DiehardShouldDieAfter130Generations()
        {
            var pattern = CreatePattern(new[]
                                      {
                                          new[] {1, 7},
                                          new[] {2, 1},
                                          new[] {2, 2},
                                          new[] {3, 2},
                                          new[] {3, 6},
                                          new[] {3, 7},
                                          new[] {3, 8},
                                      });

            var game = new PortableConwayGame.ConwayGame();
            var result = game.NextGeneration(pattern);
            for (int i = 1; i < 130; i++)
                result = game.NextGeneration(result);

            Assert.IsFalse(result.Any());
        }