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

package/Tests/Editor/Tags/AttributeMetadataCacheTests.cs

@@ -0,0 +1,192 @@
+namespace WallstopStudios.UnityHelpers.Tests.Editor.Tags
+{
+    using System;
+    using System.Reflection;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityHelpers.Tags;
+
+    [TestFixture]
+    public sealed class AttributeMetadataCacheTests
+    {
+        [Test]
+        public void SetMetadataSortsSerializedContent()
+        {
+            AttributeMetadataCache cache =
+                ScriptableObject.CreateInstance<AttributeMetadataCache>();
+
+            try
+            {
+                string[] attributeNames = new string[] { "Gamma", "Alpha", "Beta" };
+
+                string alphaAttributesTypeName =
+                    typeof(AlphaAttributesComponent).AssemblyQualifiedName ?? string.Empty;
+                string bravoAttributesTypeName =
+                    typeof(BravoAttributesComponent).AssemblyQualifiedName ?? string.Empty;
+
+                AttributeMetadataCache.TypeFieldMetadata alphaTypeMetadata = new(
+                    alphaAttributesTypeName,
+                    new string[] { "gammaField", "betaField" }
+                );
+
+                AttributeMetadataCache.TypeFieldMetadata bravoTypeMetadata = new(
+                    bravoAttributesTypeName,
+                    new string[] { "zetaField", "alphaField" }
+                );
+
+                string alphaRelationalTypeName =
+                    typeof(AlphaRelationalComponent).AssemblyQualifiedName ?? string.Empty;
+                string bravoRelationalTypeName =
+                    typeof(BravoRelationalComponent).AssemblyQualifiedName ?? string.Empty;
+
+                AttributeMetadataCache.RelationalFieldMetadata[] alphaRelationalFields =
+                    new AttributeMetadataCache.RelationalFieldMetadata[]
+                    {
+                        new(
+                            "betaRelation",
+                            AttributeMetadataCache.RelationalAttributeKind.Parent,
+                            AttributeMetadataCache.FieldKind.HashSet,
+                            typeof(Light).AssemblyQualifiedName ?? string.Empty,
+                            true
+                        ),
+                        new(
+                            "alphaRelation",
+                            AttributeMetadataCache.RelationalAttributeKind.Child,
+                            AttributeMetadataCache.FieldKind.Single,
+                            typeof(Transform).AssemblyQualifiedName ?? string.Empty,
+                            false
+                        ),
+                    };
+
+                AttributeMetadataCache.RelationalFieldMetadata[] bravoRelationalFields =
+                    new AttributeMetadataCache.RelationalFieldMetadata[]
+                    {
+                        new(
+                            "zetaRelation",
+                            AttributeMetadataCache.RelationalAttributeKind.Sibling,
+                            AttributeMetadataCache.FieldKind.List,
+                            typeof(Camera).AssemblyQualifiedName ?? string.Empty,
+                            true
+                        ),
+                        new(
+                            "alphaRelation",
+                            AttributeMetadataCache.RelationalAttributeKind.Child,
+                            AttributeMetadataCache.FieldKind.Single,
+                            typeof(Transform).AssemblyQualifiedName ?? string.Empty,
+                            false
+                        ),
+                    };
+
+                AttributeMetadataCache.RelationalTypeMetadata[] relationalMetadata =
+                    new AttributeMetadataCache.RelationalTypeMetadata[]
+                    {
+                        new(
+                            bravoRelationalTypeName,
+                            new AttributeMetadataCache.RelationalFieldMetadata[]
+                            {
+                                bravoRelationalFields[0],
+                                null,
+                                bravoRelationalFields[1],
+                            }
+                        ),
+                        null,
+                        new(alphaRelationalTypeName, alphaRelationalFields),
+                    };
+
+                AttributeMetadataCache.TypeFieldMetadata[] typeMetadata =
+                    new AttributeMetadataCache.TypeFieldMetadata[]
+                    {
+                        bravoTypeMetadata,
+                        null,
+                        alphaTypeMetadata,
+                    };
+
+                cache.SetMetadata(attributeNames, typeMetadata, relationalMetadata);
+
+                string[] storedAttributeNames = GetPrivateField<string[]>(
+                    cache,
+                    "_allAttributeNames"
+                );
+                Assert.That(
+                    storedAttributeNames,
+                    Is.EqualTo(new string[] { "Alpha", "Beta", "Gamma" })
+                );
+
+                AttributeMetadataCache.TypeFieldMetadata[] storedTypeMetadata =
+                    GetPrivateField<AttributeMetadataCache.TypeFieldMetadata[]>(
+                        cache,
+                        "_typeMetadata"
+                    );
+                Assert.That(storedTypeMetadata.Length, Is.EqualTo(2));
+                Assert.That(storedTypeMetadata[0].typeName, Is.EqualTo(alphaAttributesTypeName));
+                Assert.That(
+                    storedTypeMetadata[0].fieldNames,
+                    Is.EqualTo(new string[] { "betaField", "gammaField" })
+                );
+                Assert.That(storedTypeMetadata[1].typeName, Is.EqualTo(bravoAttributesTypeName));
+                Assert.That(
+                    storedTypeMetadata[1].fieldNames,
+                    Is.EqualTo(new string[] { "alphaField", "zetaField" })
+                );
+
+                AttributeMetadataCache.RelationalTypeMetadata[] storedRelationalMetadata =
+                    GetPrivateField<AttributeMetadataCache.RelationalTypeMetadata[]>(
+                        cache,
+                        "_relationalTypeMetadata"
+                    );
+                Assert.That(storedRelationalMetadata.Length, Is.EqualTo(2));
+                Assert.That(
+                    storedRelationalMetadata[0].typeName,
+                    Is.EqualTo(alphaRelationalTypeName)
+                );
+                Assert.That(storedRelationalMetadata[0].fields.Length, Is.EqualTo(2));
+                Assert.That(
+                    storedRelationalMetadata[0].fields[0].fieldName,
+                    Is.EqualTo("alphaRelation")
+                );
+                Assert.That(
+                    storedRelationalMetadata[0].fields[1].fieldName,
+                    Is.EqualTo("betaRelation")
+                );
+                Assert.That(
+                    storedRelationalMetadata[1].typeName,
+                    Is.EqualTo(bravoRelationalTypeName)
+                );
+                Assert.That(storedRelationalMetadata[1].fields.Length, Is.EqualTo(2));
+                Assert.That(
+                    storedRelationalMetadata[1].fields[0].fieldName,
+                    Is.EqualTo("alphaRelation")
+                );
+                Assert.That(
+                    storedRelationalMetadata[1].fields[1].fieldName,
+                    Is.EqualTo("zetaRelation")
+                );
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(cache);
+            }
+        }
+
+        private static T GetPrivateField<T>(AttributeMetadataCache cache, string fieldName)
+        {
+            BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic;
+            FieldInfo field = typeof(AttributeMetadataCache).GetField(fieldName, bindingFlags);
+            if (field == null)
+            {
+                throw new InvalidOperationException($"Field '{fieldName}' was not found.");
+            }
+
+            object value = field.GetValue(cache);
+            return value is T castValue ? castValue : default;
+        }
+
+        private sealed class AlphaAttributesComponent : AttributesComponent { }
+
+        private sealed class BravoAttributesComponent : AttributesComponent { }
+
+        private sealed class AlphaRelationalComponent : MonoBehaviour { }
+
+        private sealed class BravoRelationalComponent : MonoBehaviour { }
+    }
+}

package/Tests/Editor/Tags/AttributeMetadataCacheTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e6e89a6fc9964f9f92a7bb5cbb4f793d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Editor/Tags.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 43bfcdf80a014948b5377ffa29afa8df
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -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);

package/Tests/Runtime/Integrations/Reflex/RelationalComponentsReflexTests.cs

@@ -321,7 +321,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Reflex
             GameObject root = Track(new GameObject("ReflexComponentPrefab"));
             ReflexRelationalTester tester = root.AddComponent<ReflexRelationalTester>();
 
-            GameObject child = new GameObject("ReflexComponentPrefabChild");
+            GameObject child = new("ReflexComponentPrefabChild");
             child.AddComponent<CapsuleCollider>();
             child.transform.SetParent(root.transform, false);
 
@@ -334,7 +334,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Reflex
             GameObject root = Track(new GameObject("ReflexGameObjectPrefab"));
             root.AddComponent<ReflexRelationalTester>();
 
-            GameObject child = new GameObject("ReflexGameObjectPrefabChild");
+            GameObject child = new("ReflexGameObjectPrefabChild");
             child.AddComponent<CapsuleCollider>();
             child.transform.SetParent(root.transform, false);