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

package/Runtime/Tags/AttributeMetadataCache.cs

@@ -5,6 +5,7 @@ namespace WallstopStudios.UnityHelpers.Tags
     using Core.Attributes;
     using UnityEngine;
     using Utils;
+    using WallstopStudios.UnityHelpers.Core.Helper;
 
     /// <summary>
     /// Serialized cache of attribute metadata to avoid runtime reflection.
@@ -150,7 +151,8 @@ namespace WallstopStudios.UnityHelpers.Tags
 
             public bool Equals(ElementTypeKey other)
             {
-                return componentType == other.componentType && fieldName == other.fieldName;
+                return componentType == other.componentType
+                    && string.Equals(fieldName, other.fieldName, StringComparison.Ordinal);
             }
 
             public override bool Equals(object obj)
@@ -160,11 +162,7 @@ namespace WallstopStudios.UnityHelpers.Tags
 
             public override int GetHashCode()
             {
-                unchecked
-                {
-                    return ((componentType?.GetHashCode() ?? 0) * 397)
-                        ^ (fieldName?.GetHashCode() ?? 0);
-                }
+                return Objects.HashCode(componentType, fieldName);
             }
         }
 
@@ -484,9 +482,15 @@ namespace WallstopStudios.UnityHelpers.Tags
             RelationalTypeMetadata[] relationalTypeMetadata
         )
         {
-            _allAttributeNames = allAttributeNames;
-            _typeMetadata = typeMetadata;
-            _relationalTypeMetadata = relationalTypeMetadata;
+            string[] normalizedAttributeNames = SortAttributeNames(allAttributeNames);
+            TypeFieldMetadata[] normalizedTypeMetadata = SortTypeMetadata(typeMetadata);
+            RelationalTypeMetadata[] normalizedRelationalMetadata = SortRelationalTypeMetadata(
+                relationalTypeMetadata
+            );
+
+            _allAttributeNames = normalizedAttributeNames;
+            _typeMetadata = normalizedTypeMetadata;
+            _relationalTypeMetadata = normalizedRelationalMetadata;
             _computedAllAttributeNames = null;
             _computedAllAttributeNamesIncludesTests = false;
             _typeFieldsLookup = null;
@@ -495,6 +499,309 @@ namespace WallstopStudios.UnityHelpers.Tags
             _elementTypeLookup = null;
             UnityEditor.EditorUtility.SetDirty(this);
         }
+
+        private static string[] SortAttributeNames(string[] attributeNames)
+        {
+            if (attributeNames == null || attributeNames.Length == 0)
+            {
+                return Array.Empty<string>();
+            }
+
+            string[] result = new string[attributeNames.Length];
+            Array.Copy(attributeNames, result, attributeNames.Length);
+            Array.Sort(result, StringComparer.Ordinal);
+            return result;
+        }
+
+        private static TypeFieldMetadata[] SortTypeMetadata(TypeFieldMetadata[] typeMetadata)
+        {
+            if (typeMetadata == null || typeMetadata.Length == 0)
+            {
+                return Array.Empty<TypeFieldMetadata>();
+            }
+
+            int nonNullCount = 0;
+            for (int i = 0; i < typeMetadata.Length; i++)
+            {
+                if (typeMetadata[i] != null)
+                {
+                    nonNullCount++;
+                }
+            }
+
+            if (nonNullCount == 0)
+            {
+                return Array.Empty<TypeFieldMetadata>();
+            }
+
+            TypeFieldMetadata[] result = new TypeFieldMetadata[nonNullCount];
+            int resultIndex = 0;
+            for (int i = 0; i < typeMetadata.Length; i++)
+            {
+                TypeFieldMetadata metadata = typeMetadata[i];
+                if (metadata == null)
+                {
+                    continue;
+                }
+
+                string typeName = metadata.typeName ?? string.Empty;
+                string[] fieldNames = metadata.fieldNames ?? Array.Empty<string>();
+                string[] sortedFieldNames =
+                    fieldNames.Length == 0 ? Array.Empty<string>() : CopyAndSort(fieldNames);
+
+                result[resultIndex] = new TypeFieldMetadata(typeName, sortedFieldNames);
+                resultIndex++;
+            }
+
+            Array.Sort(result, CompareTypeFieldMetadata);
+            return result;
+        }
+
+        private static RelationalTypeMetadata[] SortRelationalTypeMetadata(
+            RelationalTypeMetadata[] relationalTypeMetadata
+        )
+        {
+            if (relationalTypeMetadata == null || relationalTypeMetadata.Length == 0)
+            {
+                return Array.Empty<RelationalTypeMetadata>();
+            }
+
+            int nonNullCount = 0;
+            for (int i = 0; i < relationalTypeMetadata.Length; i++)
+            {
+                if (relationalTypeMetadata[i] != null)
+                {
+                    nonNullCount++;
+                }
+            }
+
+            if (nonNullCount == 0)
+            {
+                return Array.Empty<RelationalTypeMetadata>();
+            }
+
+            RelationalTypeMetadata[] result = new RelationalTypeMetadata[nonNullCount];
+            int resultIndex = 0;
+            for (int i = 0; i < relationalTypeMetadata.Length; i++)
+            {
+                RelationalTypeMetadata metadata = relationalTypeMetadata[i];
+                if (metadata == null)
+                {
+                    continue;
+                }
+
+                string typeName = metadata.typeName ?? string.Empty;
+                RelationalFieldMetadata[] sortedFields = SortRelationalFields(metadata.fields);
+                result[resultIndex] = new RelationalTypeMetadata(typeName, sortedFields);
+                resultIndex++;
+            }
+
+            Array.Sort(result, CompareRelationalTypeMetadata);
+            return result;
+        }
+
+        private static RelationalFieldMetadata[] SortRelationalFields(
+            RelationalFieldMetadata[] relationalFields
+        )
+        {
+            if (relationalFields == null || relationalFields.Length == 0)
+            {
+                return Array.Empty<RelationalFieldMetadata>();
+            }
+
+            int nonNullCount = 0;
+            for (int i = 0; i < relationalFields.Length; i++)
+            {
+                if (relationalFields[i] != null)
+                {
+                    nonNullCount++;
+                }
+            }
+
+            if (nonNullCount == 0)
+            {
+                return Array.Empty<RelationalFieldMetadata>();
+            }
+
+            RelationalFieldMetadata[] result = new RelationalFieldMetadata[nonNullCount];
+            int resultIndex = 0;
+            for (int i = 0; i < relationalFields.Length; i++)
+            {
+                RelationalFieldMetadata field = relationalFields[i];
+                if (field == null)
+                {
+                    continue;
+                }
+
+                result[resultIndex] = new RelationalFieldMetadata(
+                    field.fieldName,
+                    field.attributeKind,
+                    field.fieldKind,
+                    field.elementTypeName,
+                    field.isInterface
+                );
+                resultIndex++;
+            }
+
+            Array.Sort(result, CompareRelationalFieldMetadata);
+            return result;
+        }
+
+        private static string[] CopyAndSort(string[] values)
+        {
+            string[] result = new string[values.Length];
+            Array.Copy(values, result, values.Length);
+            Array.Sort(result, StringComparer.Ordinal);
+            return result;
+        }
+
+        private static int CompareTypeFieldMetadata(TypeFieldMetadata left, TypeFieldMetadata right)
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return -1;
+            }
+
+            if (right == null)
+            {
+                return 1;
+            }
+
+            int typeNameComparison = string.CompareOrdinal(left.typeName, right.typeName);
+            if (typeNameComparison != 0)
+            {
+                return typeNameComparison;
+            }
+
+            string[] leftFields = left.fieldNames ?? Array.Empty<string>();
+            string[] rightFields = right.fieldNames ?? Array.Empty<string>();
+
+            int lengthComparison = leftFields.Length.CompareTo(rightFields.Length);
+            if (lengthComparison != 0)
+            {
+                return lengthComparison;
+            }
+
+            for (int i = 0; i < leftFields.Length; i++)
+            {
+                int fieldComparison = string.CompareOrdinal(leftFields[i], rightFields[i]);
+                if (fieldComparison != 0)
+                {
+                    return fieldComparison;
+                }
+            }
+
+            return 0;
+        }
+
+        private static int CompareRelationalTypeMetadata(
+            RelationalTypeMetadata left,
+            RelationalTypeMetadata right
+        )
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return -1;
+            }
+
+            if (right == null)
+            {
+                return 1;
+            }
+
+            int typeNameComparison = string.CompareOrdinal(left.typeName, right.typeName);
+            if (typeNameComparison != 0)
+            {
+                return typeNameComparison;
+            }
+
+            RelationalFieldMetadata[] leftFields =
+                left.fields ?? Array.Empty<RelationalFieldMetadata>();
+            RelationalFieldMetadata[] rightFields =
+                right.fields ?? Array.Empty<RelationalFieldMetadata>();
+
+            int lengthComparison = leftFields.Length.CompareTo(rightFields.Length);
+            if (lengthComparison != 0)
+            {
+                return lengthComparison;
+            }
+
+            for (int i = 0; i < leftFields.Length; i++)
+            {
+                int fieldComparison = CompareRelationalFieldMetadata(leftFields[i], rightFields[i]);
+                if (fieldComparison != 0)
+                {
+                    return fieldComparison;
+                }
+            }
+
+            return 0;
+        }
+
+        private static int CompareRelationalFieldMetadata(
+            RelationalFieldMetadata left,
+            RelationalFieldMetadata right
+        )
+        {
+            if (ReferenceEquals(left, right))
+            {
+                return 0;
+            }
+
+            if (left == null)
+            {
+                return -1;
+            }
+
+            if (right == null)
+            {
+                return 1;
+            }
+
+            int fieldNameComparison = string.CompareOrdinal(left.fieldName, right.fieldName);
+            if (fieldNameComparison != 0)
+            {
+                return fieldNameComparison;
+            }
+
+            int attributeComparison = left.attributeKind.CompareTo(right.attributeKind);
+            if (attributeComparison != 0)
+            {
+                return attributeComparison;
+            }
+
+            int fieldKindComparison = left.fieldKind.CompareTo(right.fieldKind);
+            if (fieldKindComparison != 0)
+            {
+                return fieldKindComparison;
+            }
+
+            int elementTypeComparison = string.CompareOrdinal(
+                left.elementTypeName,
+                right.elementTypeName
+            );
+            if (elementTypeComparison != 0)
+            {
+                return elementTypeComparison;
+            }
+
+            if (left.isInterface == right.isInterface)
+            {
+                return 0;
+            }
+
+            return left.isInterface ? -1 : 1;
+        }
 #endif
     }
 }

package/Runtime/Tags/CosmeticEffectData.cs

@@ -103,7 +103,7 @@ namespace WallstopStudios.UnityHelpers.Tags
 
         public override int GetHashCode()
         {
-            return _cosmeticTypes.Value.Count.GetHashCode();
+            return Objects.HashCode(_cosmeticTypes.Value.Count);
         }
     }
 }

package/Runtime/Visuals/UIToolkit/MultiFileSelectorElement.cs

@@ -663,7 +663,7 @@ namespace WallstopStudios.UnityHelpers.Visuals.UIToolkit
             if (!string.IsNullOrEmpty(rel))
             {
                 // If rel starts with Assets, strip it for subsequent segments
-                display = rel.Replace('\\', '/');
+                display = rel.SanitizePath();
                 if (display.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
                 {
                     display = display.Substring("Assets/".Length);
@@ -712,8 +712,8 @@ namespace WallstopStudios.UnityHelpers.Visuals.UIToolkit
             {
                 return;
             }
-            Toggle toggle = (evt.currentTarget as VisualElement)?.userData as Toggle;
-            if (toggle != null)
+
+            if ((evt.currentTarget as VisualElement)?.userData is Toggle toggle)
             {
                 toggle.value = !toggle.value;
             }

package/Tests/Editor/Helper/HelpersTests.cs

@@ -28,7 +28,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Helper
                 AssetDatabase.CreateFolder("Assets", "TempHelpersPrefabs");
             }
 
-            string assetPath = Path.Combine(folder, "TestPrefab.prefab").Replace('\\', '/');
+            string assetPath = Path.Combine(folder, "TestPrefab.prefab").SanitizePath();
             GameObject prefabSource = Track(new GameObject("Helpers_PrefabSource"));
             try
             {
@@ -63,7 +63,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Helper
                 AssetDatabase.CreateFolder("Assets", "TempHelpersScriptables");
             }
 
-            string assetPath = Path.Combine(folder, "Dummy.asset").Replace('\\', '/');
+            string assetPath = Path.Combine(folder, "Dummy.asset").SanitizePath();
             DummyScriptableObject asset = Track(
                 ScriptableObject.CreateInstance<DummyScriptableObject>()
             );

package/Tests/Editor/Helper/ReflectionHelpersTypedEditorTests.cs

@@ -0,0 +1,87 @@
+#if UNITY_EDITOR
+namespace WallstopStudios.UnityHelpers.Tests.Editor.Helper
+{
+    using System;
+    using System.Reflection;
+    using NUnit.Framework;
+    using WallstopStudios.UnityHelpers.Core.Helper;
+
+    public sealed class TypedHelperEditorTarget
+    {
+        public int Field;
+        public int Property { get; set; }
+    }
+
+    [TestFixture]
+    public sealed class ReflectionHelpersTypedEditorTests
+    {
+        [Test]
+        public void EditorTypedFieldSetterFallbacksWhenCapabilitiesDisabled()
+        {
+            FieldInfo field = typeof(TypedHelperEditorTarget).GetField(
+                nameof(TypedHelperEditorTarget.Field)
+            );
+            using (
+                ReflectionHelpers.OverrideReflectionCapabilities(
+                    expressions: false,
+                    dynamicIl: false
+                )
+            )
+            {
+                FieldSetter<TypedHelperEditorTarget, int> setter = ReflectionHelpers.GetFieldSetter<
+                    TypedHelperEditorTarget,
+                    int
+                >(field);
+                TypedHelperEditorTarget instance = new();
+                setter(ref instance, 12);
+                Assert.AreEqual(12, instance.Field);
+            }
+        }
+
+        [Test]
+        public void EditorTypedPropertySetterFallbacksWhenCapabilitiesDisabled()
+        {
+            PropertyInfo property = typeof(TypedHelperEditorTarget).GetProperty(
+                nameof(TypedHelperEditorTarget.Property)
+            );
+            using (
+                ReflectionHelpers.OverrideReflectionCapabilities(
+                    expressions: false,
+                    dynamicIl: false
+                )
+            )
+            {
+                Action<TypedHelperEditorTarget, int> setter = ReflectionHelpers.GetPropertySetter<
+                    TypedHelperEditorTarget,
+                    int
+                >(property);
+                TypedHelperEditorTarget instance = new();
+                setter(instance, 34);
+                Assert.AreEqual(34, instance.Property);
+            }
+        }
+
+        [Test]
+        public void EditorTypedPropertyGetterFallbacksWhenCapabilitiesDisabled()
+        {
+            PropertyInfo property = typeof(TypedHelperEditorTarget).GetProperty(
+                nameof(TypedHelperEditorTarget.Property)
+            );
+            TypedHelperEditorTarget instance = new() { Property = 56 };
+            using (
+                ReflectionHelpers.OverrideReflectionCapabilities(
+                    expressions: false,
+                    dynamicIl: false
+                )
+            )
+            {
+                Func<TypedHelperEditorTarget, int> getter = ReflectionHelpers.GetPropertyGetter<
+                    TypedHelperEditorTarget,
+                    int
+                >(property);
+                Assert.AreEqual(56, getter(instance));
+            }
+        }
+    }
+}
+#endif

package/Tests/Editor/Helper/ReflectionHelpersTypedEditorTests.cs.meta

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

package/Tests/Editor/Helper/SpriteHelpersTests.cs

@@ -296,7 +296,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Helper
         private void CreateTestTexture(bool readable, int width = 4, int height = 4)
         {
             _testTexturePath = Path.Combine(TestFolder, $"TestTexture_{System.Guid.NewGuid()}.png")
-                .Replace('\\', '/');
+                .SanitizePath();
 
             Texture2D tempTexture = Track(
                 new Texture2D(width, height, TextureFormat.RGBA32, false)

package/Tests/Editor/PrefabCheckerReportTests.cs

@@ -11,7 +11,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor
         [Test]
         public void ScanReportConstructorCopiesFolders()
         {
-            var report = new PrefabChecker.ScanReport(new[] { "A", "B" });
+            PrefabChecker.ScanReport report = new PrefabChecker.ScanReport(new[] { "A", "B" });
             string[] folders = report.folders;
             CollectionAssert.AreEqual(new[] { "A", "B" }, folders);
         }
@@ -19,10 +19,10 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor
         [Test]
         public void ScanReportAddCopiesMessages()
         {
-            var report = new PrefabChecker.ScanReport(Array.Empty<string>());
+            PrefabChecker.ScanReport 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];
+            PrefabChecker.ScanReport.Item first = report.items[0];
             Assert.AreEqual("path.prefab", first.path);
             string[] messages = first.messages;
             CollectionAssert.AreEqual(new[] { "m1", "m2" }, messages);

package/Tests/Editor/Sprites/AnimationCopierFilterTests.cs

@@ -18,20 +18,23 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
         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 };
+            AnimationCopierWindow.AnimationFileInfo a = NewFileInfo("zeta.anim");
+            AnimationCopierWindow.AnimationFileInfo b = NewFileInfo("alpha.anim");
+            AnimationCopierWindow.AnimationFileInfo c = NewFileInfo("beta.anim");
+            List<AnimationCopierWindow.AnimationFileInfo> items =
+                new List<AnimationCopierWindow.AnimationFileInfo> { a, b, c };
 
             wnd._filterText = string.Empty;
             wnd._filterUseRegex = false;
             wnd._sortAscending = true;
-            var asc = wnd.ApplyFilterAndSort(items).ToList();
+            List<AnimationCopierWindow.AnimationFileInfo> 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();
+            List<AnimationCopierWindow.AnimationFileInfo> desc = wnd.ApplyFilterAndSort(items)
+                .ToList();
             string[] descNames = desc.Select(o => o.FileName).ToArray();
             CollectionAssert.AreEqual(new[] { "zeta.anim", "beta.anim", "alpha.anim" }, descNames);
         }
@@ -40,21 +43,24 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
         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 };
+            AnimationCopierWindow.AnimationFileInfo a = NewFileInfo("walk.anim");
+            AnimationCopierWindow.AnimationFileInfo b = NewFileInfo("attack.anim");
+            AnimationCopierWindow.AnimationFileInfo c = NewFileInfo("idle.anim");
+            List<AnimationCopierWindow.AnimationFileInfo> items =
+                new List<AnimationCopierWindow.AnimationFileInfo> { a, b, c };
 
             wnd._filterText = "ta";
             wnd._filterUseRegex = false;
             wnd._sortAscending = true;
-            var sub = wnd.ApplyFilterAndSort(items).ToList();
+            List<AnimationCopierWindow.AnimationFileInfo> 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();
+            List<AnimationCopierWindow.AnimationFileInfo> rx = wnd.ApplyFilterAndSort(items)
+                .ToList();
             string[] rxNames = rx.Select(o => o.FileName).ToArray();
             CollectionAssert.AreEquivalent(new[] { "idle.anim" }, rxNames);
         }

package/Tests/Editor/Sprites/AnimationCopierWindowTests.cs

@@ -5,6 +5,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
     using NUnit.Framework;
     using UnityEditor;
     using UnityEngine;
+    using WallstopStudios.UnityHelpers.Core.Helper;
     using WallstopStudios.UnityHelpers.Editor.Sprites;
     using WallstopStudios.UnityHelpers.Tests.Editor.Utils;
 
@@ -35,7 +36,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
         [Test]
         public void AnalyzeDetectsNewChangedUnchangedAndOrphans()
         {
-            string srcA = Path.Combine(SrcRoot, "A.anim").Replace('\\', '/');
+            string srcA = Path.Combine(SrcRoot, "A.anim").SanitizePath();
             CreateEmptyClip(srcA);
             AssetDatabase.SaveAssets();
             AssetDatabase.Refresh();
@@ -55,7 +56,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
             Assert.AreEqual(0, orphansCount);
 
             // Create destination copy to become unchanged
-            string dstA = Path.Combine(DstRoot, "A.anim").Replace('\\', '/');
+            string dstA = Path.Combine(DstRoot, "A.anim").SanitizePath();
             Assert.IsTrue(AssetDatabase.CopyAsset(srcA, dstA));
             AssetDatabase.SaveAssets();
             AssetDatabase.Refresh();
@@ -66,7 +67,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
             AssetDatabase.Refresh();
 
             // Add orphan in destination
-            string dstB = Path.Combine(DstRoot, "B.anim").Replace('\\', '/');
+            string dstB = Path.Combine(DstRoot, "B.anim").SanitizePath();
             CreateEmptyClip(dstB);
             AssetDatabase.SaveAssets();
             AssetDatabase.Refresh();
@@ -87,8 +88,8 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
         [Test]
         public void CopyChangedPreservesGuidAndOverwrites()
         {
-            string srcA = Path.Combine(SrcRoot, "A.anim").Replace('\\', '/');
-            string dstA = Path.Combine(DstRoot, "A.anim").Replace('\\', '/');
+            string srcA = Path.Combine(SrcRoot, "A.anim").SanitizePath();
+            string dstA = Path.Combine(DstRoot, "A.anim").SanitizePath();
             CreateEmptyClip(srcA);
             AssetDatabase.SaveAssets();
             AssetDatabase.Refresh();
@@ -121,8 +122,8 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
         [Test]
         public void MirrorDeleteRemovesOrphansWhenNotDryRun()
         {
-            string srcA = Path.Combine(SrcRoot, "A.anim").Replace('\\', '/');
-            string dstB = Path.Combine(DstRoot, "B.anim").Replace('\\', '/');
+            string srcA = Path.Combine(SrcRoot, "A.anim").SanitizePath();
+            string dstB = Path.Combine(DstRoot, "B.anim").SanitizePath();
             CreateEmptyClip(srcA);
             CreateEmptyClip(dstB);
             AssetDatabase.SaveAssets();

package/Tests/Editor/Sprites/AnimationViewerWindowTests.cs

@@ -29,7 +29,8 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
             keys[2] = new ObjectReferenceKeyframe { time = 0.2f, value = s3 };
             AnimationUtility.SetObjectReferenceCurve(clip, binding, keys);
 
-            var instance = new AnimationViewerWindow.EditorLayerData(clip);
+            AnimationViewerWindow.EditorLayerData instance =
+                new AnimationViewerWindow.EditorLayerData(clip);
             Assert.NotNull(instance);
             Assert.AreEqual(3, instance.Sprites.Count);
         }