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

package/Samples~/DI - Zenject/README.md

@@ -71,8 +71,6 @@ public class Enemy : MonoBehaviour
 2. Add the `RelationalComponentsInstaller` component to the same GameObject
 3. Enable **"Assign Scene On Initialize"** to automatically wire all scene components after the container builds (recommended)
 
-![SceneContext Setup](../../Docs/Images/zenject_setup.png)
-
 > 💡 **Beginner tip:** Enable both checkboxes in the inspector:
 >
 > - ✅ **Assign Scene On Initialize** → Auto-wires all scene objects (saves you from calling it manually)

package/Tests/Editor/Attributes/WShowIfPropertyDrawerTests.cs

@@ -0,0 +1,285 @@
+namespace WallstopStudios.UnityHelpers.Tests.Editor.Attributes
+{
+    using System.Reflection;
+    using NUnit.Framework;
+    using UnityEditor;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Core.Attributes;
+    using WallstopStudios.UnityHelpers.Editor.CustomDrawers;
+    using WallstopStudios.UnityHelpers.Tags;
+    using WallstopStudios.UnityHelpers.Tests.Editor.Utils;
+
+    [TestFixture]
+    public sealed class WShowIfPropertyDrawerTests : CommonTestBase
+    {
+        private static readonly FieldInfo AttributeField = typeof(PropertyDrawer).GetField(
+            "m_Attribute",
+            BindingFlags.Instance | BindingFlags.NonPublic
+        );
+
+        [Test]
+        public void BoolConditionHidesFieldWhenFalse()
+        {
+            TestContainer container = CreateScriptableObject<TestContainer>();
+            SerializedObject serializedObject = new(container);
+            serializedObject.Update();
+
+            SerializedProperty dependentProperty = serializedObject.FindProperty(
+                nameof(TestContainer.boolDependent)
+            );
+            Assert.NotNull(dependentProperty);
+
+            WShowIfPropertyDrawer drawer = CreateDrawer(
+                new WShowIfAttribute(nameof(TestContainer.boolCondition))
+            );
+
+            container.boolCondition = false;
+            serializedObject.Update();
+            float hiddenHeight = drawer.GetPropertyHeight(
+                dependentProperty,
+                new GUIContent("boolDependent")
+            );
+            Assert.That(hiddenHeight, Is.Zero);
+
+            container.boolCondition = true;
+            serializedObject.Update();
+            float shownHeight = drawer.GetPropertyHeight(
+                dependentProperty,
+                new GUIContent("boolDependent")
+            );
+            Assert.That(shownHeight, Is.GreaterThan(0f));
+        }
+
+        [Test]
+        public void EnumConditionMatchesExpectedValue()
+        {
+            TestContainer container = CreateScriptableObject<TestContainer>();
+            SerializedObject serializedObject = new(container);
+            serializedObject.Update();
+
+            SerializedProperty dependentProperty = serializedObject.FindProperty(
+                nameof(TestContainer.durationDependent)
+            );
+            Assert.NotNull(dependentProperty);
+
+            WShowIfPropertyDrawer drawer = CreateDrawer(
+                new WShowIfAttribute(
+                    nameof(TestContainer.durationType),
+                    expectedValues: new object[] { ModifierDurationType.Duration }
+                )
+            );
+
+            container.durationType = ModifierDurationType.Instant;
+            serializedObject.Update();
+            float hiddenHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(hiddenHeight, Is.Zero);
+
+            container.durationType = ModifierDurationType.Duration;
+            serializedObject.Update();
+            float shownHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(shownHeight, Is.GreaterThan(0f));
+        }
+
+        [Test]
+        public void EnumConditionHonorsInverseFlag()
+        {
+            TestContainer container = CreateScriptableObject<TestContainer>();
+            SerializedObject serializedObject = new(container);
+            serializedObject.Update();
+
+            SerializedProperty dependentProperty = serializedObject.FindProperty(
+                nameof(TestContainer.inverseDependent)
+            );
+            Assert.NotNull(dependentProperty);
+
+            WShowIfPropertyDrawer drawer = CreateDrawer(
+                new WShowIfAttribute(
+                    nameof(TestContainer.durationType),
+                    inverse: true,
+                    expectedValues: new object[] { ModifierDurationType.Instant }
+                )
+            );
+
+            container.durationType = ModifierDurationType.Instant;
+            serializedObject.Update();
+            float hiddenHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(hiddenHeight, Is.Zero);
+
+            container.durationType = ModifierDurationType.Infinite;
+            serializedObject.Update();
+            float shownHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(shownHeight, Is.GreaterThan(0f));
+        }
+
+        [Test]
+        public void FloatConditionMatchesExpectedValue()
+        {
+            TestContainer container = CreateScriptableObject<TestContainer>();
+            SerializedObject serializedObject = new(container);
+            serializedObject.Update();
+
+            SerializedProperty dependentProperty = serializedObject.FindProperty(
+                nameof(TestContainer.floatDependent)
+            );
+            Assert.NotNull(dependentProperty);
+
+            WShowIfPropertyDrawer drawer = CreateDrawer(
+                new WShowIfAttribute(
+                    nameof(TestContainer.floatCondition),
+                    expectedValues: new object[] { 3.5f }
+                )
+            );
+
+            container.floatCondition = 0f;
+            serializedObject.Update();
+            float hiddenHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(hiddenHeight, Is.Zero);
+
+            container.floatCondition = 3.5f;
+            serializedObject.Update();
+            float shownHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(shownHeight, Is.GreaterThan(0f));
+        }
+
+        [Test]
+        public void DoubleConditionMatchesEquivalentIntExpectedValue()
+        {
+            TestContainer container = CreateScriptableObject<TestContainer>();
+            SerializedObject serializedObject = new(container);
+            serializedObject.Update();
+
+            SerializedProperty dependentProperty = serializedObject.FindProperty(
+                nameof(TestContainer.doubleDependent)
+            );
+            Assert.NotNull(dependentProperty);
+
+            WShowIfPropertyDrawer drawer = CreateDrawer(
+                new WShowIfAttribute(
+                    nameof(TestContainer.doubleCondition),
+                    expectedValues: new object[] { 7 }
+                )
+            );
+
+            container.doubleCondition = 2.5d;
+            serializedObject.Update();
+            float hiddenHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(hiddenHeight, Is.Zero);
+
+            container.doubleCondition = 7d;
+            serializedObject.Update();
+            float shownHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(shownHeight, Is.GreaterThan(0f));
+        }
+
+        [Test]
+        public void IntConditionMatchesExpectedValue()
+        {
+            TestContainer container = CreateScriptableObject<TestContainer>();
+            SerializedObject serializedObject = new(container);
+            serializedObject.Update();
+
+            SerializedProperty dependentProperty = serializedObject.FindProperty(
+                nameof(TestContainer.intDependent)
+            );
+            Assert.NotNull(dependentProperty);
+
+            WShowIfPropertyDrawer drawer = CreateDrawer(
+                new WShowIfAttribute(
+                    nameof(TestContainer.intCondition),
+                    expectedValues: new object[] { 42 }
+                )
+            );
+
+            container.intCondition = 7;
+            serializedObject.Update();
+            float hiddenHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(hiddenHeight, Is.Zero);
+
+            container.intCondition = 42;
+            serializedObject.Update();
+            float shownHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(shownHeight, Is.GreaterThan(0f));
+        }
+
+        [Test]
+        public void StringConditionMatchesExpectedValues()
+        {
+            TestContainer container = CreateScriptableObject<TestContainer>();
+            SerializedObject serializedObject = new(container);
+            serializedObject.Update();
+
+            SerializedProperty dependentProperty = serializedObject.FindProperty(
+                nameof(TestContainer.stringDependent)
+            );
+            Assert.NotNull(dependentProperty);
+
+            WShowIfPropertyDrawer drawer = CreateDrawer(
+                new WShowIfAttribute(
+                    nameof(TestContainer.stringCondition),
+                    expectedValues: new object[] { "alpha", "beta" }
+                )
+            );
+
+            container.stringCondition = "gamma";
+            serializedObject.Update();
+            float hiddenHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(hiddenHeight, Is.Zero);
+
+            container.stringCondition = "alpha";
+            serializedObject.Update();
+            float shownHeight = drawer.GetPropertyHeight(dependentProperty, GUIContent.none);
+            Assert.That(shownHeight, Is.GreaterThan(0f));
+        }
+
+        private static WShowIfPropertyDrawer CreateDrawer(WShowIfAttribute attribute)
+        {
+            WShowIfPropertyDrawer drawer = new();
+            Assert.NotNull(AttributeField);
+            AttributeField.SetValue(drawer, attribute);
+            return drawer;
+        }
+
+        private sealed class TestContainer : ScriptableObject
+        {
+            public bool boolCondition;
+
+            [WShowIf(nameof(boolCondition))]
+            public int boolDependent;
+
+            public ModifierDurationType durationType = ModifierDurationType.Instant;
+
+            [WShowIf(
+                nameof(durationType),
+                expectedValues: new object[] { ModifierDurationType.Duration }
+            )]
+            public int durationDependent;
+
+            [WShowIf(
+                nameof(durationType),
+                inverse: true,
+                expectedValues: new object[] { ModifierDurationType.Instant }
+            )]
+            public int inverseDependent;
+
+            public float floatCondition;
+
+            [WShowIf(nameof(floatCondition), expectedValues: new object[] { 3.5f })]
+            public int floatDependent;
+
+            public double doubleCondition;
+
+            [WShowIf(nameof(doubleCondition), expectedValues: new object[] { 7 })]
+            public int doubleDependent;
+
+            public int intCondition;
+
+            [WShowIf(nameof(intCondition), expectedValues: new object[] { 42 })]
+            public int intDependent;
+
+            public string stringCondition;
+
+            [WShowIf(nameof(stringCondition), expectedValues: new object[] { "alpha", "beta" })]
+            public int stringDependent;
+        }
+    }
+}

package/Tests/Editor/Attributes/WShowIfPropertyDrawerTests.cs.meta

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

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

@@ -24,7 +24,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Core.Attributes
         }
 
         [Test]
-        public void HasRelationalAssignments_RespectsMetadata()
+        public void HasRelationalAssignmentsRespectsMetadata()
         {
             AttributeMetadataCache cache = CreateScriptableObject<AttributeMetadataCache>();
 
@@ -62,7 +62,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Core.Attributes
         }
 
         [Test]
-        public void Assign_IEnumerable_AssignsOnlyRelationalTypes_AndSkipsNulls()
+        public void AssignIEnumerableAssignsOnlyRelationalTypesAndSkipsNulls()
         {
             AttributeMetadataCache cache = CreateScriptableObject<AttributeMetadataCache>();
 

package/Tests/Editor/Utils/ScriptableObjectSingletonTests.cs

@@ -34,6 +34,8 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Utils
             yield return null;
             DeleteAssetIfExists("Assets/Resources/CustomPath/CustomPathSingleton.asset");
             yield return null;
+            DeleteFolderIfEmpty("Assets/Resources/CustomPath");
+            yield return null;
 
             // For nested test types, Unity cannot create valid .asset files (no script file).
             // Instead, create in-memory instances so the singleton loader can discover them via FindObjectsOfTypeAll.
@@ -81,6 +83,43 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Utils
             }
         }
 
+        private static void DeleteFolderIfEmpty(string folderPath)
+        {
+            if (string.IsNullOrWhiteSpace(folderPath))
+            {
+                return;
+            }
+
+            if (!AssetDatabase.IsValidFolder(folderPath))
+            {
+                return;
+            }
+
+            string[] subFolders = AssetDatabase.GetSubFolders(folderPath);
+            if (subFolders != null && subFolders.Length > 0)
+            {
+                return;
+            }
+
+            string[] assetGuids = AssetDatabase.FindAssets(string.Empty, new[] { folderPath });
+            for (int i = 0; i < assetGuids.Length; i++)
+            {
+                string guid = assetGuids[i];
+                string assetPath = AssetDatabase.GUIDToAssetPath(guid);
+                if (
+                    !string.IsNullOrEmpty(assetPath)
+                    && !string.Equals(assetPath, folderPath, System.StringComparison.Ordinal)
+                )
+                {
+                    return;
+                }
+            }
+
+            AssetDatabase.DeleteAsset(folderPath);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+        }
+
         private static TType CreateInMemoryInstance<TType>()
             where TType : ScriptableObject
         {
@@ -144,6 +183,8 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Utils
             AssetDatabase.SaveAssets();
             AssetDatabase.Refresh();
             yield return null;
+            DeleteFolderIfEmpty("Assets/Resources/CustomPath");
+            yield return null;
             // Prefer public API surface over reflection to clean up the cached instance
             if (TestSingleton.HasInstance)
             {

package/Tests/Runtime/Serialization/JsonSerializationTest.cs

@@ -4,6 +4,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
     using System.Collections.Generic;
     using System.Linq;
     using System.Runtime.Serialization;
+    using System.Text.Json;
     using System.Text.Json.Serialization;
     using NUnit.Framework;
     using UnityEngine;
@@ -42,9 +43,9 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
             using System.Text.Json.JsonDocument doc = System.Text.Json.JsonDocument.Parse(json);
             System.Text.Json.JsonElement root = doc.RootElement;
             Assert.AreEqual(System.Text.Json.JsonValueKind.Object, root.ValueKind);
-            Assert.True(root.TryGetProperty("name", out var name));
-            Assert.True(root.TryGetProperty("type", out var type));
-            Assert.True(root.TryGetProperty("instanceId", out var id));
+            Assert.True(root.TryGetProperty("name", out JsonElement name));
+            Assert.True(root.TryGetProperty("type", out JsonElement type));
+            Assert.True(root.TryGetProperty("instanceId", out JsonElement id));
             Assert.AreEqual("Test GameObject", name.GetString());
             StringAssert.Contains("UnityEngine.GameObject", type.GetString());
             Assert.AreEqual(expectedId, id.GetInt32());

package/Tests/Runtime/Tags/AttributeEffectTests.cs

@@ -0,0 +1,135 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags
+{
+    using System.Text.Json;
+    using NUnit.Framework;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Tags;
+
+    [TestFixture]
+    public sealed class AttributeEffectTests : AttributeTagsTestBase
+    {
+        [Test]
+        public void HumanReadableDescriptionFormatsAllModificationTypes()
+        {
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.name = "Composite";
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Addition,
+                    value = 5f,
+                }
+            );
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "attack_speed",
+                    action = ModificationAction.Multiplication,
+                    value = 1.5f,
+                }
+            );
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "armor",
+                    action = ModificationAction.Override,
+                    value = 10f,
+                }
+            );
+
+            string description = effect.HumanReadableDescription;
+            Assert.AreEqual("+5 Health, +50% Attack Speed, 10 Armor", description);
+        }
+
+        [Test]
+        public void HumanReadableDescriptionSkipsNeutralModifications()
+        {
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Addition,
+                    value = 0f,
+                }
+            );
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "speed",
+                    action = ModificationAction.Multiplication,
+                    value = 1f,
+                }
+            );
+
+            Assert.IsEmpty(effect.HumanReadableDescription);
+        }
+
+        [Test]
+        public void ToStringSerializesSummaryAndCollections()
+        {
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.name = "JsonEffect";
+            effect.durationType = ModifierDurationType.Duration;
+            effect.duration = 3.25f;
+            effect.resetDurationOnReapplication = true;
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Addition,
+                    value = 10f,
+                }
+            );
+            effect.effectTags.Add("Buff");
+
+            GameObject cosmeticHolder = Track(new GameObject("Glow", typeof(CosmeticEffectData)));
+            CosmeticEffectData cosmeticData = cosmeticHolder.GetComponent<CosmeticEffectData>();
+            effect.cosmeticEffects.Add(cosmeticData);
+
+            using JsonDocument document = JsonDocument.Parse(effect.ToString());
+            JsonElement root = document.RootElement;
+            Assert.AreEqual(
+                effect.HumanReadableDescription,
+                root.GetProperty("Description").GetString()
+            );
+            Assert.AreEqual("Duration", root.GetProperty("durationType").GetString());
+            Assert.AreEqual(3.25f, root.GetProperty("duration").GetSingle());
+            Assert.AreEqual("Buff", root.GetProperty("tags")[0].GetString());
+            Assert.AreEqual("Glow", root.GetProperty("CosmeticEffects")[0].GetString());
+            Assert.AreEqual(1, root.GetProperty("modifications").GetArrayLength());
+        }
+
+        [Test]
+        public void EqualsRequiresMatchingState()
+        {
+            AttributeEffect left = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            AttributeEffect right = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            left.name = right.name = "Stack";
+            left.durationType = right.durationType = ModifierDurationType.Duration;
+            left.duration = right.duration = 2f;
+            left.resetDurationOnReapplication = right.resetDurationOnReapplication = false;
+
+            AttributeModification modification = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 5f,
+            };
+
+            left.modifications.Add(modification);
+            right.modifications.Add(modification);
+            Assert.IsTrue(left.Equals(right));
+
+            right.modifications[0] = new AttributeModification
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 10f,
+            };
+
+            Assert.IsFalse(left.Equals(right));
+        }
+    }
+}

package/Tests/Runtime/Tags/AttributeEffectTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f9cf8158bca5461c9fba12c31ab373b6
+timeCreated: 1761249361

package/Tests/Runtime/Tags/AttributeModificationTests.cs

@@ -0,0 +1,137 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags
+{
+    using System;
+    using System.Text.Json;
+    using NUnit.Framework;
+    using WallstopStudios.UnityHelpers.Core.Serialization;
+    using WallstopStudios.UnityHelpers.Tags;
+    using WallstopStudios.UnityHelpers.Tests.TestUtils;
+
+    public abstract class AttributeTagsTestBase : CommonTestBase
+    {
+        protected static void ResetEffectHandleId(long value = 0)
+        {
+            EffectHandle.Id = value;
+        }
+    }
+
+    [TestFixture]
+    public sealed class AttributeModificationTests
+    {
+        [Test]
+        public void EqualityOperatorsRespectFields()
+        {
+            AttributeModification baseline = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Multiplication,
+                value = 1.5f,
+            };
+
+            AttributeModification clone = baseline;
+            Assert.IsTrue(baseline == clone);
+            Assert.IsFalse(baseline != clone);
+            Assert.AreEqual(baseline, clone);
+            Assert.AreEqual(baseline.GetHashCode(), clone.GetHashCode());
+
+            AttributeModification differentAttribute = baseline;
+            differentAttribute.attribute = "armor";
+            Assert.IsFalse(baseline == differentAttribute);
+            Assert.IsTrue(baseline != differentAttribute);
+
+            AttributeModification differentAction = baseline;
+            differentAction.action = ModificationAction.Addition;
+            Assert.IsFalse(baseline.Equals(differentAction));
+
+            AttributeModification differentValue = baseline;
+            differentValue.value = 2f;
+            Assert.IsFalse(baseline.Equals(differentValue));
+        }
+
+        [Test]
+        public void ToStringSerializesAllFields()
+        {
+            AttributeModification modification = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Override,
+                value = 42.5f,
+            };
+
+            using JsonDocument document = JsonDocument.Parse(modification.ToString());
+            JsonElement root = document.RootElement;
+            Assert.AreEqual(
+                "health",
+                root.GetProperty(nameof(AttributeModification.attribute)).GetString()
+            );
+            Assert.AreEqual(
+                "Override",
+                root.GetProperty(nameof(AttributeModification.action)).GetString()
+            );
+            Assert.AreEqual(
+                42.5f,
+                root.GetProperty(nameof(AttributeModification.value)).GetSingle()
+            );
+        }
+
+        [Test]
+        public void SystemTextJsonRoundtripPreservesFields()
+        {
+            AttributeModification modification = new(
+                "armor",
+                ModificationAction.Multiplication,
+                1.25f
+            );
+            string json = Serializer.JsonStringify(modification);
+            AttributeModification clone = Serializer.JsonDeserialize<AttributeModification>(json);
+
+            Assert.AreEqual(modification, clone);
+        }
+
+        [Test]
+        public void ProtoBufRoundtripPreservesFields()
+        {
+            AttributeModification modification = new("speed", ModificationAction.Addition, -3f);
+            byte[] payload = Serializer.ProtoSerialize(modification);
+            AttributeModification clone = Serializer.ProtoDeserialize<AttributeModification>(
+                payload
+            );
+            Assert.AreEqual(modification, clone);
+        }
+
+        [Test]
+        public void CompareToOrdersBasedOnAction()
+        {
+            AttributeModification addition = new("health", ModificationAction.Addition, 10f);
+            AttributeModification multiplication = new(
+                "health",
+                ModificationAction.Multiplication,
+                2f
+            );
+            AttributeModification overrideValue = new("health", ModificationAction.Override, 0f);
+
+            AttributeModification[] unsorted = { overrideValue, multiplication, addition };
+
+            Array.Sort(unsorted);
+
+            Assert.AreEqual(addition, unsorted[0], "Addition should be applied first when sorted.");
+            Assert.AreEqual(
+                multiplication,
+                unsorted[1],
+                "Multiplication should appear after additions when sorted."
+            );
+            Assert.AreEqual(
+                overrideValue,
+                unsorted[2],
+                "Override should be processed last when sorted."
+            );
+        }
+
+        [Test]
+        public void CompareToObjectReturnsMinusOneForNonAttributeModification()
+        {
+            AttributeModification addition = new("health", ModificationAction.Addition, 5f);
+            Assert.AreEqual(-1, addition.CompareTo("not a modification"));
+        }
+    }
+}