com.wallstop-studios.unity-helpers 2.0.0-rc23 → 2.0.0-rc24

package/README.md

@@ -1,2 +1,12 @@
 # A Grab-Bag
 Various Unity Helpers. Includes many deterministic, seedable random number generators.
+
+# To Install as Unity Package
+1. Open Unity Package Manager
+2. (Optional) Enable Pre-release packages to get the latest, cutting-edge builds
+3. Open the Advanced Package Settings
+4. Add an entry for a new "Scoped Registry"
+    - Name: `NPM`
+    - URL: `https://registry.npmjs.org`
+    - Scope(s): `com.wallstop-studios.unity-helpers`
+5. Resolve the latest `com.wallstop-studios.unity-helpers`

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -10,6 +10,8 @@
     public sealed class CyclicBuffer<T> : IReadOnlyList<T>
     {
         public int Count { get; private set; }
+        public bool IsReadOnly => false;
+
         public readonly int capacity;
 
         private readonly List<T> _buffer;
@@ -88,28 +90,24 @@
             /* Simply reset state */
             Count = 0;
             _position = 0;
+            _buffer.Clear();
         }
 
-        public bool Peek(out T value)
+        public bool Contains(T item)
         {
-            const int firstIndex = 0;
-            if (InBounds(firstIndex))
-            {
-                value = _buffer[AdjustedIndexFor(firstIndex)];
-                return true;
-            }
-
-            value = default;
-            return false;
+            return _buffer.Contains(item);
         }
 
         private int AdjustedIndexFor(int index)
         {
-            if (index < _buffer.Count)
+            long longCapacity = capacity;
+            unchecked
             {
-                return index;
+                int adjustedIndex = (int)(
+                    (_position - 1L + longCapacity - (_buffer.Count - 1 - index)) % longCapacity
+                );
+                return adjustedIndex;
             }
-            return (_position - 1 + capacity - index) % capacity;
         }
 
         private void BoundsCheck(int index)

package/Runtime/Core/DataStructure/StringWrapper.cs

@@ -7,6 +7,7 @@
         Used to cache strings, meant to be used in place of strings as keys for when a Dictionary
         has a known set of values
      */
+    [Serializable]
     public sealed class StringWrapper : IEquatable<StringWrapper>, IComparable<StringWrapper>
     {
         private static readonly ConcurrentDictionary<string, StringWrapper> Cache = new();

package/Tests/Runtime/DataStructures/CyclicBufferTests.cs

@@ -25,6 +25,28 @@
             }
         }
 
+        [Test]
+        public void CapacityInitializedOk()
+        {
+            for (int i = 0; i < NumTries; i++)
+            {
+                int capacity = PRNG.Instance.Next(1, int.MaxValue);
+                CyclicBuffer<int> buffer = new(capacity);
+                Assert.AreEqual(capacity, buffer.capacity);
+            }
+        }
+
+        [Test]
+        public void CountInitializedOk()
+        {
+            for (int i = 0; i < NumTries; i++)
+            {
+                int capacity = PRNG.Instance.Next(1, int.MaxValue);
+                CyclicBuffer<int> buffer = new(capacity);
+                Assert.AreEqual(0, buffer.Count);
+            }
+        }
+
         [Test]
         public void ZeroCapacityOk()
         {
@@ -49,7 +71,14 @@
                 int value = PRNG.Instance.Next();
                 buffer.Add(value);
                 expected.Add(value);
-                CollectionAssert.AreEquivalent(expected, buffer);
+                if (!expected.SequenceEqual(buffer))
+                {
+                    Assert.Fail(
+                        $"Failure at iteration {i}, capacity={buffer.capacity}, "
+                            + $"capacityMultiplier={CapacityMultiplier}\n"
+                            + $"Expected: [{string.Join(",", expected)}], Actual: [{string.Join(",", buffer)}]"
+                    );
+                }
             }
         }
 
@@ -68,10 +97,58 @@
             }
         }
 
+        [Test]
+        public void InitialElementsVariableSize()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                int[] elements = Enumerable
+                    .Range(0, (int)(capacity * PRNG.Instance.NextFloat(0.5f, 1.5f)))
+                    .Select(_ => PRNG.Instance.Next())
+                    .ToArray();
+                CyclicBuffer<int> buffer = new(capacity, elements);
+                if (capacity < elements.Length)
+                {
+                    Assert.IsTrue(elements.Skip(elements.Length - capacity).SequenceEqual(buffer));
+                }
+                else
+                {
+                    Assert.IsTrue(elements.SequenceEqual(buffer));
+                }
+            }
+        }
+
+        [Test]
+        public void InitialElementsSizeSameAsCapacity()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                int[] elements = Enumerable
+                    .Range(0, capacity)
+                    .Select(_ => PRNG.Instance.Next())
+                    .ToArray();
+                CyclicBuffer<int> buffer = new(capacity, elements);
+                Assert.IsTrue(elements.SequenceEqual(buffer));
+            }
+        }
+
+        [Test]
+        public void InitialElementsEmptyInput()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity, Array.Empty<int>());
+                Assert.IsTrue(Array.Empty<int>().SequenceEqual(buffer));
+            }
+        }
+
         [Test]
         public void NormalAndWrappingBehavior()
         {
-            List<int> expected = new();
+            LinkedList<int> expected = new();
             for (int i = 0; i < NumTries; ++i)
             {
                 int capacity = PRNG.Instance.Next(100, 1_000);
@@ -81,20 +158,55 @@
                 for (int j = 0; j < capacity * CapacityMultiplier; ++j)
                 {
                     int newValue = PRNG.Instance.Next();
-                    if (capacity <= j)
+                    expected.AddLast(newValue);
+                    while (capacity < expected.Count)
                     {
-                        expected[j % capacity] = newValue;
+                        expected.RemoveFirst();
                     }
-                    else
+                    buffer.Add(newValue);
+                    Assert.AreEqual(expected.Count, buffer.Count);
+                    if (!expected.SequenceEqual(buffer))
                     {
-                        expected.Add(newValue);
+                        Assert.Fail(
+                            $"Failure at iteration {i}, j={j}, capacity={buffer.capacity}, "
+                                + $"capacityMultiplier={CapacityMultiplier}\n"
+                                + $"Expected: [{string.Join(",", expected)}], Actual: [{string.Join(",", buffer)}]"
+                        );
                     }
-                    buffer.Add(newValue);
-                    Assert.IsTrue(
-                        expected.SequenceEqual(buffer),
-                        $"Failure at iteration {i}, j={j}, capacity={capacity}, capacityMultiplier={CapacityMultiplier}"
-                    );
                 }
+
+                foreach (int item in expected)
+                {
+                    Assert.IsTrue(buffer.Contains(item));
+                }
+
+                for (int j = 0; j < NumTries; ++j)
+                {
+                    Assert.IsFalse(buffer.Contains(PRNG.Instance.Next(int.MinValue, -1)));
+                }
+            }
+        }
+
+        [Test]
+        public void ClearOk()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity);
+                float fillPercent = PRNG.Instance.NextFloat(0.5f, 1.5f);
+                for (int j = 0; j < capacity * fillPercent; ++j)
+                {
+                    buffer.Add(PRNG.Instance.Next());
+                }
+
+                Assert.AreNotEqual(0, buffer.Count);
+                Assert.IsFalse(Array.Empty<int>().SequenceEqual(buffer));
+                buffer.Clear();
+
+                Assert.AreEqual(0, buffer.Count);
+                Assert.AreEqual(capacity, buffer.capacity);
+                Assert.IsTrue(Array.Empty<int>().SequenceEqual(buffer));
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc23",
+  "version": "2.0.0-rc24",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},