com.wallstop-studios.unity-helpers 2.1.0 → 2.1.2

package/Tests/Runtime/Extensions/IListExtensionTests.cs

@@ -17,6 +17,14 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             public int Compare(int x, int y) => x.CompareTo(y);
         }
 
+        private sealed class StableTupleComparer : IComparer<ValueTuple<int, int>>
+        {
+            public int Compare(ValueTuple<int, int> x, ValueTuple<int, int> y)
+            {
+                return x.Item1.CompareTo(y.Item1);
+            }
+        }
+
         private readonly struct IntEqualityComparer : IEqualityComparer<int>
         {
             public bool Equals(int x, int y) => x == y;
@@ -135,7 +143,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
         }
 
         [Test]
-        public void ShellSortEnhanced()
+        public void GhostSort()
         {
             for (int i = 0; i < NumTries; ++i)
             {
@@ -153,6 +161,120 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             }
         }
 
+        [Test]
+        public void MeteorSort()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int[] input = Enumerable
+                    .Range(0, 100)
+                    .Select(_ => PRNG.Instance.Next(int.MinValue, int.MaxValue))
+                    .ToArray();
+                int[] conventionalSorted = input.ToArray();
+                Array.Sort(conventionalSorted);
+
+                int[] meteorSorted = input.ToArray();
+                meteorSorted.MeteorSort(new IntComparer());
+                Assert.That(conventionalSorted, Is.EqualTo(meteorSorted));
+                Assert.That(input.OrderBy(x => x), Is.EqualTo(meteorSorted));
+            }
+        }
+
+        [Test]
+        public void PatternDefeatingQuickSort()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int[] input = Enumerable
+                    .Range(0, 100)
+                    .Select(_ => PRNG.Instance.Next(int.MinValue, int.MaxValue))
+                    .ToArray();
+                int[] conventionalSorted = input.ToArray();
+                Array.Sort(conventionalSorted);
+
+                int[] pdqSorted = input.ToArray();
+                pdqSorted.PatternDefeatingQuickSort(new IntComparer());
+                Assert.That(conventionalSorted, Is.EqualTo(pdqSorted));
+                Assert.That(input.OrderBy(x => x), Is.EqualTo(pdqSorted));
+            }
+        }
+
+        [Test]
+        public void GrailSort()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int[] input = Enumerable
+                    .Range(0, 100)
+                    .Select(_ => PRNG.Instance.Next(int.MinValue, int.MaxValue))
+                    .ToArray();
+                int[] conventionalSorted = input.ToArray();
+                Array.Sort(conventionalSorted);
+
+                int[] grailSorted = input.ToArray();
+                grailSorted.GrailSort(new IntComparer());
+                Assert.That(conventionalSorted, Is.EqualTo(grailSorted));
+                Assert.That(input.OrderBy(x => x), Is.EqualTo(grailSorted));
+            }
+        }
+
+        [Test]
+        public void PowerSort()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int[] input = Enumerable
+                    .Range(0, 100)
+                    .Select(_ => PRNG.Instance.Next(int.MinValue, int.MaxValue))
+                    .ToArray();
+                int[] conventionalSorted = input.ToArray();
+                Array.Sort(conventionalSorted);
+
+                int[] powerSorted = input.ToArray();
+                powerSorted.PowerSort(new IntComparer());
+                Assert.That(conventionalSorted, Is.EqualTo(powerSorted));
+                Assert.That(input.OrderBy(x => x), Is.EqualTo(powerSorted));
+            }
+        }
+
+        [Test]
+        public void GrailSortIsStable()
+        {
+            ValueTuple<int, int>[] input = Enumerable
+                .Range(0, 100)
+                .Select(i => ValueTuple.Create(i / 5, i))
+                .ToArray();
+            ValueTuple<int, int>[] grailSorted = input.ToArray();
+            grailSorted.GrailSort(new StableTupleComparer());
+
+            for (int i = 1; i < grailSorted.Length; ++i)
+            {
+                if (grailSorted[i - 1].Item1 == grailSorted[i].Item1)
+                {
+                    Assert.That(grailSorted[i - 1].Item2, Is.LessThan(grailSorted[i].Item2));
+                }
+            }
+        }
+
+        [Test]
+        public void PowerSortIsStable()
+        {
+            ValueTuple<int, int>[] input = Enumerable
+                .Range(0, 100)
+                .Select(i => ValueTuple.Create(i / 4, i))
+                .ToArray();
+            ValueTuple<int, int>[] powerSorted = input.ToArray();
+            powerSorted.PowerSort(new StableTupleComparer());
+
+            for (int i = 1; i < powerSorted.Length; ++i)
+            {
+                if (powerSorted[i - 1].Item1 == powerSorted[i].Item1)
+                {
+                    Assert.That(powerSorted[i - 1].Item2, Is.LessThan(powerSorted[i].Item2));
+                }
+            }
+        }
+
         [Test]
         public void SortDefaultAlgorithm()
         {
@@ -731,6 +853,70 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             Assert.That(single, Is.EqualTo(new[] { 42 }));
         }
 
+        [Test]
+        public void PatternDefeatingQuickSortEmptyList()
+        {
+            int[] empty = Array.Empty<int>();
+            empty.PatternDefeatingQuickSort(new IntComparer());
+            Assert.That(empty, Is.Empty);
+        }
+
+        [Test]
+        public void PatternDefeatingQuickSortSingleElement()
+        {
+            int[] single = { 42 };
+            single.PatternDefeatingQuickSort(new IntComparer());
+            Assert.That(single, Is.EqualTo(new[] { 42 }));
+        }
+
+        [Test]
+        public void GrailSortEmptyList()
+        {
+            int[] empty = Array.Empty<int>();
+            empty.GrailSort(new IntComparer());
+            Assert.That(empty, Is.Empty);
+        }
+
+        [Test]
+        public void GrailSortSingleElement()
+        {
+            int[] single = { 42 };
+            single.GrailSort(new IntComparer());
+            Assert.That(single, Is.EqualTo(new[] { 42 }));
+        }
+
+        [Test]
+        public void PowerSortEmptyList()
+        {
+            int[] empty = Array.Empty<int>();
+            empty.PowerSort(new IntComparer());
+            Assert.That(empty, Is.Empty);
+        }
+
+        [Test]
+        public void PowerSortSingleElement()
+        {
+            int[] single = { 42 };
+            single.PowerSort(new IntComparer());
+            Assert.That(single, Is.EqualTo(new[] { 42 }));
+        }
+
+        [Test]
+        public void MeteorSortEmptyList()
+        {
+            int[] empty = Array.Empty<int>();
+            empty.MeteorSort(new IntComparer());
+            Assert.That(empty, Is.Empty);
+        }
+
+        [Test]
+        public void MeteorSortSingleElement()
+        {
+            int[] single = { 42 };
+            single.MeteorSort(new IntComparer());
+            Assert.That(single, Is.EqualTo(new[] { 42 }));
+        }
+
         [Test]
         public void CombinedOperationsShuffleThenSort()
         {

package/Tests/Runtime/Helper/ObjectsTests.cs

@@ -293,7 +293,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Helper
             CustomClass[] array = { a, b, c };
             ReadOnlySpan<CustomClass> span = array;
 
-            int spanHash = Objects.HashCode(span);
+            int spanHash = Objects.SpanHashCode(span);
             int variadicHash = Objects.HashCode(a, b, c);
 
             Assert.AreEqual(variadicHash, spanHash);
@@ -343,8 +343,8 @@ namespace WallstopStudios.UnityHelpers.Tests.Helper
             CustomEnumerable ascending = new(1, 2, 3);
             CustomEnumerable descending = new(3, 2, 1);
 
-            int ascHash = Objects.EnumerableHashCode<int>(ascending);
-            int descHash = Objects.EnumerableHashCode<int>(descending);
+            int ascHash = Objects.EnumerableHashCode(ascending);
+            int descHash = Objects.EnumerableHashCode(descending);
 
             Assert.AreNotEqual(ascHash, descHash);
         }
@@ -354,7 +354,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Helper
         {
             DisposableEnumerable enumerable = new(1, 2, 3);
 
-            int result = Objects.EnumerableHashCode<int>(enumerable);
+            int result = Objects.EnumerableHashCode(enumerable);
 
             Assert.AreNotEqual(0, result);
             Assert.IsTrue(enumerable.LastEnumerator.WasDisposed);