Initial commit

2026-05-07 03:23:56 +00:00
commit 5e8575f42a
42 changed files with 2330 additions and 0 deletions
@@ -0,0 +1,51 @@
+using System;
+using System.Linq;
+using GameOfLife;
+using GameOfLife.Entities;
+using GameOfLife.IO;
+using NUnit.Framework;
+
+namespace GameOfLifeTests
+{
+    public class ApgcodeDecoderTests
+    {
+        [Test]
+        public void ConvertToUintTest()
+        {
+            Assert.AreEqual(0, ApgcodeDecoder.ConvertToUint('0'));
+            Assert.AreEqual(9, ApgcodeDecoder.ConvertToUint('9'));
+            Assert.AreEqual(10, ApgcodeDecoder.ConvertToUint('a'));
+            Assert.AreEqual(11, ApgcodeDecoder.ConvertToUint('b'));
+        }
+
+        [Test]
+        public void ExpandAbbreviationsTests()
+        {
+            Assert.AreEqual("00", ApgcodeDecoder.ExpandAbbreviations("w"));
+            Assert.AreEqual("000", ApgcodeDecoder.ExpandAbbreviations("x"));
+            Assert.AreEqual("00000", ApgcodeDecoder.ExpandAbbreviations("wx"));
+            Assert.AreEqual("0000", ApgcodeDecoder.ExpandAbbreviations("y0"));
+            Assert.AreEqual("00000", ApgcodeDecoder.ExpandAbbreviations("y1"));
+            Assert.AreEqual(new string('0', 39), ApgcodeDecoder.ExpandAbbreviations("yz"));
+        }
+
+        [Test]
+        public void Headerless_DecodeTests()
+        {
+            var apgcodeDecoder = new ApgcodeDecoder("0ca178b96z69d1d96");
+
+            foreach (var line in apgcodeDecoder.Pattern.ToGrid())
+            {
+                Console.WriteLine(line);
+            }
+        }
+        [Test]
+        public void Xs_DecodeTests()
+        {
+            var apgcodeDecoder = new ApgcodeDecoder("xs4_33");
+            Assert.AreEqual(4, apgcodeDecoder.Pattern.Count);
+            Assert.AreEqual(PatternType.StillLife, apgcodeDecoder.Metadata.Type);
+            Assert.AreEqual("4", apgcodeDecoder.Metadata.Comments.First());
+        }
+    }
+}
@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using GameOfLife;
+using GameOfLife.Entities;
+
+namespace GameOfLifeTests
+{
+    public class CellTests
+    {
+        private readonly PatternTestData _patternTestData = new PatternTestData();
+
+        [SetUp]
+        public void Setup()
+        {
+        }
+
+        [Test]
+        public void Equals_True_Test()
+        {
+            Assert.True(Util.Equals(_patternTestData.CornerPattern, _patternTestData.CornerCopy));
+        }
+
+        [Test]
+        public void Equals_False_Test()
+        {
+            Assert.False(Util.Equals(_patternTestData.CornerPattern, _patternTestData.SquarePattern));
+        }
+
+        [Test]
+        public void Rotate_Test()
+        {
+            var rotate = _patternTestData.CornerPattern.Rotate();
+            Console.WriteLine(_patternTestData.CornerPattern);
+            Console.WriteLine(rotate);
+            Assert.Contains(-_patternTestData.CornerPattern[0].Item2, rotate.Select(r => r.Item1).ToList());
+            Assert.Contains(_patternTestData.CornerPattern[0].Item1, rotate.Select(r => r.Item2).ToList());
+            Assert.Contains(-_patternTestData.CornerPattern[0].Item2, rotate.Select(r => r.Item1).ToList());
+            Assert.Contains(-_patternTestData.CornerPattern[0].Item2, rotate.Select(r => r.Item1).ToList());
+        }
+
+        [Test]
+        public void Rotate_Circle_Test()
+        {
+            var rotate = _patternTestData.CornerPattern.Rotate(4);
+            Assert.AreEqual(_patternTestData.CornerPattern, rotate);
+       }
+
+        [Test]
+        public void GetFirstPoint_Test()
+        {
+            var fp = _patternTestData.CornerPattern.GetFirstRowFirstCell();
+            Assert.True(fp.Item1 == 2);
+            Assert.True(fp.Item2 == 1);
+        }
+
+        [Test]
+        public void Subtract_Test()
+        {
+            var fp = _patternTestData.CornerPattern[0] - new Cell(1,2);
+            Assert.True(fp.Item1 == 1);
+            Assert.True(fp.Item2 == -1);
+        }
+
+        [Test]
+        public void Hash_Test()
+        {
+            var h1 = new Cell(1, 2).GetHashCode();
+            var h2 = new Cell(2, 3).GetHashCode();
+            var h3 = new Cell(1, 2).GetHashCode();
+
+            Assert.AreEqual(h1, h3);
+            Assert.AreNotEqual(h1, h2);
+        }
+    }
+
+    public class PatternTests
+    {
+        [Test]
+        public void GetHashCode_Tests()
+        {
+            var p1 = new Pattern(new List<Cell>() { new Cell(1, 2) }).GetHashCode();
+            var p2 = new Pattern(new List<Cell>() { new Cell(2, 3) }).GetHashCode();
+            var p3 = new Pattern(new List<Cell>() { new Cell(1, 2) }).GetHashCode();
+            var p4 = new Pattern(new List<Cell>() { new Cell(1, 2), new Cell(2,3) }).GetHashCode();
+            var p5 = new Pattern(new List<Cell>() { new Cell(1, 2), new Cell(2,3) }).GetHashCode();
+            var p6 = new Pattern(new List<Cell>() { new Cell(2, 3), new Cell(1, 2) }).GetHashCode();
+
+            Assert.AreEqual(p1, p3);
+            Assert.AreNotEqual(p1, p2);
+            Assert.AreNotEqual(p1, p4);
+            Assert.AreEqual(p4, p5);
+            Assert.AreEqual(p5, p6);
+        }//
+    }
+}
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net452</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="NUnit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\GameOfLife\GameOfLife.csproj" />
+  </ItemGroup>
+
+</Project>
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GameOfLife;
+using GameOfLife.Entities;
+using NUnit.Framework;
+
+namespace GameOfLifeTests
+{
+    public class PatternLibraryTests
+    {
+        [Test]
+        public void PrintLibrary()
+        {
+            var patternLibrary = new PatternLibrary();
+            //Assert.AreEqual(15, patternLibrary.PatternProjections.Count);
+            foreach (var p in patternLibrary.PatternProjections)
+            {
+                Console.WriteLine($"{p.Item1.Name}, {p.Item1.Type} {string.Join(" ", p.Item1.Comments)}");
+                foreach (var v in p.Item2)
+                {
+                    Console.WriteLine(v.First());
+                    PatternTestData.ConsoleWriteGrid(v.Offset(new Cell(2,0)));
+                    Console.WriteLine();
+                }
+                Console.WriteLine("* * * * ");
+            }
+        }
+
+        [Test]
+        public void MatchLibraryPatterns_SelfTest()
+        {
+            var patternLibrary = new PatternLibrary();
+
+            foreach (var pattern in patternLibrary.PatternProjections)
+            {
+                var matches = patternLibrary.MatchLibraryPatterns(pattern.Item2[0]);
+                // pattern metadata is the same
+                Assert.AreEqual(matches.Count(m => m.Item1 == pattern.Item1), 1);
+            }
+        }
+
+        [Test]
+        public void MultTest()
+        {
+
+            var singleDigits = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }.Select(i=> i.ToString()[0]);
+
+            string ReplaceAtIndex(string s, char c, int i)
+            {
+                var array = s.ToCharArray();
+                array[i] = c;
+                return new string(array);
+            }
+
+            IEnumerable<int> EnumUnderscoreWithNumbers(string s)
+            {
+                var currIndex = s.IndexOf('_');
+                if (currIndex == -1) return new[] { int.Parse(s) };
+                var skip = currIndex == 0 ? 1 : 0;
+                return singleDigits.Skip(skip).SelectMany<char, int>(d => EnumUnderscoreWithNumbers(ReplaceAtIndex(s, d, currIndex)));
+            }
+
+            int PartialProduct(int m1, int m2, int digit)
+            {
+                var m2s = m2.ToString();
+                var c = int.Parse(m2s[m2s.Length - digit].ToString());
+                return m1 * c * (int)Math.Pow(10, digit - 1);
+            }
+            Console.WriteLine(PartialProduct(131, 73, 2));
+
+
+            string multplicand = "_3_";
+            string multiplier = "__";
+            string partialProd1 = "3__9";
+            string partialProd2 = "___";
+            string product = "9__9";
+
+            var r =
+                from mcnd in EnumUnderscoreWithNumbers(multplicand)
+                from mplr in EnumUnderscoreWithNumbers(multiplier)
+                from prdc in EnumUnderscoreWithNumbers(product)
+                from prt in EnumUnderscoreWithNumbers(partialProd1)
+                where PartialProduct(mcnd, mplr, 1) == prt && mcnd * mplr == prdc
+                select new { mcnd, mplr, prdc };
+
+            foreach (var result in r)
+            {
+                Console.WriteLine($"{result.mcnd} * {result.mplr} = {result.prdc}");
+            }
+
+        }
+    }
+}
@@ -0,0 +1,62 @@
+using System;
+using GameOfLife;
+using GameOfLife.Entities;
+using GameOfLife.IO;
+
+namespace GameOfLifeTests
+{
+    public class PatternTestData
+    {
+        public readonly string C0Text =  "....." + Environment.NewLine +
+                                         "..o.." + Environment.NewLine +
+                                         "..oo." + Environment.NewLine +
+                                         ".....";
+
+        public Pattern CornerPattern;
+        public Pattern CornerCopy;
+        
+        public readonly string C2SquareText = "....." + Environment.NewLine +
+                                         ".oo.." + Environment.NewLine +
+                                         ".oo.." + Environment.NewLine +
+                                         ".....";
+
+        public Pattern SquarePattern;
+
+        public readonly string Glider = "...o." + Environment.NewLine +
+                                        ".o.o." + Environment.NewLine +
+                                        "..oo." + Environment.NewLine +
+                                        ".....";
+
+        public Pattern GliderPattern;
+
+        public readonly string GliderApgcode = "xq4_153";
+
+        public Pattern GliderApgPattern;
+
+        public PatternTestData()
+        {
+            CornerPattern = Pattern.Extract(C0Text);
+            CornerCopy = Pattern.Extract(C0Text);
+            SquarePattern = Pattern.Extract(C2SquareText);
+            GliderPattern = Pattern.Extract(Glider);
+            var apgcodeDecoder = new ApgcodeDecoder(GliderApgcode);
+            GliderApgPattern = apgcodeDecoder.Pattern;
+        }
+
+        public static void ConsoleWrite(Pattern pattern)
+        {
+            foreach (var cell in pattern)
+            {
+                Console.WriteLine(cell);
+            }
+        }
+
+        public static void ConsoleWriteGrid(Pattern pattern)
+        {
+            var enumerable = pattern.ToGrid();
+
+            foreach (var e in enumerable)
+                Console.WriteLine(e);
+        }
+    }
+}
@@ -0,0 +1,141 @@
+using System;
+using System.Linq;
+using GameOfLife;
+using GameOfLife.Entities;
+using NUnit.Framework;
+
+namespace GameOfLifeTests
+{
+    public class VariationsTests
+    {
+        private readonly PatternTestData _patternTestData = new PatternTestData();
+
+        [SetUp]
+        public void Setup()
+        {
+        }
+
+        [Test]
+        public void CornerTest()
+        {
+            var pattern = new Projections(_patternTestData.CornerPattern);
+            Assert.AreEqual(4, pattern.Count);
+
+            var offsetCell = new Cell(2,2);
+            foreach (var variation in pattern)
+            {
+                PatternTestData.ConsoleWrite(variation);
+                PatternTestData.ConsoleWriteGrid(variation.Offset(offsetCell));
+                Console.WriteLine();
+                PatternTestData.ConsoleWriteGrid(variation.GetBoundary.Offset(offsetCell));
+                Console.WriteLine("-----");
+                Console.WriteLine();
+            }
+        }
+
+        [Test]
+        public void SquareTest()
+        {
+            var pattern = new Pattern(_patternTestData.SquarePattern);
+            PatternTestData.ConsoleWrite(pattern);
+            Assert.AreEqual(4, pattern.Count);
+
+            foreach (var variation in new Projections(pattern))
+            {
+                PatternTestData.ConsoleWriteGrid(variation);
+                
+                Console.WriteLine();
+            }
+        }
+
+        [Test]
+        public void GliderTest()
+        {
+            PatternTestData.ConsoleWrite(_patternTestData.GliderPattern);
+            var variations = new Projections(_patternTestData.GliderPattern);
+
+            foreach (var variation in variations)
+            {
+                PatternTestData.ConsoleWriteGrid(variation.Offset(new Cell(2,0)));
+                
+                Console.WriteLine();
+            }
+        }
+
+        [Test]
+        public void FindPattern_Corner_Tests()
+        {
+            var gol = new LifeArray(_patternTestData.CornerPattern);
+
+            var results = gol.LivingCells.ToPattern().FindPattern(_patternTestData.CornerPattern).ToArray();
+            Assert.AreEqual(1, results.Length);
+        }
+
+        [Test]
+        public void FindPattern_Corner_Square_Tests()
+        {
+            var gol = new LifeArray(_patternTestData.CornerPattern);
+
+            var results = gol.LivingCells.ToPattern().FindPattern(_patternTestData.SquarePattern).ToArray();
+            Assert.AreEqual(0, results.Length);
+        }
+
+        [Test]
+        public void FindPattern_Corner_Rotated_Tests()
+        {
+            var gol = new LifeHashSet(_patternTestData.CornerPattern.Rotate(2).Normalize());
+
+            var results = gol.LivingCells.ToPattern().FindPattern(_patternTestData.CornerPattern).ToArray();
+            Assert.AreEqual(1, results.Length);
+        }
+
+        [Test]
+        public void FindPattern_TwoCorners_Tests()
+        {
+            var offsetCorner = _patternTestData.CornerPattern.Offset(new Cell(3,0));
+            var pattern = _patternTestData.CornerPattern + offsetCorner;
+            //PatternTestData.ConsoleWriteGrid(pattern, 10);
+
+            var gol = new LifeHashSet(pattern);
+
+            var results = gol.LivingCellPattern.FindPattern(_patternTestData.CornerPattern).ToArray();
+            Assert.AreEqual(2, results.Length);
+        }
+
+        [Test]
+        public void FindPattern_Overlapping_Empty_Space_Tests()
+        {
+            var offsetCorner = _patternTestData.CornerPattern.Offset(new Cell(2, 0));
+            var pattern = _patternTestData.CornerPattern + offsetCorner;
+            
+            var gol = new LifeHashSet(pattern);
+
+            var results = gol.LivingCells.ToPattern().FindPattern(_patternTestData.CornerPattern).ToArray();
+            Assert.AreEqual(0, results.Length);
+        }
+
+        [Test]
+        public void FindPattern_Corner_and_Square_Tests()
+        {
+            var offsetCorner = _patternTestData.SquarePattern.Offset(new Cell(4, 0));
+            var pattern = _patternTestData.CornerPattern + offsetCorner;
+            PatternTestData.ConsoleWriteGrid(pattern);
+
+            var gol = new LifeHashSet(pattern);
+
+            var cornerResults = gol.LivingCells.ToPattern().FindPattern(_patternTestData.CornerPattern).ToArray();
+            Assert.AreEqual(1, cornerResults.Length);
+
+            var squareResults = gol.LivingCells.ToPattern().FindPattern(_patternTestData.SquarePattern).ToArray();
+            Assert.AreEqual(1, squareResults.Length);
+        }
+
+        [Test]
+        public void FindOscillations_Tests()
+        {
+            var oscillations= new LifeHashSet(_patternTestData.GliderApgPattern).FindOscillation();
+            Assert.Greater(oscillations.Count(), 1);
+            Console.WriteLine(oscillations.Count());
+        }
+    }
+}