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

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

@@ -33,20 +33,19 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
 
             AttributeMetadataCache cache = CreateScriptableObject<AttributeMetadataCache>();
 #if UNITY_EDITOR
-            AttributeMetadataCache.RelationalTypeMetadata relationalMetadata =
-                new AttributeMetadataCache.RelationalTypeMetadata(
-                    typeof(Consumer).AssemblyQualifiedName,
-                    new[]
-                    {
-                        new AttributeMetadataCache.RelationalFieldMetadata(
-                            "_spriteRenderer",
-                            AttributeMetadataCache.RelationalAttributeKind.Sibling,
-                            AttributeMetadataCache.FieldKind.Single,
-                            typeof(SpriteRenderer).AssemblyQualifiedName,
-                            false
-                        ),
-                    }
-                );
+            AttributeMetadataCache.RelationalTypeMetadata relationalMetadata = new(
+                typeof(Consumer).AssemblyQualifiedName,
+                new[]
+                {
+                    new AttributeMetadataCache.RelationalFieldMetadata(
+                        "_spriteRenderer",
+                        AttributeMetadataCache.RelationalAttributeKind.Sibling,
+                        AttributeMetadataCache.FieldKind.Single,
+                        typeof(SpriteRenderer).AssemblyQualifiedName,
+                        false
+                    ),
+                }
+            );
 
             cache.SetMetadata(
                 System.Array.Empty<string>(),
@@ -57,13 +56,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
             yield return null;
 #endif
 
-            RelationalComponentAssigner assigner = new RelationalComponentAssigner(cache);
-            RelationalComponentSceneInitializer initializer =
-                new RelationalComponentSceneInitializer(
-                    assigner,
-                    cache,
-                    RelationalSceneAssignmentOptions.Default
-                );
+            RelationalComponentAssigner assigner = new(cache);
+            RelationalComponentSceneInitializer initializer = new(
+                assigner,
+                cache,
+                RelationalSceneAssignmentOptions.Default
+            );
 
             initializer.Initialize();
 

package/Tests/Editor/PersistentDirectorySettingsTests.cs

@@ -2,7 +2,6 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor
 {
 #if UNITY_EDITOR
     using NUnit.Framework;
-    using UnityEditor;
     using UnityEngine;
     using WallstopStudios.UnityHelpers.Editor;
 

package/Tests/Editor/Sprites/AnimationCopierFilterTests.cs

@@ -1,7 +1,6 @@
 namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
 {
 #if UNITY_EDITOR
-    using System;
     using System.Collections.Generic;
     using System.Linq;
     using NUnit.Framework;

package/Tests/Editor/Sprites/AnimationViewerWindowTests.cs

@@ -12,8 +12,8 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Sprites
         public void EditorLayerDataBuildsSpriteListFromClip()
         {
             // Build a test clip with 3 sprite keyframes
-            AnimationClip clip = new AnimationClip();
-            Texture2D tex = new Texture2D(2, 2);
+            AnimationClip clip = new();
+            Texture2D tex = new(2, 2);
             Sprite s1 = Sprite.Create(tex, new Rect(0, 0, 1, 1), Vector2.zero);
             Sprite s2 = Sprite.Create(tex, new Rect(0, 0, 1, 1), Vector2.zero);
             Sprite s3 = Sprite.Create(tex, new Rect(0, 0, 1, 1), Vector2.zero);

package/Tests/Editor/Tools/ImageBlurToolTests.cs

@@ -27,7 +27,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Tools
         [Test]
         public void BlurredTextureMatchesInputDimensions()
         {
-            Texture2D tex = new Texture2D(8, 8, TextureFormat.RGBA32, false);
+            Texture2D tex = new(8, 8, TextureFormat.RGBA32, false);
             for (int y = 0; y < tex.height; y++)
             {
                 for (int x = 0; x < tex.width; x++)

package/Tests/Editor/Utils/CommonTestBase.cs

@@ -3,6 +3,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Utils
     using System;
     using System.Collections;
     using System.Collections.Generic;
+    using System.Reflection;
     using NUnit.Framework;
     using UnityEngine;
     using UnityEngine.SceneManagement;
@@ -19,6 +20,22 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Utils
     /// </summary>
     public abstract class CommonTestBase
     {
+        [SetUp]
+        public virtual void BaseSetUp()
+        {
+#if REFLEX_PRESENT
+            Type supportType = Type.GetType(
+                "WallstopStudios.UnityHelpers.Tests.TestUtils.ReflexTestSupport, WallstopStudios.UnityHelpers.Tests.Runtime",
+                throwOnError: false
+            );
+            MethodInfo ensureMethod = supportType?.GetMethod(
+                "EnsureReflexSettings",
+                BindingFlags.Public | BindingFlags.Static
+            );
+            ensureMethod?.Invoke(null, null);
+#endif
+        }
+
         protected readonly List<Object> _trackedObjects = new();
         protected readonly List<IDisposable> _trackedDisposables = new();
         protected readonly List<Scene> _trackedScenes = new();

package/Tests/Editor/Utils/ScriptableObjectSingletonCreatorTests.cs

@@ -79,7 +79,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Editor.Utils
             string occupiedPath = targetFolder + "/Duplicate.asset";
             if (AssetDatabase.LoadAssetAtPath<Object>(occupiedPath) == null)
             {
-                TextAsset ta = new TextAsset("occupied");
+                TextAsset ta = new("occupied");
                 AssetDatabase.CreateAsset(ta, occupiedPath);
             }
 

package/Tests/Runtime/Extensions/AsyncOperationExtensionsTests.cs

@@ -281,6 +281,91 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             Assert.IsTrue(exceptionThrown);
         }
 
+        [UnityTest]
+        public IEnumerator TaskTupleAsCoroutineCompletesSuccessfully()
+        {
+            Task<(int, string)> task = CreateDelayedTask(() => (7, "lucky"));
+
+            int first = 0;
+            string second = null;
+            yield return task.AsCoroutine(
+                (value, label) =>
+                {
+                    first = value;
+                    second = label;
+                }
+            );
+
+            Assert.AreEqual(7, first);
+            Assert.AreEqual("lucky", second);
+        }
+
+        [UnityTest]
+        public IEnumerator TaskTupleAsCoroutineWorksWithoutCallback()
+        {
+            Task<(int, string)> task = CreateDelayedTask(() => (5, "five"));
+
+            yield return task.AsCoroutine();
+
+            Assert.AreEqual((5, "five"), task.Result);
+        }
+
+        [UnityTest]
+        public IEnumerator TaskTupleAsCoroutineThrowsOnFaultedTask()
+        {
+            Task<(int, string)> task = CreateFaultedTask<(int, string)>();
+
+            bool exceptionThrown = false;
+            IEnumerator coroutine = task.AsCoroutine((_, _) => { });
+
+            while (true)
+            {
+                try
+                {
+                    if (!coroutine.MoveNext())
+                    {
+                        break;
+                    }
+                }
+                catch (InvalidOperationException)
+                {
+                    exceptionThrown = true;
+                    break;
+                }
+                catch (AggregateException e)
+                {
+                    exceptionThrown = e.Flatten()
+                        .InnerExceptions.Any(inner => inner is InvalidOperationException);
+                    break;
+                }
+                yield return null;
+            }
+
+            Assert.IsTrue(exceptionThrown);
+        }
+
+        [UnityTest]
+        public IEnumerator TaskTripleAsCoroutineCompletesSuccessfully()
+        {
+            Task<(int, string, bool)> task = CreateDelayedTask(() => (1, "one", true));
+
+            int first = 0;
+            string second = null;
+            bool third = false;
+            yield return task.AsCoroutine(
+                (value, label, flag) =>
+                {
+                    first = value;
+                    second = label;
+                    third = flag;
+                }
+            );
+
+            Assert.AreEqual(1, first);
+            Assert.AreEqual("one", second);
+            Assert.IsTrue(third);
+        }
+
         // Tests for ValueTask.AsCoroutine()
         [UnityTest]
         public IEnumerator ValueTaskAsCoroutineCompletesSuccessfully()
@@ -400,6 +485,100 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             Assert.IsTrue(exceptionThrown);
         }
 
+        [UnityTest]
+        public IEnumerator ValueTaskTupleAsCoroutineCompletesSuccessfully()
+        {
+            ValueTask<(int, string)> task = new(CreateDelayedTask(() => (2, "two")));
+
+            int first = 0;
+            string second = null;
+            yield return task.AsCoroutine(
+                (value, label) =>
+                {
+                    first = value;
+                    second = label;
+                }
+            );
+
+            Assert.AreEqual(2, first);
+            Assert.AreEqual("two", second);
+        }
+
+        [UnityTest]
+        public IEnumerator ValueTaskTupleAsCoroutineCompletesImmediatelyWhenAlreadyDone()
+        {
+            ValueTask<(int, string)> task = new((3, "three"));
+
+            int first = 0;
+            string second = null;
+            yield return task.AsCoroutine(
+                (value, label) =>
+                {
+                    first = value;
+                    second = label;
+                }
+            );
+
+            Assert.AreEqual(3, first);
+            Assert.AreEqual("three", second);
+        }
+
+        [UnityTest]
+        public IEnumerator ValueTaskTupleAsCoroutineThrowsOnFaultedTask()
+        {
+            ValueTask<(int, string)> task = new(CreateFaultedTask<(int, string)>());
+
+            bool exceptionThrown = false;
+            IEnumerator coroutine = task.AsCoroutine((_, _) => { });
+
+            while (true)
+            {
+                try
+                {
+                    if (!coroutine.MoveNext())
+                    {
+                        break;
+                    }
+                }
+                catch (InvalidOperationException)
+                {
+                    exceptionThrown = true;
+                    break;
+                }
+                catch (AggregateException e)
+                {
+                    exceptionThrown = e.Flatten()
+                        .InnerExceptions.Any(inner => inner is InvalidOperationException);
+                    break;
+                }
+                yield return null;
+            }
+
+            Assert.IsTrue(exceptionThrown);
+        }
+
+        [UnityTest]
+        public IEnumerator ValueTaskTripleAsCoroutineCompletesSuccessfully()
+        {
+            ValueTask<(int, string, bool)> task = new(CreateDelayedTask(() => (4, "four", true)));
+
+            int first = 0;
+            string second = null;
+            bool third = false;
+            yield return task.AsCoroutine(
+                (value, label, flag) =>
+                {
+                    first = value;
+                    second = label;
+                    third = flag;
+                }
+            );
+
+            Assert.AreEqual(4, first);
+            Assert.AreEqual("four", second);
+            Assert.IsTrue(third);
+        }
+
         // Tests for IEnumerator.AsTask()
         [UnityTest]
         public IEnumerator IEnumeratorAsTaskCompletesSuccessfully()

package/Tests/Runtime/Extensions/RandomExtensionTests.cs

@@ -445,6 +445,61 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             }
         }
 
+        [Test]
+        public void NextWeightedElement()
+        {
+            List<string> items = new() { "rare", "common" };
+            List<float> weights = new() { 1f, 99f };
+            HashSet<string> seen = new();
+            int commonCount = 0;
+            int rareCount = 0;
+            for (int i = 0; i < 1000; ++i)
+            {
+                string result = PRNG.Instance.NextWeightedElement(items, weights);
+                seen.Add(result);
+                if (result == "common")
+                {
+                    commonCount++;
+                }
+                else if (result == "rare")
+                {
+                    rareCount++;
+                }
+            }
+
+            Assert.AreEqual(2, seen.Count);
+            Assert.Greater(commonCount, rareCount);
+            Assert.Greater(commonCount, 900);
+        }
+
+        [Test]
+        public void NextWeightedElementThrowsOnNullItems()
+        {
+            List<float> weights = new() { 1f };
+            Assert.Throws<ArgumentNullException>(() =>
+                PRNG.Instance.NextWeightedElement<string>(null, weights)
+            );
+        }
+
+        [Test]
+        public void NextWeightedElementThrowsOnNullWeights()
+        {
+            List<string> items = new() { "item" };
+            Assert.Throws<ArgumentNullException>(() =>
+                PRNG.Instance.NextWeightedElement(items, (IReadOnlyList<float>)null)
+            );
+        }
+
+        [Test]
+        public void NextWeightedElementThrowsOnMismatchedCounts()
+        {
+            List<string> items = new() { "item" };
+            List<float> weights = new() { 1f, 2f };
+            Assert.Throws<ArgumentException>(() =>
+                PRNG.Instance.NextWeightedElement(items, weights)
+            );
+        }
+
         [Test]
         public void NextWeighted()
         {