com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Tests/Runtime/DataStructures/SpatialTreeTests.cs

@@ -0,0 +1,106 @@
+namespace UnityHelpers.Tests.DataStructures
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.DataStructure;
+    using Core.Helper;
+    using Core.Random;
+    using NUnit.Framework;
+    using Vector2 = UnityEngine.Vector2;
+
+    public abstract class SpatialTreeTests<TTree> where TTree : ISpatialTree<Vector2>
+    {
+        private IRandom Random => PcgRandom.Instance;
+
+        protected abstract TTree CreateTree(IEnumerable<Vector2> points);
+
+        [Test]
+        public void SimpleWithinCircle()
+        {
+            Vector2 center = new(Random.NextFloat(-100, 100), Random.NextFloat(-100, 100));
+            float radius = Random.NextFloat(5, 25f);
+
+            const int numPoints = 1_000;
+            HashSet<Vector2> points = new(numPoints);
+            for (int i = 0; i < numPoints; ++i)
+            {
+                Vector2 point;
+                do
+                {
+                    point = Helpers.GetRandomPointInCircle(center, radius);
+                }
+                while (!points.Add(point));
+            }
+
+            TTree quadTree = CreateTree(points);
+
+            List<Vector2> pointsInRange = quadTree.GetElementsInRange(center, radius).ToList();
+            Assert.IsTrue(points.SetEquals(pointsInRange), "Found {0} points in range, expected {1}.", pointsInRange.Count, points.Count);
+            // Translate by a unit-square - there should be no points in this range
+            Vector2 offset = center;
+            offset.x -= radius * 2;
+            offset.y -= radius * 2;
+
+            pointsInRange = quadTree.GetElementsInRange(offset, radius).ToList();
+            Assert.AreEqual(
+                0, pointsInRange.Count, "Found {0} points within {1} range of {2} (original center {3})",
+                pointsInRange.Count, radius, offset, center);
+        }
+
+        [Test]
+        public void SimplePointOutsideRange()
+        {
+            Vector2 point = new(Random.NextFloat(-100, 100), Random.NextFloat(-100, 100));
+
+            Vector2 direction = Helpers.GetRandomPointInCircle(Vector2.zero, 1f).normalized;
+            float range = Random.NextFloat(25, 1_000);
+            Vector2 testPoint = point + (direction * range);
+            List<Vector2> points = new(1) { testPoint };
+
+            TTree quadTree = CreateTree(points);
+            List<Vector2> pointsInRange = quadTree.GetElementsInRange(point, range * 0.99f).ToList();
+            Assert.AreEqual(0, pointsInRange.Count);
+            pointsInRange = quadTree.GetElementsInRange(point, range * 1.01f).ToList();
+            Assert.AreEqual(1, pointsInRange.Count, "Failed to find point {0} from test point {1} with {2:0.00} range.", point, testPoint, range);
+            Assert.AreEqual(testPoint, pointsInRange[0]);
+        }
+
+        [Test]
+        public void SimpleANN()
+        {
+            List<Vector2> points = new();
+            for (int x = 0; x < 100; ++x)
+            {
+                for (int y = 0; y < 100; ++y)
+                {
+                    Vector2 point = new(x, y);
+                    points.Add(point);
+                }
+            }
+
+            TTree quadTree = CreateTree(points);
+            Vector2 center = quadTree.Boundary.center;
+
+            List<Vector2> nearestNeighbors = new();
+            int nearestNeighborCount = 1;
+            quadTree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+            Assert.AreEqual(nearestNeighborCount, nearestNeighbors.Count);
+            Assert.IsTrue(nearestNeighbors.All(neighbor => (neighbor - center).magnitude <= 2f));
+
+            nearestNeighborCount = 4;
+            quadTree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+            Assert.AreEqual(nearestNeighborCount, nearestNeighbors.Count);
+            Assert.IsTrue(nearestNeighbors.All(neighbor => (neighbor - center).magnitude <= 2.2f));
+
+            nearestNeighborCount = 16;
+            quadTree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+            Assert.AreEqual(nearestNeighborCount, nearestNeighbors.Count);
+            Assert.IsTrue(nearestNeighbors.All(neighbor => (neighbor - center).magnitude <= 5.6f), "Max: {0}", nearestNeighbors.Select(neighbor => (neighbor - center).magnitude).Max());
+
+            center = new Vector2(-100, -100);
+
+            quadTree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+            Assert.AreEqual(nearestNeighborCount, nearestNeighbors.Count);
+        }
+    }
+}

package/Tests/Runtime/DataStructures/SpatialTreeTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0445f017299145d419297a7e0da52411
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/DataStructures/UnbalancedKDTreeTests.cs

@@ -0,0 +1,14 @@
+namespace UnityHelpers.Tests.DataStructures
+{
+    using System.Collections.Generic;
+    using UnityEngine;
+    using Core.DataStructure;
+
+    public sealed class UnbalancedKDTreeTests : SpatialTreeTests<KDTree<Vector2>>
+    {
+        protected override KDTree<Vector2> CreateTree(IEnumerable<Vector2> points)
+        {
+            return new KDTree<Vector2>(points, _ => _, balanced: false);
+        }
+    }
+}

package/Tests/Runtime/DataStructures/UnbalancedKDTreeTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9b456860735e5b04d80f1423f2d92a98
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/DataStructures.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 85bbbe201ca08f241959c78b20b73e22
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Performance/KDTreePerformanceTests.cs

@@ -0,0 +1,14 @@
+namespace UnityHelpers.Tests.Performance
+{
+    using System.Collections.Generic;
+    using Core.DataStructure;
+    using UnityEngine;
+
+    public sealed class KDTreePerformanceTests : SpatialTreePerformanceTest<KDTree<Vector2>>
+    {
+        protected override KDTree<Vector2> CreateTree(IEnumerable<Vector2> points)
+        {
+            return new KDTree<Vector2>(points, _ => _);
+        }
+    }
+}

package/Tests/Runtime/Performance/KDTreePerformanceTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aec27da8346dc82439a2b67406674902
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Performance/QuadTreePerformanceTests.cs

@@ -0,0 +1,14 @@
+namespace UnityHelpers.Tests.Performance
+{
+    using System.Collections.Generic;
+    using UnityEngine;
+    using Core.DataStructure;
+
+    public sealed class QuadTreePerformanceTests : SpatialTreePerformanceTest<QuadTree<Vector2>>
+    {
+        protected override QuadTree<Vector2> CreateTree(IEnumerable<Vector2> points)
+        {
+            return new QuadTree<Vector2>(points, _ => _);
+        }
+    }
+}

package/Tests/Runtime/Performance/QuadTreePerformanceTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9a83172c3da6b894d850aae0b3aae31e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Performance/RandomPerformanceTests.cs

@@ -0,0 +1,76 @@
+namespace UnityHelpers.Tests.Performance
+{
+    using System;
+    using System.Diagnostics;
+    using NUnit.Framework;
+    using UnityHelpers.Core.Random;
+
+    public sealed class RandomPerformanceTests
+    {
+        [Test]
+        public void Benchmark()
+        {
+            TimeSpan timeout = TimeSpan.FromSeconds(1);
+
+            UnityEngine.Debug.Log($"| Random | Next | NextFloat | NextDouble |");
+            UnityEngine.Debug.Log($"| ------ | ---- | --------- | ---------- |");
+            
+            RunTest(new PcgRandom(), timeout);
+            RunTest(new SystemRandom(), timeout);
+            RunTest(new SquirrelRandom(), timeout);
+            RunTest(new XorShiftRandom(), timeout);
+        }
+
+        private void RunTest<T>(T random, TimeSpan timeout) where T : IRandom
+        {
+            int nextInt = RunNext(timeout, random);
+            int nextFloat = RunNextFloat(timeout, random);
+            int nextDouble = RunNextDouble(timeout, random);
+
+            UnityEngine.Debug.Log($"| {random.GetType().Name} | {(nextInt / timeout.TotalSeconds):N0} | {(nextFloat / timeout.TotalSeconds):N0} | {(nextDouble / timeout.TotalSeconds):N0} |");
+        }
+
+        // Copy-pasta'd for maximum speed
+        private int RunNext<T>(TimeSpan timeout, T random) where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.Next();
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private int RunNextFloat<T>(TimeSpan timeout, T random) where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextFloat();
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+
+            return count;
+        }
+
+        private int RunNextDouble<T>(TimeSpan timeout, T random) where T : IRandom
+        {
+            int count = 0;
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                _ = random.NextDouble();
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+
+            return count;
+        }
+    }
+}

package/Tests/Runtime/Performance/RandomPerformanceTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cd362cfc7f5bcc74fa5a42a2670f070c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Performance/SpatialTreePerformanceTest.cs

@@ -0,0 +1,141 @@
+namespace UnityHelpers.Tests.Performance
+{
+    using NUnit.Framework;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System;
+    using System.Collections;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using UnityEngine;
+    using Core.DataStructure;
+    using UnityEngine.TestTools;
+
+    public abstract class SpatialTreePerformanceTest<TTree> where TTree : ISpatialTree<Vector2>
+    {
+        protected abstract TTree CreateTree(IEnumerable<Vector2> points);
+
+        [UnityTest]
+        public IEnumerator Performance()
+        {
+            UnityEngine.Debug.Log("| Operation | Operations / Second |");
+            UnityEngine.Debug.Log("| --------- | ------------------- |");
+
+            Vector2[] points = new Vector2[1_000_000];
+            float radius = 500;
+            ParallelLoopResult result = Parallel.For(0, 1_000_000, index =>
+            {
+                // ReSharper disable once PossibleLossOfFraction
+                points[index] = new Vector2(index % 1_000, index / 1_000);
+            });
+
+            while (!result.IsCompleted)
+            {
+                yield return null;
+            }
+
+            Stopwatch timer = Stopwatch.StartNew();
+            TTree tree = CreateTree(points);
+            timer.Stop();
+            UnityEngine.Debug.Log($"| Construction (1 million points) | {(int)Math.Floor(1 / timer.Elapsed.TotalSeconds)} ({timer.Elapsed.TotalSeconds} total) |");
+            Vector2 center = tree.Boundary.center;
+            int count = 0;
+            TimeSpan timeout = TimeSpan.FromSeconds(1);
+            timer.Restart();
+            do
+            {
+                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
+                Assert.AreEqual(785456, elementsInRange);
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+
+            UnityEngine.Debug.Log($"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+
+            radius /= 2f;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
+                Assert.AreEqual(196364, elementsInRange);
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log($"| Elements In Range - Half | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+
+            radius /= 2f;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
+                Assert.AreEqual(49080, elementsInRange);
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log($"| Elements In Range - Quarter | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+
+            radius = 1f;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                int elementsInRange = tree.GetElementsInRange(center, radius).Count();
+                Assert.AreEqual(4, elementsInRange);
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log($"| Elements In Range - 1 Range | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+
+            int nearestNeighborCount = 500;
+            List<Vector2> nearestNeighbors = new();
+            count = 0;
+            timer.Restart();
+            do
+            {
+                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log($"| ANN - 500 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+
+            nearestNeighborCount = 100;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log($"| ANN - 100 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+
+            nearestNeighborCount = 10;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log($"| ANN - 10 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+
+            nearestNeighborCount = 1;
+            count = 0;
+            timer.Restart();
+            do
+            {
+                tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
+                Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
+                ++count;
+            }
+            while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log($"| ANN - 1 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+        }
+    }
+}

package/Tests/Runtime/Performance/SpatialTreePerformanceTest.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dfc116ec86bb06747ba0d3471eb2bbba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Performance/UnbalancedKDTreeTests.cs

@@ -0,0 +1,14 @@
+namespace UnityHelpers.Tests.Performance
+{
+    using System.Collections.Generic;
+    using UnityEngine;
+    using Core.DataStructure;
+
+    public sealed class UnbalancedKDTreeTests : SpatialTreePerformanceTest<KDTree<Vector2>>
+    {
+        protected override KDTree<Vector2> CreateTree(IEnumerable<Vector2> points)
+        {
+            return new KDTree<Vector2>(points, _ => _, balanced: false);
+        }
+    }
+}

package/Tests/Runtime/Performance/UnbalancedKDTreeTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6cc8f8f6f409cc540accf2e960fc2ee8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Performance.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: af87f90044cdc7140b0dc8a0fd6c11d2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Random/PcgRandomTests.cs

@@ -0,0 +1,9 @@
+namespace UnityHelpers.Tests.Random
+{
+    using UnityHelpers.Core.Random;
+
+    public sealed class PcgRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom() => new PcgRandom();
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1275f0d928181ce439edbcf9a7f0ca2e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Random/RandomTestBase.cs

@@ -0,0 +1,117 @@
+namespace UnityHelpers.Tests.Random
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+    using NUnit.Framework;
+    using UnityHelpers.Core.Random;
+
+    public abstract class RandomTestBase
+    {
+        protected const int SampleCount = 10_000_000;
+
+        protected int[] _samples = new int[1_000];
+
+        protected abstract IRandom NewRandom();
+
+        [SetUp]
+        public virtual void Setup()
+        {
+            Array.Clear(_samples, 0, _samples.Length);
+        }
+
+        [TearDown]
+        public virtual void Teardown()
+        {
+            // No-op in base
+        }
+
+        [Test]
+        public void Int()
+        {
+            TestAndVerify(random => random.Next(0, _samples.Length));
+        }
+
+        [Test]
+        public void Uint()
+        {
+            TestAndVerify(random => (int)random.NextUint(0, (uint)_samples.Length));
+        }
+
+        [Test]
+        public void Short()
+        {
+            TestAndVerify(random => random.NextShort(0, (short)_samples.Length));
+        }
+
+        [Test]
+        public void Byte()
+        {
+            TestAndVerify(random => random.NextByte(0, (byte)(_samples.Length < byte.MaxValue ? _samples.Length : byte.MaxValue)), byte.MaxValue);
+        }
+
+        [Test]
+        public void Float()
+        {
+            TestAndVerify(random => (int)Math.Floor(random.NextFloat(0, _samples.Length)));
+        }
+
+        [Test]
+        public void Double()
+        {
+            TestAndVerify(random => (int)Math.Floor(random.NextDouble(0, _samples.Length)));
+        }
+
+        [Test]
+        public void Long()
+        {
+            TestAndVerify(random => (int)random.NextLong(0, _samples.Length));
+        }
+
+        [Test]
+        public void Ulong()
+        {
+            TestAndVerify(random => (int)random.NextUlong(0, (ulong)_samples.Length));
+        }
+
+        protected void TestAndVerify(Func<IRandom, int> sample, int? maxLength = null)
+        {
+            IRandom random = NewRandom();
+            for (int i = 0; i < SampleCount; ++i)
+            {
+                int index = sample(random);
+                if (index < 0 || _samples.Length <= index)
+                {
+                    Assert.Fail("Index {0} out of range", index);
+                }
+                else
+                {
+                    _samples[index]++;
+                }
+            }
+
+            int sampleLength = Math.Min(_samples.Length, maxLength ?? _samples.Length);
+            double average = SampleCount * 1.0 / sampleLength;
+            double deviationAllowed = average * 0.05;
+            List<int> zeroCountIndexes = new();
+            List<int> outsideRange = new();
+            for (int i = 0; i < sampleLength; i++)
+            {
+                int count = _samples[i];
+                if (count == 0)
+                {
+                    zeroCountIndexes.Add(i);
+                }
+
+                if (deviationAllowed < Math.Abs(count - average))
+                {
+                    outsideRange.Add(i);
+                }
+            }
+
+            Assert.AreEqual(0, zeroCountIndexes.Count, "No samples at {0} indices: [{1}]", zeroCountIndexes.Count, string.Join(",", zeroCountIndexes));
+            Assert.AreEqual(0, outsideRange.Count, "{0} indexes outside of dev {1:0.00}. Expected: {2:0.00}. Found: [{3}]", outsideRange.Count, deviationAllowed, average, string.Join(",", outsideRange.Select(index => _samples[index])));
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7742eba2bde9bee4192ce9349334b67a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Random/SquirrelRandomTests.cs

@@ -0,0 +1,9 @@
+namespace UnityHelpers.Tests.Random
+{
+    using UnityHelpers.Core.Random;
+
+    public sealed class SquirrelRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom() => new SquirrelRandom();
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1b42060f8efe0774ca7a1b5e67045d80
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Random/SystemRandomTests.cs

@@ -0,0 +1,10 @@
+namespace UnityHelpers.Tests.Random
+{
+    using System;
+    using UnityHelpers.Core.Random;
+
+    public sealed class SystemRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom() => new SystemRandom(Guid.NewGuid().GetHashCode());
+    }
+}