com.wallstop-studios.unity-helpers 2.0.0-rc43 → 2.0.0-rc45

package/Tests/Runtime/Helper/ReflectionHelperTests.cs

@@ -1,30 +1,31 @@
-namespace UnityHelpers.Tests.Tests.Runtime.Helper
+namespace UnityHelpers.Tests.Helper
 {
     using System;
     using System.Collections;
     using System.Collections.Generic;
-    using Core.Helper;
+    using System.Reflection;
     using NUnit.Framework;
+    using UnityHelpers.Core.Helper;
+    using UnityHelpers.Core.Random;
 
     public struct TestStruct
     {
+        public static int staticIntValue;
         public int intValue;
     }
 
     public sealed class TestClass
     {
+        public static int staticIntValue;
         public int intValue;
     }
 
     public sealed class ReflectionHelperTests
     {
-        internal const int NumTries = 1_000;
+        private const int NumTries = 1_000;
 
-        private readonly Random _random = new();
-
-        // TODO: Test on static fields
         [Test]
-        public void GetFieldGetterClass()
+        public void GetFieldGetterClassMemberField()
         {
             TestClass testClass = new();
             Func<object, object> classGetter = ReflectionHelpers.GetFieldGetter(
@@ -33,14 +34,59 @@
             Assert.AreEqual(testClass.intValue, classGetter(testClass));
             for (int i = 0; i < NumTries; ++i)
             {
-                testClass.intValue = _random.Next(int.MinValue, int.MaxValue);
+                testClass.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
                 Assert.AreEqual(testClass.intValue, classGetter(testClass));
             }
         }
 
-        // TODO: Test on static fields
         [Test]
-        public void GetFieldGetterStruct()
+        public void GetFieldGetterClassStaticField()
+        {
+            TestClass testClass = new();
+            Func<object, object> classGetter = ReflectionHelpers.GetFieldGetter(
+                typeof(TestClass).GetField(
+                    nameof(TestClass.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            Assert.AreEqual(TestClass.staticIntValue, classGetter(testClass));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                TestClass.staticIntValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(TestClass.staticIntValue, classGetter(testClass));
+            }
+        }
+
+        [Test]
+        public void GetStaticFieldGetterThrowsOnNonStaticField()
+        {
+            Assert.Throws<ArgumentException>(
+                () =>
+                    ReflectionHelpers.GetStaticFieldGetter(
+                        typeof(TestClass).GetField(nameof(TestClass.intValue))
+                    )
+            );
+        }
+
+        [Test]
+        public void GetStaticFieldGetterClassStaticField()
+        {
+            Func<object> classGetter = ReflectionHelpers.GetStaticFieldGetter(
+                typeof(TestClass).GetField(
+                    nameof(TestClass.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            Assert.AreEqual(TestClass.staticIntValue, classGetter());
+            for (int i = 0; i < NumTries; ++i)
+            {
+                TestClass.staticIntValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(TestClass.staticIntValue, classGetter());
+            }
+        }
+
+        [Test]
+        public void GetFieldGetterStructMemberField()
         {
             TestStruct testStruct = new();
             Func<object, object> structGetter = ReflectionHelpers.GetFieldGetter(
@@ -49,14 +95,48 @@
             Assert.AreEqual(testStruct.intValue, structGetter(testStruct));
             for (int i = 0; i < NumTries; ++i)
             {
-                testStruct.intValue = _random.Next(int.MinValue, int.MaxValue);
+                testStruct.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
                 Assert.AreEqual(testStruct.intValue, structGetter(testStruct));
             }
         }
 
-        // TODO: Test on static fields
         [Test]
-        public void GetFieldSetterClass()
+        public void GetFieldGetterStructStaticField()
+        {
+            TestStruct testStruct = new();
+            Func<object, object> structGetter = ReflectionHelpers.GetFieldGetter(
+                typeof(TestStruct).GetField(
+                    nameof(TestStruct.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            Assert.AreEqual(TestStruct.staticIntValue, structGetter(testStruct));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                TestStruct.staticIntValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(TestStruct.staticIntValue, structGetter(testStruct));
+            }
+        }
+
+        [Test]
+        public void GetStaticFieldGetterStructStaticField()
+        {
+            Func<object> structGetter = ReflectionHelpers.GetStaticFieldGetter(
+                typeof(TestStruct).GetField(
+                    nameof(TestStruct.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            Assert.AreEqual(TestStruct.staticIntValue, structGetter());
+            for (int i = 0; i < NumTries; ++i)
+            {
+                TestStruct.staticIntValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(TestStruct.staticIntValue, structGetter());
+            }
+        }
+
+        [Test]
+        public void GetFieldSetterClassMemberField()
         {
             TestClass testClass = new();
             Action<object, object> structSetter = ReflectionHelpers.GetFieldSetter(
@@ -64,15 +144,60 @@
             );
             for (int i = 0; i < NumTries; ++i)
             {
-                int expected = _random.Next(int.MinValue, int.MaxValue);
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
                 structSetter(testClass, expected);
                 Assert.AreEqual(expected, testClass.intValue);
             }
         }
 
-        // TODO: Test on static fields
         [Test]
-        public void GetFieldSetterStruct()
+        public void GetFieldSetterClassStaticField()
+        {
+            TestClass testClass = new();
+            Action<object, object> structSetter = ReflectionHelpers.GetFieldSetter(
+                typeof(TestClass).GetField(
+                    nameof(TestClass.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(testClass, expected);
+                Assert.AreEqual(expected, TestClass.staticIntValue);
+            }
+        }
+
+        [Test]
+        public void GetStaticFieldSetterThrowsOnNonStaticField()
+        {
+            Assert.Throws<ArgumentException>(
+                () =>
+                    ReflectionHelpers.GetStaticFieldSetter(
+                        typeof(TestClass).GetField(nameof(TestClass.intValue))
+                    )
+            );
+        }
+
+        [Test]
+        public void GetStaticFieldSetterClassStaticField()
+        {
+            Action<object> structSetter = ReflectionHelpers.GetStaticFieldSetter(
+                typeof(TestClass).GetField(
+                    nameof(TestClass.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(expected);
+                Assert.AreEqual(expected, TestClass.staticIntValue);
+            }
+        }
+
+        [Test]
+        public void GetFieldSetterStructMemberField()
         {
             // Need boxing
             object testStruct = new TestStruct();
@@ -81,15 +206,50 @@
             );
             for (int i = 0; i < NumTries; ++i)
             {
-                int expected = _random.Next(int.MinValue, int.MaxValue);
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
                 structSetter(testStruct, expected);
                 Assert.AreEqual(expected, ((TestStruct)testStruct).intValue);
             }
         }
 
-        // TODO: Test on static fields
         [Test]
-        public void GetFieldSetterClassGeneric()
+        public void GetFieldSetterStructStaticField()
+        {
+            // Need boxing
+            object testStruct = new TestStruct();
+            Action<object, object> structSetter = ReflectionHelpers.GetFieldSetter(
+                typeof(TestStruct).GetField(
+                    nameof(TestStruct.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(testStruct, expected);
+                Assert.AreEqual(expected, TestStruct.staticIntValue);
+            }
+        }
+
+        [Test]
+        public void GetStaticFieldSetterStructStaticField()
+        {
+            Action<object> structSetter = ReflectionHelpers.GetStaticFieldSetter(
+                typeof(TestStruct).GetField(
+                    nameof(TestStruct.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(expected);
+                Assert.AreEqual(expected, TestStruct.staticIntValue);
+            }
+        }
+
+        [Test]
+        public void GetFieldSetterClassGenericMemberField()
         {
             TestClass testClass = new();
             FieldSetter<TestClass, int> classSetter = ReflectionHelpers.GetFieldSetter<
@@ -98,15 +258,63 @@
             >(typeof(TestClass).GetField(nameof(TestClass.intValue)));
             for (int i = 0; i < NumTries; ++i)
             {
-                int expected = _random.Next(int.MinValue, int.MaxValue);
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
                 classSetter(ref testClass, expected);
                 Assert.AreEqual(expected, testClass.intValue);
             }
         }
 
-        // TODO: Test on static fields
         [Test]
-        public void GetFieldSetterStructGeneric()
+        public void GetFieldSetterClassGenericStaticField()
+        {
+            TestClass testClass = new();
+            FieldSetter<TestClass, int> classSetter = ReflectionHelpers.GetFieldSetter<
+                TestClass,
+                int
+            >(
+                typeof(TestClass).GetField(
+                    nameof(TestClass.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                classSetter(ref testClass, expected);
+                Assert.AreEqual(expected, TestClass.staticIntValue);
+            }
+        }
+
+        [Test]
+        public void GetStaticFieldSetterGenericThrowsOnNonStaticField()
+        {
+            Assert.Throws<ArgumentException>(
+                () =>
+                    ReflectionHelpers.GetStaticFieldSetter<int>(
+                        typeof(TestClass).GetField(nameof(TestClass.intValue))
+                    )
+            );
+        }
+
+        [Test]
+        public void GetStaticFieldSetterClassGenericStaticField()
+        {
+            Action<int> classSetter = ReflectionHelpers.GetStaticFieldSetter<int>(
+                typeof(TestClass).GetField(
+                    nameof(TestClass.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                classSetter(expected);
+                Assert.AreEqual(expected, TestClass.staticIntValue);
+            }
+        }
+
+        [Test]
+        public void GetFieldSetterStructGenericMemberField()
         {
             TestStruct testStruct = new();
             FieldSetter<TestStruct, int> structSetter = ReflectionHelpers.GetFieldSetter<
@@ -115,15 +323,52 @@
             >(typeof(TestStruct).GetField(nameof(TestStruct.intValue)));
             for (int i = 0; i < NumTries; ++i)
             {
-                int expected = _random.Next(int.MinValue, int.MaxValue);
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
                 structSetter(ref testStruct, expected);
                 Assert.AreEqual(expected, testStruct.intValue);
             }
         }
 
-        // TODO: Test on static fields
         [Test]
-        public void GetFieldGetterClassGeneric()
+        public void GetFieldSetterStructGenericStaticField()
+        {
+            TestStruct testStruct = new();
+            FieldSetter<TestStruct, int> structSetter = ReflectionHelpers.GetFieldSetter<
+                TestStruct,
+                int
+            >(
+                typeof(TestStruct).GetField(
+                    nameof(TestStruct.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(ref testStruct, expected);
+                Assert.AreEqual(expected, TestStruct.staticIntValue);
+            }
+        }
+
+        [Test]
+        public void GetStaticFieldSetterStructGenericStaticField()
+        {
+            Action<int> structSetter = ReflectionHelpers.GetStaticFieldSetter<int>(
+                typeof(TestStruct).GetField(
+                    nameof(TestStruct.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(expected);
+                Assert.AreEqual(expected, TestStruct.staticIntValue);
+            }
+        }
+
+        [Test]
+        public void GetFieldGetterClassGenericMemberField()
         {
             TestClass testClass = new();
             Func<TestClass, int> classGetter = ReflectionHelpers.GetFieldGetter<TestClass, int>(
@@ -131,14 +376,57 @@
             );
             for (int i = 0; i < NumTries; ++i)
             {
-                testClass.intValue = _random.Next(int.MinValue, int.MaxValue);
+                testClass.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
                 Assert.AreEqual(testClass.intValue, classGetter(testClass));
             }
         }
 
-        // TODO: Test on static fields
         [Test]
-        public void GetFieldGetterStructGeneric()
+        public void GetFieldGetterClassGenericStaticField()
+        {
+            TestClass testClass = new();
+            Func<TestClass, int> classGetter = ReflectionHelpers.GetFieldGetter<TestClass, int>(
+                typeof(TestClass).GetField(
+                    nameof(TestClass.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                TestClass.staticIntValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(TestClass.staticIntValue, classGetter(testClass));
+            }
+        }
+
+        [Test]
+        public void GetStaticFieldGetterGenericThrowsOnNonStaticField()
+        {
+            Assert.Throws<ArgumentException>(
+                () =>
+                    ReflectionHelpers.GetStaticFieldGetter<int>(
+                        typeof(TestClass).GetField(nameof(TestClass.intValue))
+                    )
+            );
+        }
+
+        [Test]
+        public void GetStaticFieldGetterClassGenericStaticField()
+        {
+            Func<int> classGetter = ReflectionHelpers.GetStaticFieldGetter<int>(
+                typeof(TestClass).GetField(
+                    nameof(TestClass.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                TestClass.staticIntValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(TestClass.staticIntValue, classGetter());
+            }
+        }
+
+        [Test]
+        public void GetFieldGetterStructGenericMemberField()
         {
             TestStruct testStruct = new();
             Func<TestStruct, int> structSetter = ReflectionHelpers.GetFieldGetter<TestStruct, int>(
@@ -146,17 +434,50 @@
             );
             for (int i = 0; i < NumTries; ++i)
             {
-                testStruct.intValue = _random.Next(int.MinValue, int.MaxValue);
+                testStruct.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
                 Assert.AreEqual(testStruct.intValue, structSetter(testStruct));
             }
         }
 
+        [Test]
+        public void GetFieldGetterStructGenericStaticField()
+        {
+            TestStruct testStruct = new();
+            Func<TestStruct, int> structSetter = ReflectionHelpers.GetFieldGetter<TestStruct, int>(
+                typeof(TestStruct).GetField(
+                    nameof(TestStruct.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                TestStruct.staticIntValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(TestStruct.staticIntValue, structSetter(testStruct));
+            }
+        }
+
+        [Test]
+        public void GetStaticFieldGetterStructGenericStaticField()
+        {
+            Func<int> structSetter = ReflectionHelpers.GetStaticFieldGetter<int>(
+                typeof(TestStruct).GetField(
+                    nameof(TestStruct.staticIntValue),
+                    BindingFlags.Static | BindingFlags.Public
+                )
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                TestStruct.staticIntValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(TestStruct.staticIntValue, structSetter());
+            }
+        }
+
         [Test]
         public void ArrayCreator()
         {
             for (int i = 0; i < NumTries; ++i)
             {
-                int count = _random.Next(1_000);
+                int count = PRNG.Instance.Next(1_000);
                 Array created = ReflectionHelpers.CreateArray(typeof(int), count);
                 Assert.AreEqual(count, created.Length);
                 Assert.IsTrue(created is int[]);
@@ -174,11 +495,11 @@
                 Assert.AreEqual(0, created.Count);
                 Assert.IsTrue(created is List<int>);
                 List<int> typedCreated = (List<int>)created;
-                int count = _random.Next(50);
+                int count = PRNG.Instance.Next(50);
                 List<int> expected = new();
                 for (int j = 0; j < count; ++j)
                 {
-                    int element = _random.Next();
+                    int element = PRNG.Instance.Next();
                     created.Add(element);
                     expected.Add(element);
                     Assert.AreEqual(j + 1, created.Count);
@@ -192,18 +513,18 @@
         {
             for (int i = 0; i < NumTries; ++i)
             {
-                int capacity = _random.Next(1_000);
+                int capacity = PRNG.Instance.Next(1_000);
                 IList created = ReflectionHelpers.CreateList(typeof(int), capacity);
                 Assert.AreEqual(0, created.Count);
                 Assert.IsTrue(created is List<int>);
                 List<int> typedCreated = (List<int>)created;
                 Assert.AreEqual(capacity, typedCreated.Capacity);
 
-                int count = _random.Next(50);
+                int count = PRNG.Instance.Next(50);
                 List<int> expected = new();
                 for (int j = 0; j < count; ++j)
                 {
-                    int element = _random.Next();
+                    int element = PRNG.Instance.Next();
                     created.Add(element);
                     expected.Add(element);
                     Assert.AreEqual(j + 1, created.Count);

package/Tests/Runtime/Helper/WallMathTests.cs

@@ -1,10 +1,10 @@
-namespace UnityHelpers.Tests.Tests.Runtime.Helper
+namespace UnityHelpers.Tests.Helper
 {
-    using Core.Extension;
-    using Core.Helper;
-    using Core.Random;
     using NUnit.Framework;
     using UnityEngine;
+    using UnityHelpers.Core.Extension;
+    using UnityHelpers.Core.Helper;
+    using UnityHelpers.Core.Random;
 
     public sealed class WallMathTests
     {

package/Tests/Runtime/Performance/RandomPerformanceTests.cs

@@ -10,13 +10,13 @@
         [Test]
         public void Benchmark()
         {
-            TimeSpan timeout = TimeSpan.FromSeconds(1.125);
+            TimeSpan timeout = TimeSpan.FromSeconds(1);
 
             UnityEngine.Debug.Log(
-                $"| Random | NextBool | Next | NextUInt | NextFloat | NextDouble | NextUint - Range | "
+                "| Random | NextBool | Next | NextUInt | NextFloat | NextDouble | NextUint - Range | NextInt - Range |"
             );
             UnityEngine.Debug.Log(
-                $"| ------ | -------- | ---- | -------- | --------- | ---------- | ---------------- |"
+                "| ------ | -------- | ---- | -------- | --------- | ---------- | ---------------- | --------------- |"
             );
 
             RunTest(new PcgRandom(), timeout);
@@ -28,6 +28,8 @@
             RunTest(new SplitMix64(), timeout);
             RunTest(new RomuDuo(), timeout);
             RunTest(new XorShiroRandom(), timeout);
+            RunTest(new UnityRandom(), timeout);
+            RunTest(new LinearCongruentialGenerator(), timeout);
         }
 
         private static void RunTest<T>(T random, TimeSpan timeout)
@@ -39,6 +41,7 @@
             int nextFloat = RunNextFloat(timeout, random);
             int nextDouble = RunNextDouble(timeout, random);
             int nextUintRange = RunNextUintRange(timeout, random);
+            int nextIntRange = RunNextIntRange(timeout, random);
 
             UnityEngine.Debug.Log(
                 $"| {random.GetType().Name} | "
@@ -48,6 +51,7 @@
                     + $"{(nextFloat / timeout.TotalSeconds):N0} | "
                     + $"{(nextDouble / timeout.TotalSeconds):N0} |"
                     + $"{(nextUintRange / timeout.TotalSeconds):N0} |"
+                    + $"{(nextIntRange / timeout.TotalSeconds):N0} |"
             );
         }
 
@@ -108,6 +112,20 @@
             return count;
         }
 
+        private static int RunNextIntRange<T>(TimeSpan timeout, T random)
+            where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.Next(1_000);
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
         private static int RunNextFloat<T>(TimeSpan timeout, T random)
             where T : IRandom
         {

package/Tests/Runtime/Random/LinearCongruentialGeneratorTests.cs

@@ -0,0 +1,12 @@
+namespace UnityHelpers.Tests.Random
+{
+    using Core.Random;
+
+    public sealed class LinearCongruentialGeneratorTests : RandomTestBase
+    {
+        protected override IRandom NewRandom()
+        {
+            return new LinearCongruentialGenerator();
+        }
+    }
+}

package/Tests/Runtime/Random/LinearCongruentialGeneratorTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7859c541d79a4af7893bd98abfe7fea8
+timeCreated: 1742702856

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc43",
+  "version": "2.0.0-rc45",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},