Refactoring of storage + rename detection

PathReduxTests/HashCodes/ControllableHashCode.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using YellowCounter.FileSystemState.HashCodes;
+
+namespace PathReduxTests.HashCodes
+{
+    public class ControllableHashCode : IHashCode
+    {
+        private StringBuilder stringBuilder = new StringBuilder();
+        private bool dead = false;
+
+        public void Add(char value)
+        {
+            stringBuilder.Append(value);
+        }
+
+        public int ToHashCode()
+        {
+            deadCheck();
+
+            string arg = stringBuilder.ToString();
+
+            // Use comma as delimiter between desired hash number and remaining text.
+            int commaPos = arg.IndexOf(',');
+
+            if(commaPos == -1)
+                throw new Exception($"{nameof(ControllableHashCode)} requires , in each string");
+
+            if(int.TryParse(arg.Substring(0, commaPos), out int result))
+                return result;
+
+            throw new Exception("Text before , must be an integer");
+        }
+
+        private void deadCheck()
+        {
+            if(dead)
+                throw new Exception("Cannot call ToHashCode() twice");
+
+            dead = true;
+        }
+    }
+}

PathReduxTests/HashCodes/DeterministicHashCode.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using YellowCounter.FileSystemState.HashCodes;
+
+namespace PathReduxTests.HashCodes
+{
+    // Want a deterministic hash function so our tests are repeatable.
+    // https://andrewlock.net/why-is-string-gethashcode-different-each-time-i-run-my-program-in-net-core/
+
+    public class DeterministicHashCode : IHashCode
+    {
+        private bool dead = false;
+        private bool odd = false;
+        private int hash1 = 352654597; //(5381 << 16) + 5381;
+        private int hash2 = 352654597;
+
+        public void Add(char value)
+        {
+            unchecked
+            {
+                if(!odd)
+                {
+                    hash1 = ((hash1 << 5) + hash1) ^ value;
+
+                }
+                else
+                {
+                    hash2 = ((hash2 << 5) + hash2) ^ value;
+
+                }
+            }
+
+            odd = !odd;
+        }
+
+        public int ToHashCode()
+        {
+            deadCheck();
+
+            unchecked
+            {
+                return hash1 + (hash2 * 1566083941);
+            }
+        }
+
+        private void deadCheck()
+        {
+            if(dead)
+                throw new Exception("Cannot call ToHashCode() twice");
+
+            dead = true;
+        }
+    }
+}

PathReduxTests/PathRedux/CharBufferTests.cs

@@ -0,0 +1,109 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using YellowCounter.FileSystemState.PathRedux;
+using Shouldly;
+
+namespace YellowCounter.FileSystemState.Tests.PathRedux
+{
+    [TestClass]
+    public class CharBufferTests
+    {
+        [TestMethod]
+        public void CharBuffer1()
+        {
+            var charBuffer = new CharBuffer(100);
+
+            int idx1 = charBuffer.Store("Hello");
+            int idx2 = charBuffer.Store("World");
+
+            charBuffer.Retrieve(idx1).ToString().ShouldBe("Hello");
+            charBuffer.Retrieve(idx2).ToString().ShouldBe("World");
+        }
+
+        [TestMethod]
+        public void CharBuffer2()
+        {
+            var charBuffer = new CharBuffer(100);
+
+            int idx1 = charBuffer.Store("Hello");
+            int idx2 = charBuffer.Store("World");
+
+            charBuffer.Retrieve(new[] { idx1, idx2 }).ToString().ShouldBe("HelloWorld");
+        }
+
+        [TestMethod]
+        public void CharBufferRealloc()
+        {
+            var charBuffer = new CharBuffer(13);
+
+            int idx1 = charBuffer.Store("Hello");
+            int idx2 = charBuffer.Store("World");
+
+            var helloSpan = charBuffer.Retrieve(idx1);
+
+            var worldSpan = charBuffer.Retrieve(idx2);
+
+            charBuffer.Resize(25);
+
+            // These spans are still pointing at the old buffer - how does it avoid
+            // freeing up the memory?
+            helloSpan.ToString().ShouldBe("Hello");
+            worldSpan.ToString().ShouldBe("World");
+
+            var hello2Span = charBuffer.Retrieve(idx1);
+            var world2Span = charBuffer.Retrieve(idx2);
+
+            hello2Span.ToString().ShouldBe("Hello");
+            world2Span.ToString().ShouldBe("World");
+        }
+
+        [TestMethod]
+        public void CharBufferEnumerate()
+        {
+            var charBuffer = new CharBuffer(100);
+
+            int idx1 = charBuffer.Store("Hello");
+            int idx2 = charBuffer.Store("World");
+
+            var results = new List<string>();
+            foreach(var item in charBuffer)
+            {
+                results.Add(item.Span.ToString());
+            }
+
+            results.ShouldBe(new[] { "Hello", "World" });
+        }
+
+        [TestMethod]
+        public void CharBufferMaxCapacity()
+        {
+            // To store the text "Hello" without expanding, we need 5 chars for Hello,
+            // 1 char for the null terminator of Hello, and 1 char for the null terminator
+            // of the overall buffer.
+            var charBuffer = new CharBuffer(7);
+
+            int idx1 = charBuffer.Store("Hello");
+            idx1.ShouldNotBe(-1);
+            charBuffer.Capacity.ShouldBe(7);
+
+            charBuffer.Retrieve(idx1).ToString().ShouldBe("Hello");
+
+            int c = 0;
+            foreach(var itm in charBuffer)
+            {
+                if(c == 0)
+                {
+                    itm.Pos.ShouldBe(0);
+                    itm.Span.ToString().ShouldBe("Hello");
+                }
+                else
+                {
+                    throw new Exception("Should only have one item");
+                }
+                c++;
+            }
+        }
+    }
+}

PathReduxTests/PathRedux/HashBucketTests.cs

@@ -0,0 +1,106 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using YellowCounter.FileSystemState.PathRedux;
+using Shouldly;
+
+namespace PathReduxTests.PathRedux
+{
+    [TestClass]
+    public class HashBucketTests
+    {
+        [TestMethod]
+        public void HashBucketStoreRetrieve()
+        {
+            var m = new HashBucket(2, 2);
+
+            m.Store(0, 123456).ShouldBe(true);
+            m.Store(0, 765432).ShouldBe(true);
+
+            var result = m.Retrieve(0);
+
+            result.ToArray().ShouldBe(new[] { 123456, 765432 });
+        }
+
+        [TestMethod]
+        public void HashBucketStoreFlowpast()
+        {
+            var m = new HashBucket(2, 2);
+
+            m.Store(1, 123456).ShouldBe(true);
+            m.Store(1, 765432).ShouldBe(true);
+
+            var result = m.Retrieve(1);
+
+            result.ToArray().ShouldBe(new[] { 123456, 765432 });
+        }
+
+        [TestMethod]
+        public void HashBucketStoreZero()
+        {
+            var m = new HashBucket(2, 2);
+
+            // It can store a zero
+            m.Store(0, 0).ShouldBe(true);
+
+            var result = m.Retrieve(0);
+            result.ToArray().ShouldBe(new[] { 0 });
+        }
+
+        [TestMethod]
+        public void HashBucketChainLimit()
+        {
+            var m = new HashBucket(8, 2);
+
+            m.Store(0, 100).ShouldBe(true);
+            m.Store(0, 200).ShouldBe(true);
+            m.Store(0, 300).ShouldBe(false);
+
+            var result = m.Retrieve(0);
+
+            result.ToArray().ShouldBe(new[] { 100, 200 });
+        }
+
+        [TestMethod]
+        public void HashBucketOverlap()
+        {
+            var m = new HashBucket(8, 8);
+
+            // The values are going to overlap.
+            m.Store(0, 100).ShouldBe(true);
+            m.Store(1, 200).ShouldBe(true);
+            m.Store(0, 300).ShouldBe(true);
+
+            var result = m.Retrieve(0);
+
+            result.ToArray().ShouldBe(new[] { 100, 200, 300 });
+        }
+
+        [TestMethod]
+        public void HashBucketOverlapLimited()
+        {
+            var m = new HashBucket(8, 2);
+
+            // If we set the max chain to a lower value then the overlap
+            // won't occur.
+            m.Store(0, 100).ShouldBe(true);
+            m.Store(1, 200).ShouldBe(true);
+            m.Store(0, 300).ShouldBe(false);
+
+            m.Retrieve(0).ToArray().ShouldBe(new[] { 100, 200 });
+            m.Retrieve(1).ToArray().ShouldBe(new[] { 200 });
+        }
+
+        [TestMethod]
+        public void HashBucketWraparound()
+        {
+            var m = new HashBucket(4, 2);
+
+            m.Store(3, 100).ShouldBe(true);
+            m.Store(3, 200).ShouldBe(true);
+
+            m.Retrieve(3).ToArray().ShouldBe(new[] { 100, 200 });
+        }
+    }
+}