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

package/Tests/Runtime/DataStructures/CyclicBufferTests.cs

@@ -0,0 +1,213 @@
+namespace UnityHelpers.Tests.DataStructures
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.DataStructure;
+    using Core.Random;
+    using NUnit.Framework;
+
+    public sealed class CyclicBufferTests
+    {
+        private const int NumTries = 100;
+        private const int CapacityMultiplier = 3;
+
+        [Test]
+        public void InvalidCapacity()
+        {
+            Assert.Throws<ArgumentException>(() => new CyclicBuffer<int>(-1));
+            Assert.Throws<ArgumentException>(() => new CyclicBuffer<int>(int.MinValue));
+            for (int i = 0; i < NumTries; i++)
+            {
+                Assert.Throws<ArgumentException>(
+                    () => new CyclicBuffer<int>(PRNG.Instance.Next(int.MinValue, -1))
+                );
+            }
+        }
+
+        [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()
+        {
+            CyclicBuffer<int> buffer = new(0);
+            CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+            for (int i = 0; i < NumTries; ++i)
+            {
+                buffer.Add(PRNG.Instance.Next());
+                CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+            }
+        }
+
+        [Test]
+        public void IntMaxCapacityOk()
+        {
+            CyclicBuffer<int> buffer = new(int.MaxValue);
+            CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+            const int tries = 50;
+            List<int> expected = new(tries);
+            for (int i = 0; i < tries; ++i)
+            {
+                int value = PRNG.Instance.Next();
+                buffer.Add(value);
+                expected.Add(value);
+                if (!expected.SequenceEqual(buffer))
+                {
+                    Assert.Fail(
+                        $"Failure at iteration {i}, capacity={buffer.capacity}, "
+                            + $"capacityMultiplier={CapacityMultiplier}\n"
+                            + $"Expected: [{string.Join(",", expected)}], Actual: [{string.Join(",", buffer)}]"
+                    );
+                }
+            }
+        }
+
+        [Test]
+        public void OneCapacityOk()
+        {
+            CyclicBuffer<int> buffer = new(1);
+            CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+            int[] expected = new int[1];
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int value = PRNG.Instance.Next();
+                buffer.Add(value);
+                expected[0] = value;
+                CollectionAssert.AreEquivalent(expected, buffer);
+            }
+        }
+
+        [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()
+        {
+            LinkedList<int> expected = new();
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity);
+                CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+                expected.Clear();
+                for (int j = 0; j < capacity * CapacityMultiplier; ++j)
+                {
+                    int newValue = PRNG.Instance.Next();
+                    expected.AddLast(newValue);
+                    while (capacity < expected.Count)
+                    {
+                        expected.RemoveFirst();
+                    }
+                    buffer.Add(newValue);
+                    Assert.AreEqual(expected.Count, buffer.Count);
+                    if (!expected.SequenceEqual(buffer))
+                    {
+                        Assert.Fail(
+                            $"Failure at iteration {i}, j={j}, capacity={buffer.capacity}, "
+                                + $"capacityMultiplier={CapacityMultiplier}\n"
+                                + $"Expected: [{string.Join(",", expected)}], Actual: [{string.Join(",", buffer)}]"
+                        );
+                    }
+                }
+
+                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/Tests/Runtime/DataStructures/CyclicBufferTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e6e1c3d02ef74aabb922aa776a8648f0
+timeCreated: 1740364919

package/Tests/Runtime/DataStructures/QuadTreeTests.cs

@@ -1,8 +1,8 @@
 namespace UnityHelpers.Tests.DataStructures
 {
     using System.Collections.Generic;
-    using UnityEngine;
     using Core.DataStructure;
+    using UnityEngine;
 
     public sealed class QuadTreeTests : SpatialTreeTests<QuadTree<Vector2>>
     {

package/Tests/Runtime/DataStructures/UnbalancedKDTreeTests.cs

@@ -1,8 +1,8 @@
 namespace UnityHelpers.Tests.DataStructures
 {
     using System.Collections.Generic;
-    using UnityEngine;
     using Core.DataStructure;
+    using UnityEngine;
 
     public sealed class UnbalancedKDTreeTests : SpatialTreeTests<KDTree<Vector2>>
     {

package/Tests/Runtime/Extensions/DictionaryExtensionTests.cs

@@ -17,11 +17,13 @@
             Assert.AreEqual(value, dictionary["test"]);
 
             int newValue = dictionary.GetOrAdd(
-                "test", () =>
+                "test",
+                () =>
                 {
                     Assert.Fail("Value Producer should not have been called!");
                     return 200;
-                });
+                }
+            );
             Assert.AreEqual(100, newValue);
 
             newValue = dictionary.GetOrAdd("test2", () => 300);
@@ -34,28 +36,34 @@
         {
             Dictionary<string, int> dictionary = new();
             int value = dictionary.GetOrAdd(
-                "test", key =>
+                "test",
+                key =>
                 {
                     Assert.AreEqual("test", key);
                     return 100;
-                });
+                }
+            );
             Assert.AreEqual(100, value);
             Assert.AreEqual(value, dictionary["test"]);
 
             int newValue = dictionary.GetOrAdd(
-                "test", key =>
+                "test",
+                key =>
                 {
                     Assert.Fail("Value Producer should not have been called!");
                     return 200;
-                });
+                }
+            );
             Assert.AreEqual(100, newValue);
 
             newValue = dictionary.GetOrAdd(
-                "test2", key =>
+                "test2",
+                key =>
                 {
                     Assert.AreEqual("test2", key);
                     return 300;
-                });
+                }
+            );
             Assert.AreEqual(300, newValue);
             Assert.AreEqual(100, dictionary["test"]);
         }
@@ -82,11 +90,13 @@
             Assert.IsFalse(dictionary.ContainsKey("test"));
             dictionary["test"] = 150;
             value = dictionary.GetOrElse(
-                "test", () =>
+                "test",
+                () =>
                 {
                     Assert.Fail("Producer should not be called.");
                     return 100;
-                });
+                }
+            );
             Assert.AreEqual(150, value);
             Assert.AreEqual(150, dictionary["test"]);
         }
@@ -96,20 +106,24 @@
         {
             Dictionary<string, int> dictionary = new();
             int value = dictionary.GetOrElse(
-                "test", key =>
+                "test",
+                key =>
                 {
                     Assert.AreEqual("test", key);
                     return 100;
-                });
+                }
+            );
             Assert.AreEqual(100, value);
             Assert.IsFalse(dictionary.ContainsKey("test"));
             dictionary["test"] = 150;
             value = dictionary.GetOrElse(
-                "test", () =>
+                "test",
+                () =>
                 {
                     Assert.Fail("Producer should not be called.");
                     return 100;
-                });
+                }
+            );
             Assert.AreEqual(150, value);
             Assert.AreEqual(150, dictionary["test"]);
         }
@@ -162,29 +176,35 @@
         {
             Dictionary<string, int> dictionary = new();
             int value = dictionary.TryAdd(
-                "test", key =>
+                "test",
+                key =>
                 {
                     Assert.AreEqual("test", key);
                     return 150;
-                });
+                }
+            );
             Assert.AreEqual(150, value);
             Assert.AreEqual(value, dictionary["test"]);
 
             value = dictionary.TryAdd(
-                "test", key =>
+                "test",
+                key =>
                 {
                     Assert.Fail("Creator should not have been called.");
                     return 200;
-                });
+                }
+            );
             Assert.AreEqual(150, value);
             Assert.AreEqual(value, dictionary["test"]);
 
             value = dictionary.TryAdd(
-                "test2", key =>
+                "test2",
+                key =>
                 {
                     Assert.AreEqual("test2", key);
                     return 350;
-                });
+                }
+            );
             Assert.AreEqual(350, value);
             Assert.AreEqual(value, dictionary["test2"]);
             Assert.AreEqual(150, dictionary["test"]);
@@ -416,4 +436,4 @@
             Assert.AreEqual(1, value);
         }
     }
-}
+}

package/Tests/Runtime/Extensions/StringExtensionTests.cs

@@ -28,4 +28,4 @@
             Assert.AreEqual("Pascal.Case", "  __Pascal____   ___Case__ ".ToPascalCase(separator));
         }
     }
-}
+}

package/Tests/Runtime/Performance/QuadTreePerformanceTests.cs

@@ -1,8 +1,8 @@
 namespace UnityHelpers.Tests.Performance
 {
     using System.Collections.Generic;
-    using UnityEngine;
     using Core.DataStructure;
+    using UnityEngine;
 
     public sealed class QuadTreePerformanceTests : SpatialTreePerformanceTest<QuadTree<Vector2>>
     {

package/Tests/Runtime/Performance/UnbalancedKDTreeTests.cs

@@ -1,8 +1,8 @@
 namespace UnityHelpers.Tests.Performance
 {
     using System.Collections.Generic;
-    using UnityEngine;
     using Core.DataStructure;
+    using UnityEngine;
 
     public sealed class UnbalancedKDTreeTests : SpatialTreePerformanceTest<KDTree<Vector2>>
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc22",
+  "version": "2.0.0-rc24",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},
@@ -18,7 +18,8 @@
     "rtree",
     "r tree",
     "kd tree",
-    "kdtree"
+    "kdtree",
+    "cyclic buffer"
   ],
   "license": "MIT",
   "repository": {