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

package/Tests/Runtime/Serialization/UnityEngineObjectJsonTests.cs

@@ -0,0 +1,247 @@
+namespace WallstopStudios.UnityHelpers.Tests.Serialization
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Text;
+    using System.Text.Json;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+    using WallstopStudios.UnityHelpers.Core.Helper;
+    using WallstopStudios.UnityHelpers.Core.Serialization;
+    using WallstopStudios.UnityHelpers.Tests.TestUtils;
+
+    [TestFixture]
+    public sealed class UnityEngineObjectJsonTests : CommonTestBase
+    {
+        [Test]
+        public void GameObjectSerializationContainsExpectedFields()
+        {
+            GameObject go = Track(new GameObject("GO_Main"));
+            int expectedId = go.GetInstanceID();
+            string json = Serializer.JsonStringify(go);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.AreEqual(JsonValueKind.Object, root.ValueKind);
+            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("GO_Main", name.GetString());
+            StringAssert.Contains("UnityEngine.GameObject", type.GetString());
+            Assert.AreEqual(expectedId, id.GetInt32());
+        }
+
+        [Test]
+        public void GameObjectSerializationHandlesQuotesAndEscapes()
+        {
+            string tricky = "Quote \" and Backslash \\ and Newline\n and Unicode ☺";
+            GameObject go = Track(new GameObject(tricky));
+            string json = Serializer.JsonStringify(go);
+            using JsonDocument doc = JsonDocument.Parse(json);
+            Assert.AreEqual(tricky, doc.RootElement.GetProperty("name").GetString());
+        }
+
+        [Test]
+        public void ObjectTypedSerializationUsesRuntimeTypeConverter()
+        {
+            GameObject go = Track(new GameObject("ObjectTypedGO"));
+            int expectedId = go.GetInstanceID();
+            object goAsObject = go;
+            string json = Serializer.JsonStringify(goAsObject);
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.AreEqual("ObjectTypedGO", root.GetProperty("name").GetString());
+            StringAssert.Contains("UnityEngine.GameObject", root.GetProperty("type").GetString());
+            Assert.AreEqual(expectedId, root.GetProperty("instanceId").GetInt32());
+        }
+
+        [Test]
+        public void GameObjectSerializationPrettyPrintFormatsAndParses()
+        {
+            GameObject go = Track(new GameObject("Pretty ☃ Object ✓"));
+            int expectedId = go.GetInstanceID();
+            string json = Serializer.JsonStringify(go, pretty: true);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+            StringAssert.Contains("\n", json);
+
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.True(root.TryGetProperty("name", out JsonElement name));
+            Assert.AreEqual("Pretty ☃ Object ✓", name.GetString());
+            Assert.True(root.TryGetProperty("instanceId", out JsonElement id));
+            Assert.AreEqual(expectedId, id.GetInt32());
+        }
+
+        [Test]
+        public void GameObjectSerializationStableInstanceIdAcrossSerializations()
+        {
+            GameObject go = Track(new GameObject("StableId"));
+            int expectedId = go.GetInstanceID();
+            string j1 = Serializer.JsonStringify(go);
+            string j2 = Serializer.JsonStringify(go);
+
+            using JsonDocument d1 = JsonDocument.Parse(j1);
+            using JsonDocument d2 = JsonDocument.Parse(j2);
+            int id1 = d1.RootElement.GetProperty("instanceId").GetInt32();
+            int id2 = d2.RootElement.GetProperty("instanceId").GetInt32();
+            Assert.AreEqual(expectedId, id1);
+            Assert.AreEqual(id1, id2);
+        }
+
+        [Test]
+        public void GameObjectDeserializationIsNotSupported()
+        {
+            GameObject go = Track(new GameObject("NoReadSupport"));
+            string json = Serializer.JsonStringify(go);
+
+            // Our converter intentionally does not implement Read. Ensure this throws.
+            Assert.Throws<NotImplementedException>(() =>
+                Serializer.JsonDeserialize<GameObject>(json)
+            );
+        }
+
+        [UnityTest]
+        public System.Collections.IEnumerator GameObjectArraySerializationWorksWithNullAndDestroyed()
+        {
+            GameObject alive = Track(new GameObject("Alive"));
+            int aliveId = alive.GetInstanceID();
+            GameObject dead = Track(new GameObject("Dead"));
+            dead.Destroy();
+            yield return null; // ensure Unity nullification
+            Assert.IsTrue(dead == null);
+
+            GameObject[] data = { null, alive, dead };
+            string json = Serializer.JsonStringify(data);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.AreEqual(JsonValueKind.Array, root.ValueKind);
+            Assert.AreEqual(3, root.GetArrayLength());
+            Assert.AreEqual(JsonValueKind.Null, root[0].ValueKind);
+
+            JsonElement mid = root[1];
+            Assert.AreEqual(JsonValueKind.Object, mid.ValueKind);
+            Assert.AreEqual("Alive", mid.GetProperty("name").GetString());
+            Assert.AreEqual(aliveId, mid.GetProperty("instanceId").GetInt32());
+
+            Assert.AreEqual(JsonValueKind.Null, root[2].ValueKind);
+        }
+
+        [UnityTest]
+        public System.Collections.IEnumerator GameObjectDictionarySerializationWorksWithNullAndDestroyed()
+        {
+            GameObject alive = Track(new GameObject("Alive_Dict"));
+            int aliveId = alive.GetInstanceID();
+            GameObject dead = Track(new GameObject("Dead_Dict"));
+            dead.Destroy();
+            yield return null; // ensure Unity nullification
+            Assert.IsTrue(dead == null);
+
+            Dictionary<string, GameObject> dict = new()
+            {
+                ["none"] = null,
+                ["alive"] = alive,
+                ["dead"] = dead,
+            };
+
+            string json = Serializer.JsonStringify(dict);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.AreEqual(JsonValueKind.Object, root.ValueKind);
+
+            Assert.True(root.TryGetProperty("none", out JsonElement none));
+            Assert.AreEqual(JsonValueKind.Null, none.ValueKind);
+
+            Assert.True(root.TryGetProperty("alive", out JsonElement aliveEl));
+            Assert.AreEqual("Alive_Dict", aliveEl.GetProperty("name").GetString());
+            Assert.AreEqual(aliveId, aliveEl.GetProperty("instanceId").GetInt32());
+
+            Assert.True(root.TryGetProperty("dead", out JsonElement deadEl));
+            Assert.AreEqual(JsonValueKind.Null, deadEl.ValueKind);
+        }
+
+        private sealed class GoHolder
+        {
+            public GameObject Go { get; set; }
+        }
+
+        private sealed class GoFieldHolder
+        {
+            public GameObject go;
+        }
+
+        [Test]
+        public void NestedObjectSerializationWithGameObjectProperty()
+        {
+            GameObject go = Track(new GameObject("Nested"));
+            int expectedId = go.GetInstanceID();
+            GoHolder holder = new() { Go = go };
+            string json = Serializer.JsonStringify(holder);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.True(root.TryGetProperty("Go", out JsonElement goEl));
+            Assert.AreEqual("Nested", goEl.GetProperty("name").GetString());
+            Assert.AreEqual(expectedId, goEl.GetProperty("instanceId").GetInt32());
+        }
+
+        [Test]
+        public void NestedObjectSerializationWithGameObjectField()
+        {
+            GameObject go = Track(new GameObject("NestedField"));
+            int expectedId = go.GetInstanceID();
+            GoFieldHolder holder = new() { go = go };
+            string json = Serializer.JsonStringify(holder);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.True(root.TryGetProperty("go", out JsonElement goEl));
+            Assert.AreEqual("NestedField", goEl.GetProperty("name").GetString());
+            Assert.AreEqual(expectedId, goEl.GetProperty("instanceId").GetInt32());
+        }
+
+        [Test]
+        public void FastSerializerProducesValidGameObjectJson()
+        {
+            GameObject go = Track(new GameObject("FastGO"));
+            int expectedId = go.GetInstanceID();
+            byte[] bytes = Serializer.JsonSerializeFast(go);
+            Assert.NotNull(bytes);
+            string json = Encoding.UTF8.GetString(bytes);
+            Assert.IsFalse(string.IsNullOrWhiteSpace(json), json);
+
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.AreEqual("FastGO", root.GetProperty("name").GetString());
+            Assert.AreEqual(expectedId, root.GetProperty("instanceId").GetInt32());
+        }
+
+        [Test]
+        public void SerializeIntoCallerBufferProducesValidGameObjectJson()
+        {
+            GameObject go = Track(new GameObject("BufferedGO"));
+            int expectedId = go.GetInstanceID();
+            byte[] buffer = null;
+            int len = Serializer.JsonSerialize(
+                go,
+                SerializerEncoding.GetNormalJsonOptions(),
+                ref buffer
+            );
+            Assert.Greater(len, 0);
+            Assert.NotNull(buffer);
+
+            string json = Encoding.UTF8.GetString(buffer, 0, len);
+            using JsonDocument doc = JsonDocument.Parse(json);
+            JsonElement root = doc.RootElement;
+            Assert.AreEqual("BufferedGO", root.GetProperty("name").GetString());
+            Assert.AreEqual(expectedId, root.GetProperty("instanceId").GetInt32());
+        }
+    }
+}

package/Tests/Runtime/Serialization/UnityEngineObjectJsonTests.cs.meta

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

package/Tests/Runtime/TestUtils/CommonTestBase.cs

@@ -6,6 +6,7 @@ namespace WallstopStudios.UnityHelpers.Tests.TestUtils
     using System.Threading.Tasks;
     using NUnit.Framework;
     using UnityEngine;
+    using UnityEngine.SceneManagement;
     using UnityEngine.TestTools;
     using Object = UnityEngine.Object;
 
@@ -15,6 +16,17 @@ namespace WallstopStudios.UnityHelpers.Tests.TestUtils
     /// </summary>
     public abstract class CommonTestBase
     {
+        /// <summary>
+        /// Ensures ReflexSettings singleton is present when the Reflex package is installed so tests do not hit assertions.
+        /// </summary>
+        [SetUp]
+        public virtual void BaseSetUp()
+        {
+#if REFLEX_PRESENT
+            ReflexTestSupport.EnsureReflexSettings();
+#endif
+        }
+
         // Per-test tracked UnityEngine.Objects
         protected readonly List<Object> _trackedObjects = new();
 
@@ -72,6 +84,93 @@ namespace WallstopStudios.UnityHelpers.Tests.TestUtils
             return producer;
         }
 
+        /// <summary>
+        /// Creates a temporary scene that is automatically unloaded during teardown.
+        /// </summary>
+        /// <param name="name">Scene name.</param>
+        /// <param name="setActive">Whether to set the scene as active immediately.</param>
+        protected Scene CreateTempScene(string name, bool setActive = true)
+        {
+            Scene previousActive = SceneManager.GetActiveScene();
+            Scene scene = SceneManager.CreateScene(name);
+
+            if (setActive)
+            {
+                SceneManager.SetActiveScene(scene);
+            }
+
+            TrackAsyncDisposal(async () =>
+            {
+                if (!scene.IsValid())
+                {
+                    return;
+                }
+
+                Scene currentActive = SceneManager.GetActiveScene();
+                if (currentActive == scene)
+                {
+                    bool restored = false;
+                    if (
+                        previousActive.IsValid()
+                        && previousActive.isLoaded
+                        && previousActive != scene
+                    )
+                    {
+                        SceneManager.SetActiveScene(previousActive);
+                        restored = true;
+                    }
+                    else
+                    {
+                        int count = SceneManager.sceneCount;
+                        for (int i = 0; i < count; i++)
+                        {
+                            Scene candidate = SceneManager.GetSceneAt(i);
+                            if (!candidate.IsValid() || !candidate.isLoaded || candidate == scene)
+                            {
+                                continue;
+                            }
+
+                            SceneManager.SetActiveScene(candidate);
+                            restored = true;
+                            break;
+                        }
+                    }
+
+                    if (!restored)
+                    {
+                        Scene fallback = SceneManager.CreateScene("RuntimeTestFallbackScene");
+                        SceneManager.SetActiveScene(fallback);
+                        TrackAsyncDisposal(async () =>
+                        {
+                            AsyncOperation unloadFallback = SceneManager.UnloadSceneAsync(fallback);
+                            if (unloadFallback == null)
+                            {
+                                return;
+                            }
+                            while (!unloadFallback.isDone)
+                            {
+                                await Task.Yield();
+                            }
+                            return;
+                        });
+                    }
+                }
+
+                AsyncOperation unload = SceneManager.UnloadSceneAsync(scene);
+                if (unload == null)
+                {
+                    return;
+                }
+
+                while (!unload.isDone)
+                {
+                    await Task.Yield();
+                }
+            });
+
+            return scene;
+        }
+
         /// <summary>
         /// NUnit teardown for non-Unity tests and EditMode cleanup.
         /// Uses DestroyImmediate when not playing and disposes disposables.

package/Tests/Runtime/TestUtils/ReflexTestSupport.cs

@@ -0,0 +1,111 @@
+#if REFLEX_PRESENT
+namespace WallstopStudios.UnityHelpers.Tests.TestUtils
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using UnityEngine;
+
+    public static class ReflexTestSupport
+    {
+        private const string ReflexSettingsTypeName = "Reflex.Configuration.ReflexSettings";
+        private const string InstanceFieldName = "_instance";
+        private const string LogLevelBackingFieldName = "<LogLevel>k__BackingField";
+        private const string ProjectScopesBackingFieldName = "<ProjectScopes>k__BackingField";
+        private const string LogLevelTypeName = "Reflex.Logging.LogLevel";
+        private const string ProjectScopeTypeName = "Reflex.Core.ProjectScope";
+
+        private static bool _initialized;
+
+        public static void EnsureReflexSettings()
+        {
+            if (_initialized)
+            {
+                return;
+            }
+
+            Type settingsType = FindType(ReflexSettingsTypeName);
+            if (settingsType == null)
+            {
+                return;
+            }
+
+            FieldInfo instanceField = settingsType.GetField(
+                InstanceFieldName,
+                BindingFlags.NonPublic | BindingFlags.Static
+            );
+            if (instanceField == null)
+            {
+                return;
+            }
+
+            object currentInstance = instanceField.GetValue(null);
+            if (currentInstance == null)
+            {
+                ScriptableObject settings = ScriptableObject.CreateInstance(settingsType);
+                SetInstanceField(
+                    settingsType,
+                    settings,
+                    LogLevelBackingFieldName,
+                    GetLogLevelInfo()
+                );
+                SetInstanceField(
+                    settingsType,
+                    settings,
+                    ProjectScopesBackingFieldName,
+                    CreateEmptyProjectScopesList()
+                );
+                instanceField.SetValue(null, settings);
+            }
+
+            _initialized = true;
+        }
+
+        private static void SetInstanceField(
+            Type declaringType,
+            object instance,
+            string fieldName,
+            object value
+        )
+        {
+            FieldInfo field = declaringType.GetField(
+                fieldName,
+                BindingFlags.Instance | BindingFlags.NonPublic
+            );
+            field?.SetValue(instance, value);
+        }
+
+        private static object GetLogLevelInfo()
+        {
+            Type logLevelType = FindType(LogLevelTypeName);
+            if (logLevelType == null)
+            {
+                return null;
+            }
+
+            return Enum.Parse(logLevelType, "Info", ignoreCase: true);
+        }
+
+        private static object CreateEmptyProjectScopesList()
+        {
+            Type projectScopeType = FindType(ProjectScopeTypeName);
+            if (projectScopeType == null)
+            {
+                return null;
+            }
+
+            Type listType = typeof(List<>).MakeGenericType(projectScopeType);
+            return Activator.CreateInstance(listType);
+        }
+
+        private static Type FindType(string fullName)
+        {
+            return AppDomain
+                .CurrentDomain.GetAssemblies()
+                .Select(assembly => assembly.GetType(fullName))
+                .FirstOrDefault(type => type != null);
+        }
+    }
+}
+#endif

package/Tests/Runtime/TestUtils/ReflexTestSupport.cs.meta

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

package/Tests/Runtime/Utils/CoroutineHandlerTests.cs

@@ -20,7 +20,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
             Track(instance.gameObject);
 
             Assert.IsTrue(CoroutineHandler.HasInstance);
-            Assert.IsNotNull(instance);
+            Assert.IsTrue(instance != null);
             yield return null;
         }
 

package/Tests/Runtime/Utils/LZMAComprehensiveTests.cs

@@ -11,7 +11,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
         public void RoundtripVariousSizes()
         {
             Random random = new(12345);
-            int[] sizes = new[] { 0, 1, 3, 5, 32, 64, 257, 1024, 4096 };
+            int[] sizes = { 0, 1, 3, 5, 32, 64, 257, 1024, 4096 };
             foreach (int length in sizes)
             {
                 byte[] data = new byte[length];

package/Tests/Runtime/Utils/LZMATests.cs

@@ -24,7 +24,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
         [Test]
         public void DecompressingGarbageThrows()
         {
-            byte[] garbage = new byte[] { 1, 2, 3, 4, 5 };
+            byte[] garbage = { 1, 2, 3, 4, 5 };
             Assert.Throws<Exception>(() => LZMA.Decompress(garbage));
         }
     }

package/Tests/Runtime/Utils/MatchColliderToSpriteTests.cs

@@ -24,12 +24,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
             );
 
             // Define a physics shape for the sprite (a simple rectangle)
-            Vector2[] physicsShape = new[]
+            Vector2[] physicsShape =
             {
-                new Vector2(-0.5f, -0.5f),
-                new Vector2(-0.5f, 0.5f),
-                new Vector2(0.5f, 0.5f),
-                new Vector2(0.5f, -0.5f),
+                new(-0.5f, -0.5f),
+                new(-0.5f, 0.5f),
+                new(0.5f, 0.5f),
+                new(0.5f, -0.5f),
             };
             _testSprite.OverridePhysicsShape(new[] { physicsShape });
         }