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

package/Tests/Runtime/Extensions/DictionaryExtensionTests.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 31368b65c8f54bed82bc38001ab86cba
+fileFormatVersion: 2
+guid: 31368b65c8f54bed82bc38001ab86cba
 timeCreated: 1720405525

package/Tests/Runtime/Extensions/EnumExtensionTests.cs

@@ -1,128 +1,128 @@
-namespace UnityHelpers.Tests.Extensions
-{
-    using Core.Extension;
-    using NUnit.Framework;
-    using UnityEngine.TestTools.Constraints;
-    using Is = NUnit.Framework.Is;
-
-    public sealed class EnumExtensionTests
-    {
-        private enum TestEnum
-        {
-            None = 0,
-            First = 1 << 0,
-            Second = 1 << 1,
-            Third = 1 << 2,
-        }
-
-        private enum TinyTestEnum : byte
-        {
-            None = 0,
-            First = 1 << 0,
-            Second = 1 << 1,
-            Third = 1 << 2,
-        }
-
-        private enum SmallTestEnum : short
-        {
-            None = 0,
-            First = 1 << 0,
-            Second = 1 << 1,
-            Third = 1 << 2,
-        }
-
-        private enum BigTestEnum : long
-        {
-            None = 0,
-            First = 1 << 0,
-            Second = 1 << 1,
-            Third = 1 << 2,
-        }
-
-        [Test]
-        public void HasFlagNoAlloc()
-        {
-            Assert.IsTrue(TestEnum.First.HasFlagNoAlloc(TestEnum.First));
-            Assert.IsFalse(TestEnum.First.HasFlagNoAlloc(TestEnum.Second));
-            Assert.IsTrue((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.First));
-            Assert.IsTrue((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.Second));
-            Assert.IsFalse((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.Third));
-            Assert.IsFalse(TestEnum.First.HasFlagNoAlloc((TestEnum.First | TestEnum.Second)));
-        }
-
-        [Test]
-        public void HasFlagNoAllocTiny()
-        {
-            Assert.IsTrue(TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.First));
-            Assert.IsFalse(TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.Second));
-            Assert.IsTrue(
-                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.First)
-            );
-            Assert.IsTrue(
-                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.Second)
-            );
-            Assert.IsFalse(
-                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.Third)
-            );
-            Assert.IsFalse(
-                TinyTestEnum.First.HasFlagNoAlloc((TinyTestEnum.First | TinyTestEnum.Second))
-            );
-        }
-
-        [Test]
-        public void HasFlagNoAllocSmall()
-        {
-            Assert.IsTrue(SmallTestEnum.First.HasFlagNoAlloc(SmallTestEnum.First));
-            Assert.IsFalse(SmallTestEnum.First.HasFlagNoAlloc(SmallTestEnum.Second));
-            Assert.IsTrue(
-                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.First)
-            );
-            Assert.IsTrue(
-                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.Second)
-            );
-            Assert.IsFalse(
-                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.Third)
-            );
-            Assert.IsFalse(
-                SmallTestEnum.First.HasFlagNoAlloc((SmallTestEnum.First | SmallTestEnum.Second))
-            );
-        }
-
-        [Test]
-        public void HasFlagNoAllocBig()
-        {
-            Assert.IsTrue(BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.First));
-            Assert.IsFalse(BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.Second));
-            Assert.IsTrue(
-                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.First)
-            );
-            Assert.IsTrue(
-                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.Second)
-            );
-            Assert.IsFalse(
-                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.Third)
-            );
-            Assert.IsFalse(
-                BigTestEnum.First.HasFlagNoAlloc((BigTestEnum.First | BigTestEnum.Second))
-            );
-        }
-
-        [Test]
-        public void HasFlagsNoAllocDoesNotAlloc()
-        {
-            Assert.That(
-                () =>
-                {
-                    TestEnum.First.HasFlagNoAlloc(TestEnum.First);
-                    TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.First);
-                    BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.First);
-
-                    TestEnum.First.HasFlagNoAlloc(TestEnum.Second);
-                    TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.Second);
-                    BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.Second);
-                },
-                Is.Not.AllocatingGCMemory()
-            );
-        }
-    }
-}
+namespace UnityHelpers.Tests.Extensions
+{
+    using Core.Extension;
+    using NUnit.Framework;
+    using UnityEngine.TestTools.Constraints;
+    using Is = NUnit.Framework.Is;
+
+    public sealed class EnumExtensionTests
+    {
+        private enum TestEnum
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum TinyTestEnum : byte
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum SmallTestEnum : short
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum BigTestEnum : long
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        [Test]
+        public void HasFlagNoAlloc()
+        {
+            Assert.IsTrue(TestEnum.First.HasFlagNoAlloc(TestEnum.First));
+            Assert.IsFalse(TestEnum.First.HasFlagNoAlloc(TestEnum.Second));
+            Assert.IsTrue((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.First));
+            Assert.IsTrue((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.Second));
+            Assert.IsFalse((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.Third));
+            Assert.IsFalse(TestEnum.First.HasFlagNoAlloc((TestEnum.First | TestEnum.Second)));
+        }
+
+        [Test]
+        public void HasFlagNoAllocTiny()
+        {
+            Assert.IsTrue(TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.First));
+            Assert.IsFalse(TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.Second));
+            Assert.IsTrue(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.First)
+            );
+            Assert.IsTrue(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.Third)
+            );
+            Assert.IsFalse(
+                TinyTestEnum.First.HasFlagNoAlloc((TinyTestEnum.First | TinyTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagNoAllocSmall()
+        {
+            Assert.IsTrue(SmallTestEnum.First.HasFlagNoAlloc(SmallTestEnum.First));
+            Assert.IsFalse(SmallTestEnum.First.HasFlagNoAlloc(SmallTestEnum.Second));
+            Assert.IsTrue(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.First)
+            );
+            Assert.IsTrue(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.Third)
+            );
+            Assert.IsFalse(
+                SmallTestEnum.First.HasFlagNoAlloc((SmallTestEnum.First | SmallTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagNoAllocBig()
+        {
+            Assert.IsTrue(BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.First));
+            Assert.IsFalse(BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.Second));
+            Assert.IsTrue(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.First)
+            );
+            Assert.IsTrue(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.Third)
+            );
+            Assert.IsFalse(
+                BigTestEnum.First.HasFlagNoAlloc((BigTestEnum.First | BigTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagsNoAllocDoesNotAlloc()
+        {
+            Assert.That(
+                () =>
+                {
+                    TestEnum.First.HasFlagNoAlloc(TestEnum.First);
+                    TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.First);
+                    BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.First);
+
+                    TestEnum.First.HasFlagNoAlloc(TestEnum.Second);
+                    TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.Second);
+                    BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.Second);
+                },
+                Is.Not.AllocatingGCMemory()
+            );
+        }
+    }
+}

package/Tests/Runtime/Extensions/EnumExtensionTests.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 08e6640512474d02bc94651af90a6ffd
+fileFormatVersion: 2
+guid: 08e6640512474d02bc94651af90a6ffd
 timeCreated: 1742771579

package/Tests/Runtime/Extensions/IListExtensionTests.cs

@@ -1,104 +1,104 @@
-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()
-        {
-            int[] input = Enumerable.Range(0, 10).ToArray();
-            for (int i = 0; i < input.Length * 2; ++i)
-            {
-                int[] shifted = input.ToArray();
-                shifted.Shift(-1 * i);
-                Assert.That(
-                    input.Skip(i % input.Length).Concat(input.Take(i % input.Length)),
-                    Is.EqualTo(shifted)
-                );
-            }
-        }
-
-        [Test]
-        public void ShiftRight()
-        {
-            int[] input = Enumerable.Range(0, 10).ToArray();
-            for (int i = 0; i < input.Length * 2; ++i)
-            {
-                int[] shifted = input.ToArray();
-                shifted.Shift(i);
-                Assert.That(
-                    input
-                        .Skip((input.Length * 3 - i) % input.Length)
-                        .Concat(input.Take((input.Length * 3 - i) % input.Length)),
-                    Is.EqualTo(shifted),
-                    $"Shift failed for amount {i}."
-                );
-            }
-        }
-
-        [Test]
-        public void Reverse()
-        {
-            int[] input = Enumerable.Range(0, 10).ToArray();
-            for (int i = 0; i < input.Length; ++i)
-            {
-                int[] shifted = input.ToArray();
-                shifted.Reverse(0, i);
-                Assert.That(
-                    input.Take(i + 1).Reverse().Concat(input.Skip(i + 1)),
-                    Is.EqualTo(shifted),
-                    $"Reverse failed for reversal from [0, {i}]."
-                );
-            }
-
-            // TODO
-        }
-
-        [Test]
-        public void ReverseInvalidArguments()
-        {
-            int[] input = Enumerable.Range(0, 10).ToArray();
-            Assert.Throws<ArgumentException>(() => input.Reverse(-1, 1));
-            Assert.Throws<ArgumentException>(() => input.Reverse(input.Length, 1));
-            Assert.Throws<ArgumentException>(() => input.Reverse(int.MaxValue, 1));
-            Assert.Throws<ArgumentException>(() => input.Reverse(int.MinValue, 1));
-
-            Assert.Throws<ArgumentException>(() => input.Reverse(1, -1));
-            Assert.Throws<ArgumentException>(() => input.Reverse(1, input.Length));
-            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));
-            }
-        }
-    }
-}
+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()
+        {
+            int[] input = Enumerable.Range(0, 10).ToArray();
+            for (int i = 0; i < input.Length * 2; ++i)
+            {
+                int[] shifted = input.ToArray();
+                shifted.Shift(-1 * i);
+                Assert.That(
+                    input.Skip(i % input.Length).Concat(input.Take(i % input.Length)),
+                    Is.EqualTo(shifted)
+                );
+            }
+        }
+
+        [Test]
+        public void ShiftRight()
+        {
+            int[] input = Enumerable.Range(0, 10).ToArray();
+            for (int i = 0; i < input.Length * 2; ++i)
+            {
+                int[] shifted = input.ToArray();
+                shifted.Shift(i);
+                Assert.That(
+                    input
+                        .Skip((input.Length * 3 - i) % input.Length)
+                        .Concat(input.Take((input.Length * 3 - i) % input.Length)),
+                    Is.EqualTo(shifted),
+                    $"Shift failed for amount {i}."
+                );
+            }
+        }
+
+        [Test]
+        public void Reverse()
+        {
+            int[] input = Enumerable.Range(0, 10).ToArray();
+            for (int i = 0; i < input.Length; ++i)
+            {
+                int[] shifted = input.ToArray();
+                shifted.Reverse(0, i);
+                Assert.That(
+                    input.Take(i + 1).Reverse().Concat(input.Skip(i + 1)),
+                    Is.EqualTo(shifted),
+                    $"Reverse failed for reversal from [0, {i}]."
+                );
+            }
+
+            // TODO
+        }
+
+        [Test]
+        public void ReverseInvalidArguments()
+        {
+            int[] input = Enumerable.Range(0, 10).ToArray();
+            Assert.Throws<ArgumentException>(() => input.Reverse(-1, 1));
+            Assert.Throws<ArgumentException>(() => input.Reverse(input.Length, 1));
+            Assert.Throws<ArgumentException>(() => input.Reverse(int.MaxValue, 1));
+            Assert.Throws<ArgumentException>(() => input.Reverse(int.MinValue, 1));
+
+            Assert.Throws<ArgumentException>(() => input.Reverse(1, -1));
+            Assert.Throws<ArgumentException>(() => input.Reverse(1, input.Length));
+            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/Extensions/RandomExtensionTests.cs

@@ -1,27 +1,27 @@
-namespace UnityHelpers.Tests.Extensions
-{
-    using System.Collections.Generic;
-    using Core.Extension;
-    using Core.Random;
-    using NUnit.Framework;
-    using UnityEngine;
-
-    public sealed class RandomExtensionTests
-    {
-        [Test]
-        public void NextVector2InRange()
-        {
-            HashSet<float> seenAngles = new();
-            for (int i = 0; i < 1_000; ++i)
-            {
-                Vector2 vector = PRNG.Instance.NextVector2(-100, 100);
-                float range = PRNG.Instance.NextFloat(100f);
-                Vector2 inRange = PRNG.Instance.NextVector2InRange(range, vector);
-                Assert.LessOrEqual(Vector2.Distance(vector, inRange), range);
-                seenAngles.Add(Vector2.SignedAngle(vector, inRange));
-            }
-
-            Assert.LessOrEqual(3, seenAngles.Count);
-        }
-    }
-}
+namespace UnityHelpers.Tests.Extensions
+{
+    using System.Collections.Generic;
+    using Core.Extension;
+    using Core.Random;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class RandomExtensionTests
+    {
+        [Test]
+        public void NextVector2InRange()
+        {
+            HashSet<float> seenAngles = new();
+            for (int i = 0; i < 1_000; ++i)
+            {
+                Vector2 vector = PRNG.Instance.NextVector2(-100, 100);
+                float range = PRNG.Instance.NextFloat(100f);
+                Vector2 inRange = PRNG.Instance.NextVector2InRange(range, vector);
+                Assert.LessOrEqual(Vector2.Distance(vector, inRange), range);
+                seenAngles.Add(Vector2.SignedAngle(vector, inRange));
+            }
+
+            Assert.LessOrEqual(3, seenAngles.Count);
+        }
+    }
+}

package/Tests/Runtime/Extensions/RandomExtensionTests.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 610d56fdeadc4caf9d50c75574db4204
+fileFormatVersion: 2
+guid: 610d56fdeadc4caf9d50c75574db4204
 timeCreated: 1732732306

package/Tests/Runtime/Extensions/StringExtensionTests.cs

@@ -1,31 +1,31 @@
-namespace UnityHelpers.Tests.Extensions
-{
-    using Core.Extension;
-    using NUnit.Framework;
-
-    public sealed class StringExtensionTests
-    {
-        [Test]
-        public void ToPascalCaseNominal()
-        {
-            Assert.AreEqual("PascalCase", "PascalCase".ToPascalCase());
-            Assert.AreEqual("PascalCase", "pascalCase".ToPascalCase());
-            Assert.AreEqual("PascalCase", "_pascalCase".ToPascalCase());
-            Assert.AreEqual("PascalCase", "_PascalCase".ToPascalCase());
-            Assert.AreEqual("PascalCase", "pascal case".ToPascalCase());
-            Assert.AreEqual("PascalCase", "  __Pascal____   ___Case__ ".ToPascalCase());
-        }
-
-        [Test]
-        public void ToPascalCaseCustomSeparator()
-        {
-            const string separator = ".";
-            Assert.AreEqual("Pascal.Case", "PascalCase".ToPascalCase(separator));
-            Assert.AreEqual("Pascal.Case", "pascalCase".ToPascalCase(separator));
-            Assert.AreEqual("Pascal.Case", "_pascalCase".ToPascalCase(separator));
-            Assert.AreEqual("Pascal.Case", "_PascalCase".ToPascalCase(separator));
-            Assert.AreEqual("Pascal.Case", "pascal case".ToPascalCase(separator));
-            Assert.AreEqual("Pascal.Case", "  __Pascal____   ___Case__ ".ToPascalCase(separator));
-        }
-    }
-}
+namespace UnityHelpers.Tests.Extensions
+{
+    using Core.Extension;
+    using NUnit.Framework;
+
+    public sealed class StringExtensionTests
+    {
+        [Test]
+        public void ToPascalCaseNominal()
+        {
+            Assert.AreEqual("PascalCase", "PascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "pascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "_pascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "_PascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "pascal case".ToPascalCase());
+            Assert.AreEqual("PascalCase", "  __Pascal____   ___Case__ ".ToPascalCase());
+        }
+
+        [Test]
+        public void ToPascalCaseCustomSeparator()
+        {
+            const string separator = ".";
+            Assert.AreEqual("Pascal.Case", "PascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "pascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "_pascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "_PascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "pascal case".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "  __Pascal____   ___Case__ ".ToPascalCase(separator));
+        }
+    }
+}

package/Tests/Runtime/Extensions/StringExtensionTests.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 522329788bc543aab266b1d91a8e2b47
+fileFormatVersion: 2
+guid: 522329788bc543aab266b1d91a8e2b47
 timeCreated: 1720391633

package/Tests/Runtime/Extensions.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 3b57270da98c4ce8bb8714dfb1603ee0
+fileFormatVersion: 2
+guid: 3b57270da98c4ce8bb8714dfb1603ee0
 timeCreated: 1720391613

package/Tests/Runtime/Helper/ArrayConverterTests.cs

@@ -1,19 +1,19 @@
-namespace UnityHelpers.Tests.Helper
-{
-    using System.Linq;
-    using NUnit.Framework;
-    using UnityHelpers.Core.Helper;
-    using UnityHelpers.Core.Random;
-
-    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));
-        }
-    }
-}
+namespace UnityHelpers.Tests.Helper
+{
+    using System.Linq;
+    using NUnit.Framework;
+    using UnityHelpers.Core.Helper;
+    using UnityHelpers.Core.Random;
+
+    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));
+        }
+    }
+}