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

package/Tests/Runtime/Extensions/IListExtensionTests.cs

@@ -1,12 +1,21 @@
 namespace UnityHelpers.Tests.Extensions
 {
     using System;
+    using System.Collections.Generic;
     using System.Linq;
     using Core.Extension;
+    using Core.Random;
     using NUnit.Framework;
 
     public sealed class IListExtensionTests
     {
+        private const int NumTries = 1_000;
+
+        private readonly struct IntComparer : IComparer<int>
+        {
+            public int Compare(int x, int y) => x.CompareTo(y);
+        }
+
         [Test]
         public void ShiftLeft()
         {
@@ -72,5 +81,24 @@
             Assert.Throws<ArgumentException>(() => input.Reverse(1, int.MaxValue));
             Assert.Throws<ArgumentException>(() => input.Reverse(1, int.MinValue));
         }
+
+        [Test]
+        public void InsertionSort()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int[] input = Enumerable
+                    .Range(0, 100)
+                    .Select(_ => PRNG.Instance.Next(int.MinValue, int.MaxValue))
+                    .ToArray();
+                int[] conventionalSorted = input.ToArray();
+                Array.Sort(conventionalSorted);
+
+                int[] insertionSorted = input.ToArray();
+                insertionSorted.InsertionSort(new IntComparer());
+                Assert.That(conventionalSorted, Is.EqualTo(insertionSorted));
+                Assert.That(input.OrderBy(x => x), Is.EqualTo(insertionSorted));
+            }
+        }
     }
 }

package/Tests/Runtime/Helper/ArrayConverterTests.cs

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

package/Tests/Runtime/Helper/FormattingHelperTests.cs

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

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

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

package/Tests/Runtime/Helper/ObjectHelperTests.cs

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