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

package/Runtime/Core/Helper/FormattingHelpers.cs

@@ -4,19 +4,19 @@
 
     public static class FormattingHelpers
     {
+        private static readonly string[] ByteSizes = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
+
         public static string FormatBytes(long bytes)
         {
-            string[] sizes = { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
+            bytes = Math.Max(0L, bytes);
             double len = bytes;
             int order = 0;
 
-            bytes = Math.Max(0, bytes);
-
             const int byteInChunk = 1024;
             while (byteInChunk <= len)
             {
                 len /= byteInChunk;
-                if (order < sizes.Length - 1)
+                if (order < ByteSizes.Length - 1)
                 {
                     ++order;
                 }
@@ -26,7 +26,7 @@
                 }
             }
 
-            return $"{len:0.##} {sizes[order]}";
+            return $"{len:0.##} {ByteSizes[order]}";
         }
     }
 }

package/Runtime/Core/Helper/Objects.cs

@@ -7,8 +7,8 @@
 
     public static class Objects
     {
-        private const int HashBase = 839;
-        private const int HashMultiplier = 4021;
+        private const int HashBase = 5556137;
+        private const int HashMultiplier = 95785853;
 
         public static T FromWeakReference<T>(WeakReference weakReference)
             where T : class

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -20,6 +20,7 @@
         public static Array CreateArray(Type type, int length)
         {
             return ArrayCreators
+                // ReSharper disable once ConvertClosureToMethodGroup
                 .GetOrAdd(type, elementType => GetArrayCreator(elementType))
                 .Invoke(length);
         }
@@ -28,6 +29,7 @@
         public static IList CreateList(Type elementType, int length)
         {
             return ListWithCapacityCreators
+                // ReSharper disable once ConvertClosureToMethodGroup
                 .GetOrAdd(elementType, type => GetListWithCapacityCreator(type))
                 .Invoke(length);
         }
@@ -35,6 +37,7 @@
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static IList CreateList(Type elementType)
         {
+            // ReSharper disable once ConvertClosureToMethodGroup
             return ListCreators.GetOrAdd(elementType, type => GetListCreator(type)).Invoke();
         }
 
@@ -44,7 +47,7 @@
             return field.GetValue;
 #else
             DynamicMethod dynamicMethod = new(
-                $"Get{(field.DeclaringType?.Name ?? string.Empty)}{field.Name}",
+                $"Get{field.DeclaringType.Name}{field.Name}",
                 typeof(object),
                 new[] { typeof(object) },
                 field.DeclaringType,
@@ -72,6 +75,41 @@
 #endif
         }
 
+        public static Func<object> GetStaticFieldGetter(FieldInfo field)
+        {
+            if (!field.IsStatic)
+            {
+                throw new ArgumentException(nameof(field));
+            }
+
+#if WEB_GL
+            return () => field.GetValue(null);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"Get{field.DeclaringType.Name}{field.Name}",
+                typeof(object),
+                Type.EmptyTypes, // No parameters for static fields
+                field.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            // Load the static field
+            il.Emit(OpCodes.Ldsfld, field);
+
+            // If the field's type is a value type, box it.
+            if (field.FieldType.IsValueType)
+            {
+                il.Emit(OpCodes.Box, field.FieldType);
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            return (Func<object>)dynamicMethod.CreateDelegate(typeof(Func<object>));
+#endif
+        }
+
         public static Func<TInstance, TValue> GetFieldGetter<TInstance, TValue>(FieldInfo field)
         {
 #if WEB_GL
@@ -142,6 +180,59 @@
 #endif
         }
 
+        public static Func<TValue> GetStaticFieldGetter<TValue>(FieldInfo field)
+        {
+            if (!field.IsStatic)
+            {
+                throw new ArgumentException(nameof(field));
+            }
+
+#if WEB_GL
+            return Getter;
+            TValue Getter()
+            {
+                return (TValue)field.GetValue(null);
+            }
+#else
+            DynamicMethod dynamicMethod = new(
+                $"GetGenericStatic{field.DeclaringType.Name}{field.Name}",
+                typeof(TValue),
+                Type.EmptyTypes, // no parameters needed for static fields
+                field.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            // Load the static field.
+            il.Emit(OpCodes.Ldsfld, field);
+
+            // Handle conversion from the field type to TValue.
+            if (field.FieldType.IsValueType)
+            {
+                if (!typeof(TValue).IsValueType)
+                {
+                    il.Emit(OpCodes.Box, field.FieldType);
+                }
+            }
+            else
+            {
+                if (typeof(TValue).IsValueType)
+                {
+                    il.Emit(OpCodes.Unbox_Any, typeof(TValue));
+                }
+                else if (typeof(TValue) != field.FieldType)
+                {
+                    il.Emit(OpCodes.Castclass, typeof(TValue));
+                }
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            return (Func<TValue>)dynamicMethod.CreateDelegate(typeof(Func<TValue>));
+#endif
+        }
+
         public static FieldSetter<TInstance, TValue> GetFieldSetter<TInstance, TValue>(
             FieldInfo field
         )
@@ -184,6 +275,36 @@
 #endif
         }
 
+        public static Action<TValue> GetStaticFieldSetter<TValue>(FieldInfo field)
+        {
+            if (!field.IsStatic)
+            {
+                throw new ArgumentException(nameof(field));
+            }
+#if WEB_GL
+            return Setter;
+            void Setter(TValue newValue)
+            {
+                field.SetValue(null, newValue);
+            }
+#else
+            DynamicMethod dynamicMethod = new(
+                $"SetFieldGenericStatic{field.DeclaringType.Name}{field.Name}",
+                typeof(void),
+                new[] { typeof(TValue) },
+                field.Module,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_0);
+            il.Emit(OpCodes.Stsfld, field);
+            il.Emit(OpCodes.Ret);
+
+            return (Action<TValue>)dynamicMethod.CreateDelegate(typeof(Action<TValue>));
+#endif
+        }
+
         public static Action<object, object> GetFieldSetter(FieldInfo field)
         {
 #if WEB_GL
@@ -217,6 +338,40 @@
 #endif
         }
 
+        public static Action<object> GetStaticFieldSetter(FieldInfo field)
+        {
+            if (!field.IsStatic)
+            {
+                throw new ArgumentException(nameof(field));
+            }
+#if WEB_GL
+            return value => field.SetValue(null, value);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"SetFieldStatic{field.DeclaringType.Name}{field.Name}",
+                null,
+                new[] { typeof(object) },
+                field.DeclaringType.Module,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            // Load the new value (argument 0)
+            il.Emit(OpCodes.Ldarg_0);
+            // Convert the object to the field's type (unbox or cast as needed)
+            il.Emit(
+                field.FieldType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass,
+                field.FieldType
+            );
+            // Set the static field
+            il.Emit(OpCodes.Stsfld, field);
+            il.Emit(OpCodes.Ret);
+
+            return (Action<object>)dynamicMethod.CreateDelegate(typeof(Action<object>));
+#endif
+        }
+
         public static Func<int, Array> GetArrayCreator(Type elementType)
         {
 #if WEB_GL

package/Runtime/Core/Helper/SpriteHelpers.cs

@@ -3,13 +3,12 @@
     using Extension;
     using UnityEditor;
     using UnityEngine;
-    using Utils;
 
     public static class SpriteHelpers
     {
         public static void MakeReadable(this Texture2D texture)
         {
-            if (texture.isReadable)
+            if (texture == null || texture.isReadable)
             {
                 return;
             }
@@ -29,58 +28,14 @@
                 return;
             }
 
-            tImporter.isReadable = true;
-            EditorUtility.SetDirty(tImporter);
-            tImporter.SaveAndReimport();
-            EditorUtility.SetDirty(texture);
-#endif
-        }
-
-        public static void SetSpritePivot(string fullSpritePath, Vector2 pivot)
-        {
-#if UNITY_EDITOR
-            SetSpritePivot(AssetImporter.GetAtPath(fullSpritePath) as TextureImporter, pivot);
-#endif
-        }
-
-        public static void SetSpritePivot(Sprite sprite, Vector2 pivot)
-        {
-#if UNITY_EDITOR
-            SetSpritePivot(
-                AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(sprite)) as TextureImporter,
-                pivot
-            );
-#endif
-        }
-
-#if UNITY_EDITOR
-        public static void SetSpritePivot(TextureImporter textureImporter, Vector2 pivot)
-        {
-            if (textureImporter == null)
+            if (!tImporter.isReadable)
             {
-                return;
+                tImporter.isReadable = true;
+                EditorUtility.SetDirty(tImporter);
+                tImporter.SaveAndReimport();
+                EditorUtility.SetDirty(texture);
             }
-
-            TextureImporterSettings textureImportSettings = new TextureImporterSettings();
-            textureImporter.ReadTextureSettings(textureImportSettings);
-            textureImportSettings.spriteAlignment = (int)SpriteAlignment.Custom;
-            textureImportSettings.wrapMode = TextureWrapMode.Clamp;
-            textureImportSettings.filterMode = FilterMode.Trilinear;
-            textureImporter.SetTextureSettings(textureImportSettings);
-
-            TextureImporterPlatformSettings importerSettings = new TextureImporterPlatformSettings
-            {
-                resizeAlgorithm = TextureResizeAlgorithm.Bilinear,
-                maxTextureSize = SetTextureImportData.RegularTextureSize,
-                textureCompression = TextureImporterCompression.Compressed,
-                format = TextureImporterFormat.Automatic,
-            };
-
-            textureImporter.SetPlatformTextureSettings(importerSettings);
-            textureImporter.isReadable = true;
-            textureImporter.spritePivot = pivot;
-            textureImporter.SaveAndReimport();
-        }
 #endif
+        }
     }
 }

package/Runtime/Core/Helper/WallMath.cs

@@ -125,12 +125,12 @@
                 if (0 < direction.x)
                 {
                     float t2 = (max.x - center.x) / direction.x;
-                    tMax = Math.Min(tMax, t2);
+                    tMax = Mathf.Min(tMax, t2);
                 }
                 else
                 {
                     float t1 = (min.x - center.x) / direction.x;
-                    tMax = Math.Min(tMax, t1);
+                    tMax = Mathf.Min(tMax, t1);
                 }
             }
 
@@ -139,12 +139,12 @@
                 if (direction.y > 0)
                 {
                     float t2 = (max.y - center.y) / direction.y;
-                    tMax = Math.Min(tMax, t2);
+                    tMax = Mathf.Min(tMax, t2);
                 }
                 else
                 {
                     float t1 = (min.y - center.y) / direction.y;
-                    tMax = Math.Min(tMax, t1);
+                    tMax = Mathf.Min(tMax, t1);
                 }
             }
 
@@ -160,7 +160,7 @@
 
         public static bool Approximately(this float lhs, float rhs, float tolerance = 0.045f)
         {
-            return Math.Abs(lhs - rhs) <= tolerance;
+            return Mathf.Abs(lhs - rhs) <= tolerance;
         }
     }
 }

package/Tests/Runtime/Helper/ArrayConverterTests.cs

@@ -1,9 +1,9 @@
-namespace UnityHelpers.Tests.Tests.Runtime.Helper
+namespace UnityHelpers.Tests.Helper
 {
     using System.Linq;
-    using Core.Helper;
-    using Core.Random;
     using NUnit.Framework;
+    using UnityHelpers.Core.Helper;
+    using UnityHelpers.Core.Random;
 
     public sealed class ArrayConverterTests
     {

package/Tests/Runtime/Helper/FormattingHelperTests.cs

@@ -0,0 +1,129 @@
+namespace UnityHelpers.Tests.Helper
+{
+    using NUnit.Framework;
+    using UnityHelpers.Core.Helper;
+    using UnityHelpers.Core.Random;
+
+    public sealed class FormattingHelperTests
+    {
+        private const int NumTries = 1_000;
+
+        [Test]
+        public void FormatNegative()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                long bytes = PRNG.Instance.NextLong(long.MinValue, 0);
+                const string expected = "0 B";
+                string found = FormattingHelpers.FormatBytes(bytes);
+                Assert.AreEqual(expected, found, $"{bytes} failed to convert");
+            }
+        }
+
+        [Test]
+        public void FormatZeroBytes()
+        {
+            long bytes = 0L;
+            const string expected = "0 B";
+            string found = FormattingHelpers.FormatBytes(bytes);
+            Assert.AreEqual(expected, found);
+        }
+
+        [Test]
+        public void FormatBytes()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                long bytes = PRNG.Instance.NextLong(1024L);
+                string expected = $"{bytes} B";
+                string found = FormattingHelpers.FormatBytes(bytes);
+                Assert.AreEqual(expected, found);
+            }
+        }
+
+        [Test]
+        public void FormatKiloBytes()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                long bytes = PRNG.Instance.NextLong(1024L, 1024L * 1024L);
+                string expected = $"{(bytes / 1024.0):0.##} KB";
+                string found = FormattingHelpers.FormatBytes(bytes);
+                Assert.AreEqual(expected, found);
+            }
+        }
+
+        [Test]
+        public void FormatMegaBytes()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                long bytes = PRNG.Instance.NextLong(1024L * 1024L, 1024L * 1024L * 1024L);
+                string expected = $"{(bytes / 1024.0 / 1024.0):0.##} MB";
+                string found = FormattingHelpers.FormatBytes(bytes);
+                Assert.AreEqual(expected, found);
+            }
+        }
+
+        [Test]
+        public void FormatGigaBytes()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                long bytes = PRNG.Instance.NextLong(
+                    1024L * 1024L * 1024L,
+                    1024L * 1024L * 1024L * 1024L
+                );
+                string expected = $"{(bytes / 1024.0 / 1024.0 / 1024.0):0.##} GB";
+                string found = FormattingHelpers.FormatBytes(bytes);
+                Assert.AreEqual(expected, found);
+            }
+        }
+
+        [Test]
+        public void FormatTeraBytes()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                long bytes = PRNG.Instance.NextLong(
+                    1024L * 1024L * 1024L * 1024L,
+                    1024L * 1024L * 1024L * 1024L * 1024L
+                );
+                string expected = $"{(bytes / 1024.0 / 1024.0 / 1024.0 / 1024.0):0.##} TB";
+                string found = FormattingHelpers.FormatBytes(bytes);
+                Assert.AreEqual(expected, found);
+            }
+        }
+
+        [Test]
+        public void FormatPetaBytes()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                long bytes = PRNG.Instance.NextLong(
+                    1024L * 1024L * 1024L * 1024L * 1024L,
+                    1024L * 1024L * 1024L * 1024L * 1024L * 1024L
+                );
+                string expected = $"{(bytes / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0):0.##} PB";
+                string found = FormattingHelpers.FormatBytes(bytes);
+                Assert.AreEqual(expected, found);
+            }
+        }
+
+        [Test]
+        public void FormatExaBytes()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                long bytes = PRNG.Instance.NextLong(
+                    1024L * 1024L * 1024L * 1024L * 1024L * 1024L,
+                    long.MaxValue
+                );
+                string expected =
+                    $"{(bytes / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0 / 1024.0):0.##} EB";
+                string found = FormattingHelpers.FormatBytes(bytes);
+                Assert.AreEqual(expected, found);
+            }
+        }
+    }
+}

package/Tests/Runtime/Helper/FormattingHelperTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 67b3a1cde9694bcb8a7bfbdb9bd477f6
+timeCreated: 1742758560

package/Tests/Runtime/Helper/ObjectHelperTests.cs

@@ -1,11 +1,11 @@
-namespace UnityHelpers.Tests.Tests.Runtime.Helper
+namespace UnityHelpers.Tests.Helper
 {
     using System.Collections;
-    using Core.Helper;
     using JetBrains.Annotations;
     using NUnit.Framework;
     using UnityEngine;
     using UnityEngine.TestTools;
+    using UnityHelpers.Core.Helper;
 
     [UsedImplicitly]
     public sealed class ObjectHelperComponent : MonoBehaviour { }

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/package.json

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