com.wallstop-studios.unity-helpers 2.0.0-rc58 → 2.0.0-rc59

package/Tests/Runtime/Helper/ReflectionHelperTests.cs

@@ -1,536 +1,536 @@
-namespace UnityHelpers.Tests.Helper
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    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
-    {
-        private const int NumTries = 1_000;
-
-        [Test]
-        public void GetFieldGetterClassMemberField()
-        {
-            TestClass testClass = new();
-            Func<object, object> classGetter = ReflectionHelpers.GetFieldGetter(
-                typeof(TestClass).GetField(nameof(TestClass.intValue))
-            );
-            Assert.AreEqual(testClass.intValue, classGetter(testClass));
-            for (int i = 0; i < NumTries; ++i)
-            {
-                testClass.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
-                Assert.AreEqual(testClass.intValue, classGetter(testClass));
-            }
-        }
-
-        [Test]
-        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(
-                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
-            );
-            Assert.AreEqual(testStruct.intValue, structGetter(testStruct));
-            for (int i = 0; i < NumTries; ++i)
-            {
-                testStruct.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
-                Assert.AreEqual(testStruct.intValue, structGetter(testStruct));
-            }
-        }
-
-        [Test]
-        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(
-                typeof(TestClass).GetField(nameof(TestClass.intValue))
-            );
-            for (int i = 0; i < NumTries; ++i)
-            {
-                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
-                structSetter(testClass, expected);
-                Assert.AreEqual(expected, testClass.intValue);
-            }
-        }
-
-        [Test]
-        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();
-            Action<object, object> structSetter = ReflectionHelpers.GetFieldSetter(
-                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
-            );
-            for (int i = 0; i < NumTries; ++i)
-            {
-                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
-                structSetter(testStruct, expected);
-                Assert.AreEqual(expected, ((TestStruct)testStruct).intValue);
-            }
-        }
-
-        [Test]
-        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<
-                TestClass,
-                int
-            >(typeof(TestClass).GetField(nameof(TestClass.intValue)));
-            for (int i = 0; i < NumTries; ++i)
-            {
-                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
-                classSetter(ref testClass, expected);
-                Assert.AreEqual(expected, testClass.intValue);
-            }
-        }
-
-        [Test]
-        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<
-                TestStruct,
-                int
-            >(typeof(TestStruct).GetField(nameof(TestStruct.intValue)));
-            for (int i = 0; i < NumTries; ++i)
-            {
-                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
-                structSetter(ref testStruct, expected);
-                Assert.AreEqual(expected, testStruct.intValue);
-            }
-        }
-
-        [Test]
-        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>(
-                typeof(TestClass).GetField(nameof(TestClass.intValue))
-            );
-            for (int i = 0; i < NumTries; ++i)
-            {
-                testClass.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
-                Assert.AreEqual(testClass.intValue, classGetter(testClass));
-            }
-        }
-
-        [Test]
-        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>(
-                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
-            );
-            for (int i = 0; i < NumTries; ++i)
-            {
-                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 = PRNG.Instance.Next(1_000);
-                Array created = ReflectionHelpers.CreateArray(typeof(int), count);
-                Assert.AreEqual(count, created.Length);
-                Assert.IsTrue(created is int[]);
-                int[] typed = (int[])created;
-                Assert.AreEqual(count, typed.Length);
-            }
-        }
-
-        [Test]
-        public void ListCreator()
-        {
-            for (int i = 0; i < NumTries; ++i)
-            {
-                IList created = ReflectionHelpers.CreateList(typeof(int));
-                Assert.AreEqual(0, created.Count);
-                Assert.IsTrue(created is List<int>);
-                List<int> typedCreated = (List<int>)created;
-                int count = PRNG.Instance.Next(50);
-                List<int> expected = new();
-                for (int j = 0; j < count; ++j)
-                {
-                    int element = PRNG.Instance.Next();
-                    created.Add(element);
-                    expected.Add(element);
-                    Assert.AreEqual(j + 1, created.Count);
-                    Assert.That(expected, Is.EqualTo(typedCreated));
-                }
-            }
-        }
-
-        [Test]
-        public void ListWithSizeCreator()
-        {
-            for (int i = 0; i < NumTries; ++i)
-            {
-                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 = PRNG.Instance.Next(50);
-                List<int> expected = new();
-                for (int j = 0; j < count; ++j)
-                {
-                    int element = PRNG.Instance.Next();
-                    created.Add(element);
-                    expected.Add(element);
-                    Assert.AreEqual(j + 1, created.Count);
-                    Assert.That(expected, Is.EqualTo(typedCreated));
-                }
-            }
-        }
-    }
-}
+namespace UnityHelpers.Tests.Helper
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    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
+    {
+        private const int NumTries = 1_000;
+
+        [Test]
+        public void GetFieldGetterClassMemberField()
+        {
+            TestClass testClass = new();
+            Func<object, object> classGetter = ReflectionHelpers.GetFieldGetter(
+                typeof(TestClass).GetField(nameof(TestClass.intValue))
+            );
+            Assert.AreEqual(testClass.intValue, classGetter(testClass));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testClass.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testClass.intValue, classGetter(testClass));
+            }
+        }
+
+        [Test]
+        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(
+                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
+            );
+            Assert.AreEqual(testStruct.intValue, structGetter(testStruct));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testStruct.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testStruct.intValue, structGetter(testStruct));
+            }
+        }
+
+        [Test]
+        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(
+                typeof(TestClass).GetField(nameof(TestClass.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(testClass, expected);
+                Assert.AreEqual(expected, testClass.intValue);
+            }
+        }
+
+        [Test]
+        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();
+            Action<object, object> structSetter = ReflectionHelpers.GetFieldSetter(
+                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(testStruct, expected);
+                Assert.AreEqual(expected, ((TestStruct)testStruct).intValue);
+            }
+        }
+
+        [Test]
+        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<
+                TestClass,
+                int
+            >(typeof(TestClass).GetField(nameof(TestClass.intValue)));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                classSetter(ref testClass, expected);
+                Assert.AreEqual(expected, testClass.intValue);
+            }
+        }
+
+        [Test]
+        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<
+                TestStruct,
+                int
+            >(typeof(TestStruct).GetField(nameof(TestStruct.intValue)));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                structSetter(ref testStruct, expected);
+                Assert.AreEqual(expected, testStruct.intValue);
+            }
+        }
+
+        [Test]
+        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>(
+                typeof(TestClass).GetField(nameof(TestClass.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testClass.intValue = PRNG.Instance.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testClass.intValue, classGetter(testClass));
+            }
+        }
+
+        [Test]
+        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>(
+                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                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 = PRNG.Instance.Next(1_000);
+                Array created = ReflectionHelpers.CreateArray(typeof(int), count);
+                Assert.AreEqual(count, created.Length);
+                Assert.IsTrue(created is int[]);
+                int[] typed = (int[])created;
+                Assert.AreEqual(count, typed.Length);
+            }
+        }
+
+        [Test]
+        public void ListCreator()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                IList created = ReflectionHelpers.CreateList(typeof(int));
+                Assert.AreEqual(0, created.Count);
+                Assert.IsTrue(created is List<int>);
+                List<int> typedCreated = (List<int>)created;
+                int count = PRNG.Instance.Next(50);
+                List<int> expected = new();
+                for (int j = 0; j < count; ++j)
+                {
+                    int element = PRNG.Instance.Next();
+                    created.Add(element);
+                    expected.Add(element);
+                    Assert.AreEqual(j + 1, created.Count);
+                    Assert.That(expected, Is.EqualTo(typedCreated));
+                }
+            }
+        }
+
+        [Test]
+        public void ListWithSizeCreator()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                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 = PRNG.Instance.Next(50);
+                List<int> expected = new();
+                for (int j = 0; j < count; ++j)
+                {
+                    int element = PRNG.Instance.Next();
+                    created.Add(element);
+                    expected.Add(element);
+                    Assert.AreEqual(j + 1, created.Count);
+                    Assert.That(expected, Is.EqualTo(typedCreated));
+                }
+            }
+        }
+    }
+}