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

package/Runtime/Core/Serialization/Serializer.cs

@@ -2,13 +2,13 @@
 {
     using System;
     using System.ComponentModel;
-    using Extension;
-    using JsonConverters;
     using System.IO;
     using System.Runtime.Serialization.Formatters.Binary;
     using System.Text;
     using System.Text.Json;
     using System.Text.Json.Serialization;
+    using Extension;
+    using JsonConverters;
 
     internal static class SerializerEncoding
     {
@@ -30,7 +30,7 @@
                 {
                     new JsonStringEnumConverter(),
                     Vector3Converter.Instance,
-                    Vector2Converter.Instance
+                    Vector2Converter.Instance,
                 },
             };
 
@@ -45,7 +45,7 @@
                 {
                     new JsonStringEnumConverter(),
                     Vector3Converter.Instance,
-                    Vector2Converter.Instance
+                    Vector2Converter.Instance,
                 },
                 WriteIndented = true,
             };
@@ -70,7 +70,10 @@
                     return ProtoDeserialize<T>(serialized);
                 default:
                     throw new InvalidEnumArgumentException(
-                        nameof(serializationType), (int)serializationType, typeof(SerializationType));
+                        nameof(serializationType),
+                        (int)serializationType,
+                        typeof(SerializationType)
+                    );
             }
         }
 
@@ -84,7 +87,10 @@
                     return ProtoSerialize(instance);
                 default:
                     throw new InvalidEnumArgumentException(
-                        nameof(serializationType), (int)serializationType, typeof(SerializationType));
+                        nameof(serializationType),
+                        (int)serializationType,
+                        typeof(SerializationType)
+                    );
             }
         }
 
@@ -123,9 +129,14 @@
             return memoryStream.ToArray();
         }
 
-        public static T JsonDeserialize<T>(string data)
+        public static T JsonDeserialize<T>(string data, Type type = null)
         {
-            return JsonSerializer.Deserialize<T>(data, SerializerEncoding.NormalJsonOptions);
+            return (T)
+                JsonSerializer.Deserialize(
+                    data,
+                    type ?? typeof(T),
+                    SerializerEncoding.NormalJsonOptions
+                );
         }
 
         public static byte[] JsonSerialize<T>(T input)
@@ -135,13 +146,24 @@
 
         public static string JsonStringify<T>(T input, bool pretty = false)
         {
-            JsonSerializerOptions options =
-                pretty ? SerializerEncoding.PrettyJsonOptions : SerializerEncoding.NormalJsonOptions;
-            if (typeof(T) == typeof(object))
+            JsonSerializerOptions options = pretty
+                ? SerializerEncoding.PrettyJsonOptions
+                : SerializerEncoding.NormalJsonOptions;
+            Type parameterType = typeof(T);
+            if (
+                parameterType.IsAbstract
+                || parameterType.IsInterface
+                || parameterType == typeof(object)
+            )
             {
                 object data = input;
-                Type type = data?.GetType();
-                return JsonSerializer.Serialize(data, data?.GetType(), options);
+                if (data == null)
+                {
+                    return "{}";
+                }
+
+                Type type = data.GetType();
+                return JsonSerializer.Serialize(data, type, options);
             }
 
             return JsonSerializer.Serialize(input, options);
@@ -159,4 +181,4 @@
             File.WriteAllText(path, jsonAsText);
         }
     }
-}
+}

package/Runtime/Utils/CircleLineRenderer.cs

@@ -17,7 +17,7 @@
         public int baseSegments = 4;
         public float updateRateSeconds = 0.1f;
         public Color color = Color.grey;
-        
+
         public Vector3 Offset
         {
             get => _offset;
@@ -26,6 +26,7 @@
 
         [SiblingComponent]
         private CircleCollider2D _collider;
+
         [SiblingComponent]
         private LineRenderer[] _lineRenderers;
 
@@ -70,7 +71,11 @@
 
             if (maxLineWidth < minLineWidth)
             {
-                this.LogWarn("MaxLineWidth {0} smaller than MinLineWidth {1}.", maxLineWidth, minLineWidth);
+                this.LogWarn(
+                    "MaxLineWidth {0} smaller than MinLineWidth {1}.",
+                    maxLineWidth,
+                    minLineWidth
+                );
             }
         }
 
@@ -98,7 +103,10 @@
                 lineRenderer.positionCount = numSegments;
 
                 // ReSharper disable once CompareOfFloatsByEqualityOperator
-                float lineWidth = minLineWidth == maxLineWidth ? minLineWidth : PcgRandom.Instance.NextFloat(minLineWidth, maxLineWidth);
+                float lineWidth =
+                    minLineWidth == maxLineWidth
+                        ? minLineWidth
+                        : PRNG.Instance.NextFloat(minLineWidth, maxLineWidth);
 
                 lineRenderer.startWidth = lineWidth;
                 lineRenderer.endWidth = lineWidth;
@@ -106,12 +114,16 @@
                 float distanceMultiplier = _collider.radius;
 
                 float angle = 360f / numSegments;
-                float offsetRadians = PcgRandom.Instance.NextFloat(angle);
+                float offsetRadians = PRNG.Instance.NextFloat(angle);
                 float currentOffset = offsetRadians;
                 Vector3[] positions = new Vector3[numSegments];
                 for (int i = 0; i < numSegments; ++i)
                 {
-                    positions[i] = new Vector3(Mathf.Cos(Mathf.Deg2Rad * currentOffset), Mathf.Sin(Mathf.Deg2Rad * currentOffset)) * distanceMultiplier;
+                    positions[i] =
+                        new Vector3(
+                            Mathf.Cos(Mathf.Deg2Rad * currentOffset),
+                            Mathf.Sin(Mathf.Deg2Rad * currentOffset)
+                        ) * distanceMultiplier;
                     currentOffset += angle % 360f;
                 }
 

package/Tests/Runtime/DataStructures/SpatialTreeTests.cs

@@ -8,9 +8,10 @@
     using NUnit.Framework;
     using Vector2 = UnityEngine.Vector2;
 
-    public abstract class SpatialTreeTests<TTree> where TTree : ISpatialTree<Vector2>
+    public abstract class SpatialTreeTests<TTree>
+        where TTree : ISpatialTree<Vector2>
     {
-        private IRandom Random => PcgRandom.Instance;
+        private IRandom Random => PRNG.Instance;
 
         protected abstract TTree CreateTree(IEnumerable<Vector2> points);
 
@@ -28,14 +29,18 @@
                 do
                 {
                     point = Helpers.GetRandomPointInCircle(center, radius);
-                }
-                while (!points.Add(point));
+                } 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);
+            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;
@@ -43,8 +48,14 @@
 
             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);
+                0,
+                pointsInRange.Count,
+                "Found {0} points within {1} range of {2} (original center {3})",
+                pointsInRange.Count,
+                radius,
+                offset,
+                center
+            );
         }
 
         [Test]
@@ -58,10 +69,19 @@
             List<Vector2> points = new(1) { testPoint };
 
             TTree quadTree = CreateTree(points);
-            List<Vector2> pointsInRange = quadTree.GetElementsInRange(point, range * 0.99f).ToList();
+            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(
+                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]);
         }
 
@@ -95,7 +115,11 @@
             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());
+            Assert.IsTrue(
+                nearestNeighbors.All(neighbor => (neighbor - center).magnitude <= 5.6f),
+                "Max: {0}",
+                nearestNeighbors.Select(neighbor => (neighbor - center).magnitude).Max()
+            );
 
             center = new Vector2(-100, -100);
 

package/Tests/Runtime/Helper/ArrayConverterTests.cs

@@ -0,0 +1,19 @@
+namespace UnityHelpers.Tests.Tests.Runtime.Helper
+{
+    using System.Linq;
+    using Core.Helper;
+    using Core.Random;
+    using NUnit.Framework;
+
+    public sealed class ArrayConverterTests
+    {
+        [Test]
+        public void IntToByteArray()
+        {
+            int[] ints = Enumerable.Range(0, 1000).Select(_ => PRNG.Instance.Next()).ToArray();
+            byte[] bytes = ArrayConverter.IntArrayToByteArrayBlockCopy(ints);
+            int[] decoded = ArrayConverter.ByteArrayToIntArrayBlockCopy(bytes);
+            Assert.IsTrue(ints.SequenceEqual(decoded));
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 35d3b0e1ba0e43bbb9d899a44b36812a
+timeCreated: 1732492102

package/Tests/Runtime/Helper/WallMathTests.cs

@@ -0,0 +1,221 @@
+namespace UnityHelpers.Tests.Tests.Runtime.Helper
+{
+    using Core.Extension;
+    using Core.Helper;
+    using Core.Random;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class WallMathTests
+    {
+        private const int TestIterations = 10_000;
+
+        [Test]
+        public void ApproximatelyRandom()
+        {
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                float target = PRNG.Instance.NextFloat(-1_000, 1_000);
+                float delta = PRNG.Instance.NextFloat(0f, 10f);
+
+                float insideOffset = delta * PRNG.Instance.NextFloat();
+                if (PRNG.Instance.NextBool())
+                {
+                    insideOffset *= -1;
+                }
+
+                float inside = target + insideOffset;
+                Assert.IsTrue(
+                    target.Approximately(inside, delta),
+                    $"Target {target} is not close enough to {inside} with a delta of {delta}."
+                );
+
+                float outsideOffset = delta * PRNG.Instance.NextFloat(1.001f, 10f);
+                if (PRNG.Instance.NextBool())
+                {
+                    outsideOffset *= -1;
+                }
+
+                float outside = target + outsideOffset;
+                Assert.IsFalse(
+                    target.Approximately(outside, delta),
+                    $"Target {target} was unexpectedly close to {outside} with a delta of {delta}."
+                );
+            }
+        }
+
+        [Test]
+        public void ApproximatelyExpected()
+        {
+            Assert.IsTrue(0f.Approximately(0f, 0f));
+            Assert.IsTrue(0f.Approximately(0.5f, 1f));
+            Assert.IsFalse(0.001f.Approximately(0f, 0f));
+            Assert.IsFalse(100f.Approximately(5f, 2.4f));
+
+            Assert.IsTrue(0.001f.Approximately(0.0001f));
+        }
+
+        [Test]
+        public void ClampRectInsideRandom()
+        {
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                Vector2 position = PRNG.Instance.NextVector2InRange(10f);
+
+                Vector2 size;
+                do
+                {
+                    size = PRNG.Instance.NextVector2InRange(10f);
+                } while (size.x < 0 || size.y < 0);
+
+                Rect rect = new(position, size);
+
+                Vector2 inside = new(
+                    PRNG.Instance.NextFloat(rect.min.x, rect.max.x),
+                    PRNG.Instance.NextFloat(rect.min.y, rect.max.y)
+                );
+                Assert.IsTrue(rect.Contains(inside), $"Rect {rect} does not contain {inside}.");
+                Vector2 clamped = rect.Clamp(inside);
+                Assert.AreEqual(inside, clamped);
+            }
+        }
+
+        [Test]
+        public void ClampRectInsideExpected()
+        {
+            Rect rect = new Rect(Vector2.one, Vector2.one);
+            Vector2 clamped = rect.Clamp(rect.center);
+            Assert.AreEqual(rect.center, clamped);
+
+            Vector2 inside =
+                rect.center
+                + new Vector2(PRNG.Instance.NextFloat(0.1f), PRNG.Instance.NextFloat(0.1f));
+            clamped = rect.Clamp(inside);
+            Assert.AreEqual(
+                inside,
+                clamped,
+                $"Expected inside point {inside} unexpectedly was clamped to {clamped} for rect {rect}."
+            );
+        }
+
+        [Test]
+        public void ClampRectOutsideRandom()
+        {
+            Rect rect = new(Vector2.one, Vector2.one);
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                Vector2 outside;
+                do
+                {
+                    outside = PRNG.Instance.NextVector2InRange(10f, rect.center);
+                } while (rect.Contains(outside));
+
+                Vector2 originalOutside = outside;
+                Vector2 clamped = rect.Clamp(ref outside);
+                Debug.Log($"Clamped {originalOutside} to {clamped}.");
+                Assert.AreNotEqual(originalOutside, clamped);
+                Assert.AreEqual(clamped, outside);
+
+                // Shrink just a little to ensure within bounds, clamping will put it right on the edge
+                const float shrinkScaleToAccountForPrecision = 0.99f;
+                Vector2 delta = rect.center - clamped;
+                delta *= shrinkScaleToAccountForPrecision;
+                clamped = rect.center + delta;
+                Assert.IsTrue(
+                    rect.Contains(clamped),
+                    $"Expected rect {rect} to contain {clamped}, but it did not."
+                );
+            }
+        }
+
+        [Test]
+        public void ClampRectOutsideExpected()
+        {
+            Rect rect = new(Vector2.one, Vector2.one);
+            Vector2 outside = new(rect.center.x, 100f);
+            Vector2 clamped = rect.Clamp(ref outside);
+            Assert.AreEqual(clamped, outside);
+            Assert.AreEqual(new Vector2(rect.center.x, 2f), clamped);
+
+            // Shrink just a little to ensure within bounds, clamping will put it right on the edge
+            const float shrinkScaleToAccountForPrecision = 0.99f;
+            Vector2 delta = rect.center - clamped;
+            delta *= shrinkScaleToAccountForPrecision;
+            clamped = rect.center + delta;
+            Assert.IsTrue(
+                rect.Contains(clamped),
+                $"Expected rect to contain {clamped}, but it did not."
+            );
+        }
+
+        [Test]
+        public void ClampFloat()
+        {
+            float value = 1.25f;
+            float clamped = value.Clamp(0, 1);
+            Assert.AreEqual(1, clamped);
+            Assert.AreEqual(1.25f, value);
+
+            value = 0.5f;
+            clamped = value.Clamp(0, 1);
+            Assert.AreEqual(0.5f, clamped);
+            Assert.AreEqual(0.5f, value);
+        }
+
+        [Test]
+        public void WrappedIncrementWrapped()
+        {
+            int ten = 10;
+            int one = ten.WrappedIncrement(10);
+            Assert.AreEqual(1, one);
+            Assert.AreEqual(10, ten);
+
+            int toChangeToOne = 10;
+            int returned = WallMath.WrappedIncrement(ref toChangeToOne, 10);
+            Assert.AreEqual(1, returned);
+            Assert.AreEqual(1, toChangeToOne);
+        }
+
+        [Test]
+        public void WrappedIncrementUnwrapped()
+        {
+            int ten = 10;
+            int eleven = ten.WrappedIncrement(100);
+            Assert.AreEqual(11, eleven);
+            Assert.AreEqual(10, ten);
+
+            int toChangeToEleven = 10;
+            int returned = WallMath.WrappedIncrement(ref toChangeToEleven, 100);
+            Assert.AreEqual(11, returned);
+            Assert.AreEqual(11, toChangeToEleven);
+        }
+
+        [Test]
+        public void WrappedAddWrapped()
+        {
+            int ten = 10;
+            int two = ten.WrappedAdd(2, 10);
+            Assert.AreEqual(10, ten);
+            Assert.AreEqual(2, two);
+
+            int toChangeToTwo = 10;
+            int returned = WallMath.WrappedAdd(ref toChangeToTwo, 2, 10);
+            Assert.AreEqual(2, returned);
+            Assert.AreEqual(2, toChangeToTwo);
+        }
+
+        [Test]
+        public void WrappedAddUnwrapped()
+        {
+            int ten = 10;
+            int twelve = ten.WrappedAdd(2, 100);
+            Assert.AreEqual(10, ten);
+            Assert.AreEqual(12, twelve);
+
+            int toChangeToTwelve = 10;
+            int returned = WallMath.WrappedAdd(ref toChangeToTwelve, 2, 100);
+            Assert.AreEqual(12, returned);
+            Assert.AreEqual(12, toChangeToTwelve);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 11e0e2d4098d47159de89eff698b2510
+timeCreated: 1732563313

package/Tests/Runtime/Helper.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d1cf06665d214b7aa507e42eb1fdfbe4
+timeCreated: 1732492095

package/Tests/Runtime/Performance/SpatialTreePerformanceTest.cs

@@ -1,17 +1,18 @@
 namespace UnityHelpers.Tests.Performance
 {
-    using NUnit.Framework;
-    using System.Collections.Generic;
-    using System.Diagnostics;
     using System;
     using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
     using System.Linq;
     using System.Threading.Tasks;
-    using UnityEngine;
     using Core.DataStructure;
+    using NUnit.Framework;
+    using UnityEngine;
     using UnityEngine.TestTools;
 
-    public abstract class SpatialTreePerformanceTest<TTree> where TTree : ISpatialTree<Vector2>
+    public abstract class SpatialTreePerformanceTest<TTree>
+        where TTree : ISpatialTree<Vector2>
     {
         protected abstract TTree CreateTree(IEnumerable<Vector2> points);
 
@@ -23,11 +24,15 @@
 
             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);
-            });
+            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)
             {
@@ -37,7 +42,9 @@
             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) |");
+            UnityEngine.Debug.Log(
+                $"| Construction (1 million points) | {(int)Math.Floor(1 / timer.Elapsed.TotalSeconds)} ({timer.Elapsed.TotalSeconds} seconds total) |"
+            );
             Vector2 center = tree.Boundary.center;
             int count = 0;
             TimeSpan timeout = TimeSpan.FromSeconds(1);
@@ -47,10 +54,11 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(785456, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
 
-            UnityEngine.Debug.Log($"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius /= 2f;
             count = 0;
@@ -60,9 +68,10 @@
                 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)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Half | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius /= 2f;
             count = 0;
@@ -72,9 +81,10 @@
                 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)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Quarter | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius = 1f;
             count = 0;
@@ -84,9 +94,10 @@
                 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)} |");
+            } 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();
@@ -97,9 +108,10 @@
                 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)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 500 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 100;
             count = 0;
@@ -109,9 +121,10 @@
                 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)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 100 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 10;
             count = 0;
@@ -121,9 +134,10 @@
                 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)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 10 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 1;
             count = 0;
@@ -133,8 +147,7 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
             UnityEngine.Debug.Log($"| ANN - 1 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
         }
     }