com.wallstop-studios.unity-helpers 2.0.0-rc05 → 2.0.0-rc07

package/Tests/Runtime/Random/RandomTestBase.cs

@@ -3,12 +3,16 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Runtime.CompilerServices;
+    using Core.Extension;
+    using Core.Serialization;
     using NUnit.Framework;
     using UnityHelpers.Core.Random;
 
     public abstract class RandomTestBase
     {
-        private const int SampleCount = 12_500_000;
+        private const int NumGeneratorChecks = 1_000;
+        private const int SampleCount = 12_750_000;
 
         private readonly int[] _samples = new int[1_000];
 
@@ -27,24 +31,119 @@
         }
 
         [Test]
+        [Parallelizable]
+        public void Bool()
+        {
+            TestAndVerify(random => Convert.ToInt32(random.NextBool()), maxLength: 2);
+        }
+
+        [Test]
+        [Parallelizable]
         public void Int()
         {
             TestAndVerify(random => random.Next(0, _samples.Length));
         }
 
         [Test]
+        [Parallelizable]
+        public void IntRange()
+        {
+            TestAndVerify(random => random.Next(_samples.Length));
+        }
+
+        [Test]
+        [Parallelizable]
+        public void IntDistribution()
+        {
+            TestAndVerify(random =>
+                (int)(random.Next() / ((1.0 * int.MaxValue) / _samples.Length))
+            );
+        }
+
+        [Test]
+        [Parallelizable]
+        public void IntMaxRange()
+        {
+            TestAndVerify(random =>
+                (int)(
+                    (random.Next(int.MinValue, int.MaxValue) + (-1.0 * int.MinValue))
+                    / (1.0 * int.MaxValue - int.MinValue)
+                    * _samples.Length
+                )
+            );
+        }
+
+        [Test]
+        [Parallelizable]
         public void Uint()
         {
             TestAndVerify(random => (int)random.NextUint(0, (uint)_samples.Length));
         }
 
         [Test]
+        [Parallelizable]
+        public void UintRange()
+        {
+            TestAndVerify(random => (int)random.NextUint((uint)_samples.Length));
+        }
+
+        [Test]
+        [Parallelizable]
+        public void UintDistribution()
+        {
+            TestAndVerify(random =>
+                (int)(random.NextUint() / ((1.0 * uint.MaxValue) / _samples.Length))
+            );
+        }
+
+        [Test]
+        [Parallelizable]
+        public void UintMaxRange()
+        {
+            TestAndVerify(random =>
+                (int)(
+                    (random.NextUint(uint.MinValue, uint.MaxValue) + (1.0 * uint.MinValue))
+                    / (1.0 * uint.MaxValue)
+                    * _samples.Length
+                )
+            );
+        }
+
+        [Test]
+        [Parallelizable]
         public void Short()
         {
-            TestAndVerify(random => random.NextShort(0, (short)_samples.Length));
+            TestAndVerify(
+                random => random.NextShort(0, (short)_samples.Length),
+                maxLength: (short.MaxValue - short.MinValue)
+            );
+        }
+
+        [Test]
+        [Parallelizable]
+        public void ShortRange()
+        {
+            TestAndVerify(
+                random => random.NextShort((short)_samples.Length),
+                maxLength: (short.MaxValue - short.MinValue)
+            );
+        }
+
+        [Test]
+        [Parallelizable]
+        public void ShortMaxRange()
+        {
+            TestAndVerify(random =>
+                (int)(
+                    (random.NextShort(short.MinValue, short.MaxValue) + (-1.0 * short.MinValue))
+                    / (1.0 * short.MaxValue - short.MinValue)
+                    * _samples.Length
+                )
+            );
         }
 
         [Test]
+        [Parallelizable]
         public void Byte()
         {
             TestAndVerify(
@@ -58,6 +157,40 @@
         }
 
         [Test]
+        [Parallelizable]
+        public void ByteRange()
+        {
+            TestAndVerify(
+                random =>
+                    random.NextByte(
+                        (byte)(_samples.Length < byte.MaxValue ? _samples.Length : byte.MaxValue)
+                    ),
+                byte.MaxValue
+            );
+        }
+
+        [Test]
+        [Parallelizable]
+        public void ByteMaxRange()
+        {
+            int sampleCount = Math.Min((byte.MaxValue - byte.MinValue), _samples.Length);
+            TestAndVerify(
+                random =>
+                    Math.Clamp(
+                        (int)(
+                            (random.NextByte(byte.MinValue, byte.MaxValue) + (-1.0 * byte.MinValue))
+                            / (1.0 * byte.MaxValue - byte.MinValue)
+                            * sampleCount
+                        ),
+                        0,
+                        sampleCount - 1
+                    ),
+                maxLength: sampleCount
+            );
+        }
+
+        [Test]
+        [Parallelizable]
         public void Float()
         {
             TestAndVerify(random =>
@@ -70,6 +203,44 @@
         }
 
         [Test]
+        [Parallelizable]
+        public void FloatRange()
+        {
+            TestAndVerify(random =>
+                Math.Clamp(
+                    (int)Math.Floor(random.NextFloat(_samples.Length)),
+                    0,
+                    _samples.Length - 1
+                )
+            );
+        }
+
+        [Test]
+        [Parallelizable]
+        public void FloatDistribution()
+        {
+            TestAndVerify(random => (int)(random.NextFloat() * _samples.Length));
+        }
+
+        [Test]
+        [Parallelizable]
+        public void FloatMaxRange()
+        {
+            TestAndVerify(random =>
+                Math.Clamp(
+                    (int)(
+                        (random.NextFloat(float.MinValue, float.MaxValue) + (-1.0 * float.MinValue))
+                        / (1.0 * float.MaxValue - float.MinValue)
+                        * _samples.Length
+                    ),
+                    0,
+                    _samples.Length - 1
+                )
+            );
+        }
+
+        [Test]
+        [Parallelizable]
         public void Double()
         {
             TestAndVerify(random =>
@@ -82,28 +253,103 @@
         }
 
         [Test]
+        [Parallelizable]
+        public void DoubleRange()
+        {
+            TestAndVerify(random =>
+                Math.Clamp(
+                    (int)Math.Floor(random.NextDouble(_samples.Length)),
+                    0,
+                    _samples.Length - 1
+                )
+            );
+        }
+
+        [Test]
+        [Parallelizable]
+        public void DoubleDistribution()
+        {
+            TestAndVerify(random => (int)(random.NextDouble() * _samples.Length));
+        }
+
+        [Test]
+        [Parallelizable]
+        public void DoubleMaxRange()
+        {
+            IRandom random = NewRandom();
+            for (int i = 0; i < SampleCount; ++i)
+            {
+                double value = random.NextDouble(double.MinValue, double.MaxValue);
+                Assert.IsFalse(double.IsNaN(value));
+                Assert.IsFalse(double.IsInfinity(value));
+            }
+        }
+
+        [Test]
+        [Parallelizable]
         public void Long()
         {
             TestAndVerify(random => (int)random.NextLong(0, _samples.Length));
         }
 
         [Test]
+        [Parallelizable]
+        public void LongRange()
+        {
+            TestAndVerify(random => (int)random.NextLong(_samples.Length));
+        }
+
+        [Test]
+        [Parallelizable]
+        public void LongMaxRange()
+        {
+            TestAndVerify(random =>
+                (int)(
+                    (random.NextLong(long.MinValue, long.MaxValue) + (-1.0 * long.MinValue))
+                    / (1.0 * long.MaxValue - long.MinValue)
+                    * _samples.Length
+                )
+            );
+        }
+
+        [Test]
+        [Parallelizable]
         public void Ulong()
         {
             TestAndVerify(random => (int)random.NextUlong(0, (ulong)_samples.Length));
         }
 
         [Test]
+        [Parallelizable]
+        public void UlongRange()
+        {
+            TestAndVerify(random => (int)random.NextUlong((ulong)_samples.Length));
+        }
+
+        [Test]
+        [Parallelizable]
+        public void UlongMaxRange()
+        {
+            TestAndVerify(random =>
+                (int)(
+                    (random.NextUlong(ulong.MinValue, ulong.MaxValue) + (-1.0 * ulong.MinValue))
+                    / (1.0 * ulong.MaxValue - ulong.MinValue)
+                    * _samples.Length
+                )
+            );
+        }
+
+        [Test]
+        [Parallelizable]
         public void Copy()
         {
-            const int numGeneratorChecks = 1_000;
             IRandom random1 = NewRandom();
             IRandom random2 = random1.Copy();
             Assert.AreEqual(random1.InternalState, random2.InternalState);
             // UnityRandom has shared state, the below test is not possible for it. We did all we could.
             if (NewRandom() is not UnityRandom)
             {
-                for (int i = 0; i < numGeneratorChecks; ++i)
+                for (int i = 0; i < NumGeneratorChecks; ++i)
                 {
                     Assert.AreEqual(random1.Next(), random2.Next());
                     Assert.AreEqual(random1.InternalState, random2.InternalState);
@@ -115,7 +361,7 @@
             Assert.AreEqual(random1.InternalState, random3.InternalState);
             if (NewRandom() is not UnityRandom)
             {
-                for (int i = 0; i < numGeneratorChecks; ++i)
+                for (int i = 0; i < NumGeneratorChecks; ++i)
                 {
                     Assert.AreEqual(random1.Next(), random3.Next());
                     Assert.AreEqual(random1.InternalState, random3.InternalState);
@@ -123,13 +369,42 @@
             }
         }
 
-        private void TestAndVerify(Func<IRandom, int> sample, int? maxLength = null)
+        [Test]
+        [Parallelizable]
+        public void Json()
+        {
+            IRandom random = NewRandom();
+            string json = random.ToJson();
+            IRandom deserialized = Serializer.JsonDeserialize<IRandom>(json, random.GetType());
+            Assert.AreEqual(random.InternalState, deserialized.InternalState);
+
+            if (NewRandom() is not UnityRandom)
+            {
+                for (int i = 0; i < NumGeneratorChecks; ++i)
+                {
+                    Assert.AreEqual(random.Next(), deserialized.Next());
+                    Assert.AreEqual(random.InternalState, deserialized.InternalState);
+                }
+            }
+        }
+
+        protected virtual double DeviationFor(string caller)
+        {
+            return 0.0625;
+        }
+
+        private void TestAndVerify(
+            Func<IRandom, int> sample,
+            int? maxLength = null,
+            [CallerMemberName] string caller = ""
+        )
         {
             IRandom random = NewRandom();
+            int sampleLength = _samples.Length;
             for (int i = 0; i < SampleCount; ++i)
             {
                 int index = sample(random);
-                if (index < 0 || _samples.Length <= index)
+                if (index < 0 || sampleLength <= index)
                 {
                     Assert.Fail("Index {0} out of range", index);
                 }
@@ -139,9 +414,9 @@
                 }
             }
 
-            int sampleLength = Math.Min(_samples.Length, maxLength ?? _samples.Length);
+            sampleLength = Math.Min(sampleLength, maxLength ?? sampleLength);
             double average = SampleCount * 1.0 / sampleLength;
-            double deviationAllowed = average * 0.05;
+            double deviationAllowed = average * DeviationFor(caller);
             List<int> zeroCountIndexes = new();
             List<int> outsideRange = new();
             for (int i = 0; i < sampleLength; i++)

package/Tests/Runtime/Random/SquirrelRandomTests.cs

@@ -5,5 +5,10 @@
     public sealed class SquirrelRandomTests : RandomTestBase
     {
         protected override IRandom NewRandom() => new SquirrelRandom();
+
+        protected override double DeviationFor(string caller)
+        {
+            return 0.075;
+        }
     }
 }

package/Tests/Runtime/Serialization/JsonSerializationTest.cs

@@ -29,12 +29,12 @@
         [Test]
         public void SerializationWorks()
         {
-            IRandom random = PcgRandom.Instance;
+            IRandom random = PRNG.Instance;
             TestDataObject input = new()
             {
                 field = Guid.NewGuid().ToString(),
                 Property = random.Next(),
-                NamedProperty = random.NextFloat()
+                NamedProperty = random.NextFloat(),
             };
 
             int dictionaryProperties = random.Next(4, 10);
@@ -51,21 +51,34 @@
 
             string json = input.ToJson();
             Assert.IsTrue(
-                json.Contains("DifferentPropertyName"), $"DifferentPropertyName failed to serialize! JSON: {json}");
+                json.Contains("DifferentPropertyName"),
+                $"DifferentPropertyName failed to serialize! JSON: {json}"
+            );
 
             TestDataObject deserialized = Serializer.JsonDeserialize<TestDataObject>(json);
-            Assert.AreEqual(input.field, deserialized.field, $"Unexpected {nameof(deserialized.field)}! JSON: {json}");
             Assert.AreEqual(
-                input.Property, deserialized.Property, $"Unexpected {nameof(deserialized.Property)}! JSON: {json}");
+                input.field,
+                deserialized.field,
+                $"Unexpected {nameof(deserialized.field)}! JSON: {json}"
+            );
             Assert.AreEqual(
-                input.NamedProperty, deserialized.NamedProperty,
-                $"Unexpected {nameof(deserialized.NamedProperty)}! JSON: {json}");
-            Assert.IsTrue( 
+                input.Property,
+                deserialized.Property,
+                $"Unexpected {nameof(deserialized.Property)}! JSON: {json}"
+            );
+            Assert.AreEqual(
+                input.NamedProperty,
+                deserialized.NamedProperty,
+                $"Unexpected {nameof(deserialized.NamedProperty)}! JSON: {json}"
+            );
+            Assert.IsTrue(
                 input.DictionaryProperty.ContentEquals(deserialized.DictionaryProperty),
-                $"Unexpected {nameof(deserialized.DictionaryProperty)}! JSON: {json}");
+                $"Unexpected {nameof(deserialized.DictionaryProperty)}! JSON: {json}"
+            );
             Assert.IsTrue(
                 input.ListProperty.SequenceEqual(deserialized.ListProperty),
-                $"Unexpected {nameof(deserialized.ListProperty)}! JSON: {json}");
+                $"Unexpected {nameof(deserialized.ListProperty)}! JSON: {json}"
+            );
         }
     }
-}
+}

package/Tests/Runtime/Utils/SpriteRendererMetadataTests.cs

@@ -32,7 +32,11 @@
 
         private SpriteRendererMetadata CreateMetadata()
         {
-            GameObject go = new("TestSpriteRendererMetadata", typeof(SpriteRenderer), typeof(SpriteRendererMetadata));
+            GameObject go = new(
+                "TestSpriteRendererMetadata",
+                typeof(SpriteRenderer),
+                typeof(SpriteRendererMetadata)
+            );
             _spawned.Add(go);
             return go.GetComponent<SpriteRendererMetadata>();
         }
@@ -44,8 +48,13 @@
 
         private Color CreateColor()
         {
-            IRandom random = PcgRandom.Instance;
-            Color color = new(random.NextFloat(), random.NextFloat(), random.NextFloat(), random.NextFloat());
+            IRandom random = PRNG.Instance;
+            Color color = new(
+                random.NextFloat(),
+                random.NextFloat(),
+                random.NextFloat(),
+                random.NextFloat()
+            );
             return color;
         }
 
@@ -74,9 +83,8 @@
             Material originalMaterial = metadata.OriginalMaterial;
             do
             {
-                newColor.r = PcgRandom.Instance.NextFloat();
-            }
-            while (newColor == originalColor);
+                newColor.r = PRNG.Instance.NextFloat();
+            } while (newColor == originalColor);
 
             SpriteRendererMetadata second = CreateMetadata();
             SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
@@ -91,9 +99,8 @@
             Color updatedColor = newColor;
             do
             {
-                updatedColor.g = PcgRandom.Instance.NextFloat();
-            }
-            while (updatedColor == newColor);
+                updatedColor.g = PRNG.Instance.NextFloat();
+            } while (updatedColor == newColor);
 
             metadata.PushColor(spriteRenderer, updatedColor);
             Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
@@ -108,9 +115,8 @@
             Color latestColor = updatedColor;
             do
             {
-                latestColor.b = PcgRandom.Instance.NextFloat();
-            }
-            while (latestColor == updatedColor);
+                latestColor.b = PRNG.Instance.NextFloat();
+            } while (latestColor == updatedColor);
 
             metadata.PushColor(second, latestColor);
             Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
@@ -120,9 +126,8 @@
             Assert.IsFalse(metadata.Colors.Contains(newColor));
             do
             {
-                newColor.a = PcgRandom.Instance.NextFloat();
-            }
-            while (newColor == latestColor);
+                newColor.a = PRNG.Instance.NextFloat();
+            } while (newColor == latestColor);
 
             metadata.PushColor(second, newColor);
             Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
@@ -189,7 +194,6 @@
             yield break;
         }
 
-
         [UnityTest]
         public IEnumerator PopColorIdempotent()
         {
@@ -392,4 +396,4 @@
             yield break;
         }
     }
-}
+}

package/package.json

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