com.wallstop-studios.unity-helpers 2.0.0-rc81.9 → 2.0.0

package/Samples~/UGUI - EnhancedImage/README.md

@@ -3,10 +3,11 @@ UGUI – EnhancedImage
 Shows programmatic setup and basic usage of `EnhancedImage` with HDR tinting.
 
 How to use
+
 - Add `EnhancedImageDemo` to an empty scene and press Play.
 - Optionally assign a `materialTemplate` in the inspector to use a shader that exposes `_Color` and optional `_ShapeMask`.
 
 What it shows
+
 - Creating a `Canvas` and an `EnhancedImage` at runtime.
 - Setting an HDR tint via `HdrColor` (values > 1).
-

package/Samples~/UI Toolkit - MultiFile Selector (Editor)/README.md

@@ -3,10 +3,11 @@ UI Toolkit – MultiFile Selector (Editor)
 A minimal EditorWindow showcasing `MultiFileSelectorElement` for fast in-Editor multi-file selection with breadcrumbs, filtering and virtualization.
 
 How to use
+
 - Import the sample, then open: `Window > Unity Helpers > MultiFile Selector Sample`.
 - Pick extensions and select multiple files; results are logged to the Console.
 
 What it shows
+
 - Creating and adding `MultiFileSelectorElement` to an EditorWindow.
 - Hooks for `OnFilesSelected` and `OnCancelled`.
-

package/THIRD_PARTY_NOTICES.md

@@ -27,7 +27,7 @@ Full License Texts
 
 Apache License
 Version 2.0, January 2004
-[http://www.apache.org/licenses/](http://www.apache.org/licenses/)
+[https://www.apache.org/licenses/](https://www.apache.org/licenses/)
 
 TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 

package/Tests/Editor/Attributes/AnimationEventHelpersTests.cs

@@ -93,6 +93,22 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Attributes
 
             CollectionAssert.AreEquivalent(expected, methods.Select(method => method.Name));
         }
+
+        [Test]
+        public void GetPossibleAnimatorEventsAreSortedByName()
+        {
+            List<MethodInfo> methods = AnimationEventHelpers.GetPossibleAnimatorEventsForType(
+                typeof(AnimationEventSignatureHost)
+            );
+            // Ensure ascending ordinal sort by method name
+            for (int i = 1; i < methods.Count; i++)
+            {
+                Assert.LessOrEqual(
+                    string.Compare(methods[i - 1].Name, methods[i].Name, StringComparison.Ordinal),
+                    0
+                );
+            }
+        }
     }
 
     internal enum AnimationEventSignal

package/Tests/Editor/Core/Attributes/RelationalComponentAssignerTests.cs

@@ -98,13 +98,13 @@ namespace WallstopStudios.UnityHelpers.Tests.Core.Attributes
             GameObject go2 = NewGameObject("NonRelational");
             NonRelational non = go2.AddComponent<NonRelational>();
 
-            Assert.IsNull(consumer.SR, "Precondition: relational field should start null");
+            Assert.IsTrue(consumer.SR == null, "Precondition: relational field should start null");
 
             List<Component> items = new List<Component> { consumer, null, non.transform };
             assigner.Assign(items);
 
-            Assert.IsNotNull(
-                consumer.SR,
+            Assert.IsTrue(
+                consumer.SR != null,
                 "Relational field should be assigned by Assign(IEnumerable<Component>)"
             );
 

package/Tests/Editor/Integrations/VContainer/VContainerRelationalEntryPointTests.cs

@@ -55,6 +55,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.VContainer
                 new[] { relationalMetadata }
             );
             cache.ForceRebuildForTests();
+            yield return null;
 #endif
 
             RelationalComponentAssigner assigner = new RelationalComponentAssigner(cache);
@@ -69,8 +70,11 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.VContainer
             // Allow assignment to complete
             yield return null;
 
-            Assert.NotNull(consumer);
-            Assert.NotNull(consumer.SR, "Relational field should be assigned by entry point");
+            Assert.IsTrue(consumer != null);
+            Assert.IsTrue(
+                consumer.SR != null,
+                "Relational field should be assigned by entry point"
+            );
         }
     }
 }

package/Tests/Editor/Integrations/VContainer/VContainerRelationalHelpersTests.cs

@@ -0,0 +1,170 @@
+#if VCONTAINER_PRESENT
+namespace WallstopStudios.UnityHelpers.Tests.Integrations.VContainer
+{
+    using System.Collections;
+    using global::VContainer;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.SceneManagement;
+    using UnityEngine.TestTools;
+    using WallstopStudios.UnityHelpers.Core.Attributes;
+    using WallstopStudios.UnityHelpers.Integrations.VContainer;
+    using WallstopStudios.UnityHelpers.Tags;
+    using WallstopStudios.UnityHelpers.Tests.Editor.Utils;
+
+    public sealed class VContainerRelationalHelpersTests : CommonTestBase
+    {
+        private sealed class TestComponent : MonoBehaviour
+        {
+            [ParentComponent(OnlyAncestors = true)]
+            public Rigidbody parentBody;
+
+            [ChildComponent(OnlyDescendants = true)]
+            public CapsuleCollider childCollider;
+        }
+
+        [Test]
+        public void InjectWithRelationsAssignsFields()
+        {
+            ContainerBuilder builder = new ContainerBuilder();
+            IObjectResolver resolver = builder.Build();
+
+            // Build hierarchy: Parent(Rigidbody) -> Middle(TestComponent) -> Child(CapsuleCollider)
+            GameObject parent = NewGameObject("Parent");
+            parent.AddComponent<Rigidbody>();
+            GameObject middle = NewGameObject("Middle");
+            middle.transform.SetParent(parent.transform);
+            TestComponent comp = middle.AddComponent<TestComponent>();
+            GameObject child = NewGameObject("Child");
+            child.transform.SetParent(middle.transform);
+            child.AddComponent<CapsuleCollider>();
+
+            TestComponent result = resolver.InjectWithRelations(comp);
+
+            Assert.That(result, Is.SameAs(comp));
+            Assert.IsTrue(comp.parentBody != null);
+            Assert.IsTrue(comp.childCollider != null);
+        }
+
+        [Test]
+        public void InstantiateComponentWithRelationsAssignsFields()
+        {
+            ContainerBuilder builder = new ContainerBuilder();
+            IObjectResolver resolver = builder.Build();
+
+            // Build prefab hierarchy: Root(Rigidbody) -> Middle(TestComponent) -> Child(CapsuleCollider)
+            GameObject prefabRoot = NewGameObject("PrefabRoot");
+            prefabRoot.AddComponent<Rigidbody>();
+            GameObject prefabMiddle = NewGameObject("PrefabMiddle");
+            prefabMiddle.transform.SetParent(prefabRoot.transform);
+            TestComponent prefabComp = prefabMiddle.AddComponent<TestComponent>();
+            GameObject prefabChild = NewGameObject("PrefabChild");
+            prefabChild.transform.SetParent(prefabMiddle.transform);
+            prefabChild.AddComponent<CapsuleCollider>();
+
+            // Instantiate the full hierarchy and hydrate via GO helper
+            GameObject instanceRoot = resolver.InstantiateGameObjectWithRelations(prefabRoot);
+            TestComponent instance = instanceRoot.GetComponentInChildren<TestComponent>(true);
+
+            Assert.IsTrue(instance != null);
+            Assert.IsTrue(instance.parentBody != null);
+            Assert.IsTrue(instance.childCollider != null);
+        }
+
+        [Test]
+        public void InjectGameObjectWithRelationsAssignsHierarchy()
+        {
+            ContainerBuilder builder = new ContainerBuilder();
+            IObjectResolver resolver = builder.Build();
+
+            GameObject root = NewGameObject("Root");
+            root.AddComponent<Rigidbody>();
+            GameObject middle = NewGameObject("Middle");
+            middle.transform.SetParent(root.transform);
+            TestComponent comp = middle.AddComponent<TestComponent>();
+            GameObject child = NewGameObject("Child");
+            child.transform.SetParent(middle.transform);
+            child.AddComponent<CapsuleCollider>();
+
+            resolver.InjectGameObjectWithRelations(root);
+
+            Assert.IsTrue(comp.parentBody != null);
+            Assert.IsTrue(comp.childCollider != null);
+        }
+
+        [Test]
+        public void InstantiateGameObjectWithRelationsAssignsHierarchy()
+        {
+            ContainerBuilder builder = new ContainerBuilder();
+            IObjectResolver resolver = builder.Build();
+
+            GameObject prefab = NewGameObject("PrefabRoot");
+            prefab.AddComponent<Rigidbody>();
+            GameObject mid = NewGameObject("PrefabMiddle");
+            mid.transform.SetParent(prefab.transform);
+            TestComponent prefabComp = mid.AddComponent<TestComponent>();
+            GameObject child = NewGameObject("PrefabChild");
+            child.transform.SetParent(mid.transform);
+            child.AddComponent<CapsuleCollider>();
+
+            GameObject instance = resolver.InstantiateGameObjectWithRelations(prefab);
+            TestComponent comp = instance.GetComponentInChildren<TestComponent>(true);
+
+            Assert.IsTrue(comp != null);
+            Assert.IsTrue(comp.parentBody != null);
+            Assert.IsTrue(comp.childCollider != null);
+        }
+
+        [Test]
+        public void AssignerRecognizesBaseTypeMetadataForDerivedComponents()
+        {
+            AttributeMetadataCache cache = CreateScriptableObject<AttributeMetadataCache>();
+
+            AttributeMetadataCache.RelationalFieldMetadata[] fields =
+            {
+                new AttributeMetadataCache.RelationalFieldMetadata(
+                    nameof(BaseWithSibling._spriteRenderer),
+                    AttributeMetadataCache.RelationalAttributeKind.Sibling,
+                    AttributeMetadataCache.FieldKind.Single,
+                    typeof(SpriteRenderer).AssemblyQualifiedName,
+                    false
+                ),
+            };
+            AttributeMetadataCache.RelationalTypeMetadata[] relational =
+            {
+                new AttributeMetadataCache.RelationalTypeMetadata(
+                    typeof(BaseWithSibling).AssemblyQualifiedName,
+                    fields
+                ),
+            };
+            cache._relationalTypeMetadata = relational;
+            cache.ForceRebuildForTests();
+
+            ContainerBuilder builder = new ContainerBuilder();
+            builder.RegisterInstance(cache).AsSelf();
+            builder
+                .RegisterInstance(new RelationalComponentAssigner(cache))
+                .As<IRelationalComponentAssigner>();
+            IObjectResolver resolver = builder.Build();
+
+            GameObject go = NewGameObject("Root");
+            go.AddComponent<SpriteRenderer>();
+            DerivedWithSibling comp = go.AddComponent<DerivedWithSibling>();
+
+            resolver.AssignRelationalComponents(comp);
+
+            Assert.IsTrue(comp.SR != null);
+        }
+
+        private class BaseWithSibling : MonoBehaviour
+        {
+            [SiblingComponent]
+            protected internal SpriteRenderer _spriteRenderer;
+
+            public SpriteRenderer SR => _spriteRenderer;
+        }
+
+        private sealed class DerivedWithSibling : BaseWithSibling { }
+    }
+}
+#endif

package/Tests/Editor/Integrations/VContainer/VContainerRelationalHelpersTests.cs.meta

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

package/Tests/Editor/Integrations/VContainer/WallstopStudios.UnityHelpers.Tests.Editor.VContainer.asmdef

@@ -6,7 +6,8 @@
     "UnityEngine.TestRunner",
     "WallstopStudios.UnityHelpers",
     "WallstopStudios.UnityHelpers.Integration.VContainer",
-    "WallstopStudios.UnityHelpers.Tests.Editor"
+    "WallstopStudios.UnityHelpers.Tests.Editor",
+    "VContainer"
   ],
   "includePlatforms": ["Editor"],
   "excludePlatforms": [],

package/Tests/Editor/Integrations/Zenject/WallstopStudios.UnityHelpers.Tests.Editor.Zenject.asmdef

@@ -6,13 +6,14 @@
     "UnityEngine.TestRunner",
     "WallstopStudios.UnityHelpers",
     "WallstopStudios.UnityHelpers.Integration.Zenject",
-    "WallstopStudios.UnityHelpers.Tests.Editor"
+    "WallstopStudios.UnityHelpers.Tests.Editor",
+    "Zenject"
   ],
   "includePlatforms": ["Editor"],
   "excludePlatforms": [],
   "allowUnsafeCode": false,
   "overrideReferences": true,
-  "precompiledReferences": ["nunit.framework.dll"],
+  "precompiledReferences": ["nunit.framework.dll", "Zenject-usage.dll"],
   "autoReferenced": false,
   "defineConstraints": ["UNITY_INCLUDE_TESTS", "ZENJECT_PRESENT"],
   "versionDefines": [

package/Tests/Editor/Integrations/Zenject/ZenjectRelationalHelpersTests.cs

@@ -0,0 +1,131 @@
+#if ZENJECT_PRESENT
+namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
+{
+    using System.Collections;
+    using global::Zenject;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.SceneManagement;
+    using UnityEngine.TestTools;
+    using WallstopStudios.UnityHelpers.Core.Attributes;
+    using WallstopStudios.UnityHelpers.Integrations.Zenject;
+    using WallstopStudios.UnityHelpers.Tags;
+    using WallstopStudios.UnityHelpers.Tests.Editor.Utils;
+
+    public sealed class ZenjectRelationalHelpersTests : CommonTestBase
+    {
+        private sealed class TestComponent : MonoBehaviour
+        {
+            [ParentComponent(OnlyAncestors = true)]
+            public Rigidbody parentBody;
+
+            [ChildComponent(OnlyDescendants = true)]
+            public CapsuleCollider childCollider;
+        }
+
+        [Test]
+        public void InjectWithRelationsAssignsFields()
+        {
+            DiContainer container = new DiContainer();
+
+            // Build hierarchy: Parent(Rigidbody) -> Middle(TestComponent) -> Child(CapsuleCollider)
+            GameObject parent = NewGameObject("Root");
+            parent.AddComponent<Rigidbody>();
+            GameObject middle = NewGameObject("Middle");
+            middle.transform.SetParent(parent.transform);
+            TestComponent comp = middle.AddComponent<TestComponent>();
+            GameObject child = NewGameObject("Child");
+            child.transform.SetParent(middle.transform);
+            child.AddComponent<CapsuleCollider>();
+
+            TestComponent result = container.InjectWithRelations(comp);
+
+            Assert.That(result, Is.SameAs(comp));
+            Assert.IsTrue(comp.parentBody != null);
+        }
+
+        [Test]
+        public void InjectGameObjectWithRelationsAssignsHierarchy()
+        {
+            DiContainer container = new DiContainer();
+
+            GameObject root = NewGameObject("Root");
+            root.AddComponent<Rigidbody>();
+            GameObject middle = NewGameObject("Middle");
+            middle.transform.SetParent(root.transform);
+            TestComponent comp = middle.AddComponent<TestComponent>();
+            GameObject child = NewGameObject("Child");
+            child.transform.SetParent(middle.transform);
+            child.AddComponent<CapsuleCollider>();
+
+            container.InjectGameObjectWithRelations(root);
+
+            Assert.IsTrue(comp.parentBody != null);
+            Assert.IsTrue(comp.childCollider != null);
+        }
+
+        [Test]
+        public void InstantiateGameObjectWithRelationsAssignsHierarchy()
+        {
+            DiContainer container = new DiContainer();
+
+            GameObject prefab = NewGameObject("PrefabRoot");
+            prefab.AddComponent<Rigidbody>();
+            GameObject mid = NewGameObject("PrefabMiddle");
+            mid.transform.SetParent(prefab.transform);
+            TestComponent prefabComp = mid.AddComponent<TestComponent>();
+            GameObject child = NewGameObject("PrefabChild");
+            child.transform.SetParent(mid.transform);
+            child.AddComponent<CapsuleCollider>();
+
+            GameObject instance = container.InstantiateGameObjectWithRelations(prefab);
+            TestComponent comp = instance.GetComponentInChildren<TestComponent>(true);
+
+            Assert.IsTrue(comp != null);
+            Assert.IsTrue(comp.parentBody != null);
+            Assert.IsTrue(comp.childCollider != null);
+        }
+
+        [Test]
+        public void RelationalMemoryPoolAssignsOnSpawn()
+        {
+            // Create a pool and inject a container into the private field using reflection
+            RelationalMemoryPool<TestComponent> pool = new RelationalMemoryPool<TestComponent>();
+            DiContainer container = new DiContainer();
+
+            pool._container = container;
+
+            GameObject go = NewGameObject("PooledRoot");
+            go.AddComponent<Rigidbody>();
+            GameObject middle = NewGameObject("PooledMiddle");
+            middle.transform.SetParent(go.transform);
+            TestComponent comp = middle.AddComponent<TestComponent>();
+            GameObject child = NewGameObject("PooledChild");
+            child.transform.SetParent(middle.transform);
+            child.AddComponent<CapsuleCollider>();
+
+            // Call OnSpawned indirectly via protected method using a small helper
+            PoolHarness harness = new PoolHarness(pool);
+            harness.InvokeOnSpawned(comp);
+
+            Assert.IsTrue(comp.parentBody != null);
+            Assert.IsTrue(comp.childCollider != null);
+        }
+
+        private sealed class PoolHarness
+        {
+            private readonly RelationalMemoryPool<TestComponent> _pool;
+
+            public PoolHarness(RelationalMemoryPool<TestComponent> pool)
+            {
+                _pool = pool;
+            }
+
+            public void InvokeOnSpawned(TestComponent item)
+            {
+                _pool.InternalOnSpawned(item);
+            }
+        }
+    }
+}
+#endif

package/Tests/Editor/Integrations/Zenject/ZenjectRelationalHelpersTests.cs.meta

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

package/Tests/Editor/Integrations/Zenject/ZenjectRelationalInitializerTests.cs

@@ -54,6 +54,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
                 new[] { relationalMetadata }
             );
             cache.ForceRebuildForTests();
+            yield return null;
 #endif
 
             RelationalComponentAssigner assigner = new RelationalComponentAssigner(cache);
@@ -68,8 +69,11 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
 
             yield return null;
 
-            Assert.NotNull(consumer);
-            Assert.NotNull(consumer.SR, "Relational field should be assigned by initializer");
+            Assert.IsTrue(consumer != null);
+            Assert.IsTrue(
+                consumer.SR != null,
+                "Relational field should be assigned by initializer"
+            );
         }
     }
 }

package/Tests/Editor/PersistentDirectorySettingsTests.cs

@@ -0,0 +1,59 @@
+namespace WallstopStudios.UnityHelpers.Tests.Editor
+{
+#if UNITY_EDITOR
+    using NUnit.Framework;
+    using UnityEditor;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Editor;
+
+    public sealed class PersistentDirectorySettingsTests
+    {
+        [Test]
+        public void GetPathsSortsByCountThenLastUsed()
+        {
+            PersistentDirectorySettings settings =
+                ScriptableObject.CreateInstance<PersistentDirectorySettings>();
+
+            string tool = "TestTool";
+            string ctx = "Context";
+
+            // B: 1 time, A: 3 times, C: 2 times
+            settings.RecordPath(tool, ctx, "Assets/A");
+            settings.RecordPath(tool, ctx, "Assets/A");
+            settings.RecordPath(tool, ctx, "Assets/A");
+
+            settings.RecordPath(tool, ctx, "Assets/C");
+            settings.RecordPath(tool, ctx, "Assets/C");
+
+            settings.RecordPath(tool, ctx, "Assets/B");
+
+            DirectoryUsageData[] paths = settings.GetPaths(tool, ctx);
+            Assert.IsNotNull(paths);
+            Assert.GreaterOrEqual(paths.Length, 3);
+            Assert.AreEqual("Assets/A", paths[0].path);
+            Assert.AreEqual("Assets/C", paths[1].path);
+            Assert.AreEqual("Assets/B", paths[2].path);
+        }
+
+        [Test]
+        public void GetPathsTopOnlyRespectsLimit()
+        {
+            PersistentDirectorySettings settings =
+                ScriptableObject.CreateInstance<PersistentDirectorySettings>();
+
+            string tool = "TopOnlyTool";
+            string ctx = "Context";
+
+            settings.RecordPath(tool, ctx, "Assets/One");
+            settings.RecordPath(tool, ctx, "Assets/One");
+            settings.RecordPath(tool, ctx, "Assets/Two");
+            settings.RecordPath(tool, ctx, "Assets/Three");
+
+            DirectoryUsageData[] top2 = settings.GetPaths(tool, ctx, topOnly: true, topN: 2);
+            Assert.IsNotNull(top2);
+            Assert.AreEqual(2, top2.Length);
+            Assert.AreEqual("Assets/One", top2[0].path);
+        }
+    }
+#endif
+}

package/Tests/Editor/PersistentDirectorySettingsTests.cs.meta

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

package/Tests/Editor/PrefabCheckerReportTests.cs

@@ -0,0 +1,32 @@
+namespace WallstopStudios.UnityHelpers.Tests.Editor
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using NUnit.Framework;
+    using WallstopStudios.UnityHelpers.Editor;
+
+    public sealed class PrefabCheckerReportTests
+    {
+        [Test]
+        public void ScanReportConstructorCopiesFolders()
+        {
+            var report = new PrefabChecker.ScanReport(new[] { "A", "B" });
+            string[] folders = report.folders;
+            CollectionAssert.AreEqual(new[] { "A", "B" }, folders);
+        }
+
+        [Test]
+        public void ScanReportAddCopiesMessages()
+        {
+            var report = new PrefabChecker.ScanReport(Array.Empty<string>());
+            report.Add("path.prefab", new List<string> { "m1", "m2" });
+            Assert.AreEqual(1, report.items.Count);
+            var first = report.items[0];
+            Assert.AreEqual("path.prefab", first.path);
+            string[] messages = first.messages;
+            CollectionAssert.AreEqual(new[] { "m1", "m2" }, messages);
+        }
+    }
+#endif
+}

package/Tests/Editor/PrefabCheckerReportTests.cs.meta

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

package/Tests/Editor/Sprites/AnimationCopierFilterTests.cs

@@ -0,0 +1,64 @@
+namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using NUnit.Framework;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Editor.Sprites;
+
+    public sealed class AnimationCopierFilterTests
+    {
+        private static AnimationCopierWindow.AnimationFileInfo NewFileInfo(string name)
+        {
+            return new AnimationCopierWindow.AnimationFileInfo { FileName = name };
+        }
+
+        [Test]
+        public void SortsAscendingAndDescending()
+        {
+            AnimationCopierWindow wnd = ScriptableObject.CreateInstance<AnimationCopierWindow>();
+            var a = NewFileInfo("zeta.anim");
+            var b = NewFileInfo("alpha.anim");
+            var c = NewFileInfo("beta.anim");
+            var items = new List<AnimationCopierWindow.AnimationFileInfo> { a, b, c };
+
+            wnd._filterText = string.Empty;
+            wnd._filterUseRegex = false;
+            wnd._sortAscending = true;
+            var asc = wnd.ApplyFilterAndSort(items).ToList();
+            string[] ascNames = asc.Select(o => o.FileName).ToArray();
+            CollectionAssert.AreEqual(new[] { "alpha.anim", "beta.anim", "zeta.anim" }, ascNames);
+
+            wnd._sortAscending = false;
+            var desc = wnd.ApplyFilterAndSort(items).ToList();
+            string[] descNames = desc.Select(o => o.FileName).ToArray();
+            CollectionAssert.AreEqual(new[] { "zeta.anim", "beta.anim", "alpha.anim" }, descNames);
+        }
+
+        [Test]
+        public void FiltersBySubstringAndRegex()
+        {
+            AnimationCopierWindow wnd = ScriptableObject.CreateInstance<AnimationCopierWindow>();
+            var a = NewFileInfo("walk.anim");
+            var b = NewFileInfo("attack.anim");
+            var c = NewFileInfo("idle.anim");
+            var items = new List<AnimationCopierWindow.AnimationFileInfo> { a, b, c };
+
+            wnd._filterText = "ta";
+            wnd._filterUseRegex = false;
+            wnd._sortAscending = true;
+            var sub = wnd.ApplyFilterAndSort(items).ToList();
+            string[] subNames = sub.Select(o => o.FileName).ToArray();
+            CollectionAssert.AreEquivalent(new[] { "attack.anim" }, subNames);
+
+            wnd._filterText = "^i";
+            wnd._filterUseRegex = true;
+            var rx = wnd.ApplyFilterAndSort(items).ToList();
+            string[] rxNames = rx.Select(o => o.FileName).ToArray();
+            CollectionAssert.AreEquivalent(new[] { "idle.anim" }, rxNames);
+        }
+    }
+#endif
+}

package/Tests/Editor/Sprites/AnimationCopierFilterTests.cs.meta

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