com.wallstop-studios.unity-helpers 2.0.0-rc80.4 → 2.0.0-rc80.6

package/Runtime/Core/Extension/EnumExtensions.cs

@@ -12,142 +12,60 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
     public static class EnumNameCache<T>
         where T : struct, Enum
     {
-        private const int MaxDenseRange = 1024;
-
-        private static readonly bool UseDensePacking;
-        private static readonly int Min;
-        private static readonly string[] DenseNames;
-        private static readonly Dictionary<int, string> SparseNames;
+        private static readonly Dictionary<T, string> Names;
 
         static EnumNameCache()
         {
-            T[] values = Enum.GetValues(typeof(T)).Cast<T>().ToArray();
-            int[] intValues = values.Select(v => Unsafe.As<T, int>(ref v)).ToArray();
-            int min = intValues.Min();
-            int max = intValues.Max();
-            int range = max - min + 1;
-
-            if (range <= MaxDenseRange)
-            {
-                UseDensePacking = true;
-                Min = min;
-                DenseNames = new string[range];
-
-                for (int i = 0; i < values.Length; i++)
-                {
-                    int key = intValues[i] - min;
-                    T value = values[i];
-                    DenseNames[key] = value.ToString("G");
-                }
-            }
-            else
+            T[] values = Enum.GetValues(typeof(T)).OfType<T>().ToArray();
+            Names = new Dictionary<T, string>(values.Length);
+            for (int i = 0; i < values.Length; i++)
             {
-                UseDensePacking = false;
-                SparseNames = new Dictionary<int, string>();
-                for (int i = 0; i < values.Length; i++)
-                {
-                    int key = Unsafe.As<T, int>(ref values[i]);
-                    T value = values[i];
-                    string name = value.ToString("G");
-                    SparseNames.TryAdd(key, name);
-                }
+                T value = values[i];
+                string name = value.ToString("G");
+                Names.TryAdd(value, name);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static string ToCachedName(T value)
         {
-            int key = Unsafe.As<T, int>(ref value);
-            if (UseDensePacking)
+            if (Names.TryGetValue(value, out string name))
             {
-                int idx = key - Min;
-                if ((uint)idx < (uint)DenseNames!.Length)
-                {
-                    return DenseNames[idx];
-                }
-            }
-            else
-            {
-                if (SparseNames!.TryGetValue(key, out string name))
-                {
-                    return name;
-                }
+                return name;
             }
 
-            return value.ToString();
+            return value.ToString("G");
         }
     }
 
     public static class EnumDisplayNameCache<T>
         where T : struct, Enum
     {
-        private const int MaxDenseRange = 1024;
-
-        private static readonly bool UseDensePacking;
-        private static readonly int Min;
-        private static readonly string[] DenseNames;
-        private static readonly Dictionary<int, string> SparseNames;
+        private static readonly Dictionary<T, string> Names;
 
         static EnumDisplayNameCache()
         {
             Type type = typeof(T);
             FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Static);
-            T[] values = fields.Select(f => (T)f.GetValue(null)).ToArray();
-            int[] intValues = values.Select(v => Unsafe.As<T, int>(ref v)).ToArray();
-            int min = intValues.Min();
-            int max = intValues.Max();
-            int range = max - min + 1;
+            Names = new Dictionary<T, string>(fields.Length);
 
-            if (range <= MaxDenseRange)
+            for (int i = 0; i < fields.Length; i++)
             {
-                UseDensePacking = true;
-                Min = min;
-                DenseNames = new string[range];
-
-                for (int i = 0; i < fields.Length; i++)
-                {
-                    int key = intValues[i] - min;
-                    FieldInfo field = fields[i];
-                    string name = field.IsAttributeDefined(out EnumDisplayNameAttribute displayName)
-                        ? displayName.DisplayName
-                        : field.Name;
-                    DenseNames[key] = name;
-                }
-            }
-            else
-            {
-                UseDensePacking = false;
-                SparseNames = new Dictionary<int, string>(fields.Length);
-                for (int i = 0; i < fields.Length; i++)
-                {
-                    int key = Unsafe.As<T, int>(ref values[i]);
-                    FieldInfo field = fields[i];
-                    string name = field.IsAttributeDefined(out EnumDisplayNameAttribute displayName)
-                        ? displayName.DisplayName
-                        : field.Name;
-                    SparseNames.TryAdd(key, name);
-                }
+                FieldInfo field = fields[i];
+                string name = field.IsAttributeDefined(out EnumDisplayNameAttribute displayName)
+                    ? displayName.DisplayName
+                    : field.Name;
+                T value = (T)field.GetValue(null);
+                Names.TryAdd(value, name);
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static string ToDisplayName(T value)
         {
-            int key = Unsafe.As<T, int>(ref value);
-            if (UseDensePacking)
+            if (Names.TryGetValue(value, out string name))
             {
-                int idx = key - Min;
-                if ((uint)idx < (uint)DenseNames!.Length)
-                {
-                    return DenseNames[idx];
-                }
-            }
-            else
-            {
-                if (SparseNames!.TryGetValue(key, out string name))
-                {
-                    return name;
-                }
+                return name;
             }
 
             return value.ToString();
@@ -160,9 +78,15 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
         public static bool HasFlagNoAlloc<T>(this T value, T flag)
             where T : unmanaged, Enum
         {
-            ulong valueUnderlying = GetUInt64(value);
-            ulong flagUnderlying = GetUInt64(flag);
-            return (valueUnderlying & flagUnderlying) == flagUnderlying;
+            ulong? valueUnderlying = GetUInt64(value);
+            ulong? flagUnderlying = GetUInt64(flag);
+            if (valueUnderlying == null || flagUnderlying == null)
+            {
+                // Fallback for unsupported enum sizes
+                return value.HasFlag(flag);
+            }
+
+            return (valueUnderlying.Value & flagUnderlying.Value) == flagUnderlying.Value;
         }
 
         public static string ToDisplayName<T>(this T value)
@@ -190,23 +114,24 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe ulong GetUInt64<T>(T value)
+        private static ulong? GetUInt64<T>(T value)
             where T : unmanaged
         {
-            /*
-                Works because T is constrained to unmanaged, so it's safe to reinterpret
-                All enums are value types and have a fixed size
-             */
-            return sizeof(T) switch
+            try
             {
-                1 => *(byte*)&value,
-                2 => *(ushort*)&value,
-                4 => *(uint*)&value,
-                8 => *(ulong*)&value,
-                _ => throw new ArgumentException(
-                    $"Unsupported enum size: {sizeof(T)} for type {typeof(T)}"
-                ),
-            };
+                return Unsafe.SizeOf<T>() switch
+                {
+                    1 => Unsafe.As<T, byte>(ref value),
+                    2 => Unsafe.As<T, ushort>(ref value),
+                    4 => Unsafe.As<T, uint>(ref value),
+                    8 => Unsafe.As<T, ulong>(ref value),
+                    _ => null,
+                };
+            }
+            catch
+            {
+                return null;
+            }
         }
     }
 }

package/Runtime/Core/Threading/SingleThreadedThreadPool.cs

@@ -1,5 +1,6 @@
 namespace WallstopStudios.UnityHelpers.Core.Threading
 {
+#if !SINGLE_THREADED
     using System;
     using System.Collections.Concurrent;
     using System.Threading;
@@ -223,4 +224,5 @@ namespace WallstopStudios.UnityHelpers.Core.Threading
             }
         }
     }
+#endif
 }

package/Runtime/Utils/Buffers.cs

@@ -1,9 +1,11 @@
 namespace WallstopStudios.UnityHelpers.Utils
 {
     using System;
+    using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Reflection;
     using System.Text;
+    using System.Threading;
     using UnityEngine;
     using WallstopStudios.UnityHelpers.Core.Helper;
 
@@ -149,6 +151,200 @@ namespace WallstopStudios.UnityHelpers.Utils
         }
     }
 
+#if SINGLE_THREADED
+    public static class WallstopFastArrayPool<T>
+    {
+        private static readonly List<List<T[]>> _pool = new();
+        private static readonly Action<T[]> _onDispose = Release;
+
+        public static PooledResource<T[]> Get(int size)
+        {
+            switch (size)
+            {
+                case < 0:
+                {
+                    throw new ArgumentOutOfRangeException(
+                        nameof(size),
+                        size,
+                        "Must be non-negative."
+                    );
+                }
+                case 0:
+                {
+                    return new PooledResource<T[]>(Array.Empty<T>(), _ => { });
+                }
+            }
+
+            while (_pool.Count <= size)
+            {
+                _pool.Add(null);
+            }
+
+            List<T[]> pool = _pool[size];
+            if (pool == null)
+            {
+                pool = new List<T[]>();
+                _pool[size] = pool;
+            }
+
+            if (pool.Count == 0)
+            {
+                return new PooledResource<T[]>(new T[size], _onDispose);
+            }
+
+            int lastIndex = pool.Count - 1;
+            T[] instance = pool[lastIndex];
+            pool.RemoveAt(lastIndex);
+            return new PooledResource<T[]>(instance, _onDispose);
+        }
+
+        private static void Release(T[] resource)
+        {
+            _pool[resource.Length].Add(resource);
+        }
+    }
+#else
+
+    public static class WallstopFastArrayPool<T>
+    {
+        private static readonly ReaderWriterLockSlim _lock = new();
+        private static readonly List<ConcurrentStack<T[]>> _pool = new();
+        private static readonly Action<T[]> _onDispose = Release;
+
+        public static PooledResource<T[]> Get(int size)
+        {
+            switch (size)
+            {
+                case < 0:
+                {
+                    throw new ArgumentOutOfRangeException(
+                        nameof(size),
+                        size,
+                        "Must be non-negative."
+                    );
+                }
+                case 0:
+                {
+                    return new PooledResource<T[]>(Array.Empty<T>(), _ => { });
+                }
+            }
+
+            bool withinRange;
+            ConcurrentStack<T[]> pool = null;
+            _lock.EnterReadLock();
+            try
+            {
+                withinRange = size < _pool.Count;
+                if (withinRange)
+                {
+                    pool = _pool[size];
+                }
+            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }
+
+            if (withinRange)
+            {
+                if (pool == null)
+                {
+                    _lock.EnterUpgradeableReadLock();
+                    try
+                    {
+                        pool = _pool[size];
+                        if (pool == null)
+                        {
+                            _lock.EnterWriteLock();
+                            try
+                            {
+                                pool = _pool[size];
+                                if (pool == null)
+                                {
+                                    pool = new ConcurrentStack<T[]>();
+                                    _pool[size] = pool;
+                                }
+                            }
+                            finally
+                            {
+                                _lock.ExitWriteLock();
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        _lock.ExitUpgradeableReadLock();
+                    }
+                }
+            }
+            else
+            {
+                _lock.EnterUpgradeableReadLock();
+                try
+                {
+                    if (size < _pool.Count)
+                    {
+                        pool = _pool[size];
+                        if (pool == null)
+                        {
+                            _lock.EnterWriteLock();
+                            try
+                            {
+                                pool = _pool[size];
+                                if (pool == null)
+                                {
+                                    pool = new ConcurrentStack<T[]>();
+                                    _pool[size] = pool;
+                                }
+                            }
+                            finally
+                            {
+                                _lock.ExitWriteLock();
+                            }
+                        }
+                    }
+                    else
+                    {
+                        _lock.EnterWriteLock();
+                        try
+                        {
+                            while (_pool.Count <= size)
+                            {
+                                _pool.Add(null);
+                            }
+                            pool = _pool[size];
+                            if (pool == null)
+                            {
+                                pool = new ConcurrentStack<T[]>();
+                                _pool[size] = pool;
+                            }
+                        }
+                        finally
+                        {
+                            _lock.ExitWriteLock();
+                        }
+                    }
+                }
+                finally
+                {
+                    _lock.ExitUpgradeableReadLock();
+                }
+            }
+
+            if (pool.TryPop(out T[] instance))
+            {
+                return new PooledResource<T[]>(instance, _onDispose);
+            }
+            return new PooledResource<T[]>(new T[size], _onDispose);
+        }
+
+        private static void Release(T[] resource)
+        {
+            _pool[resource.Length].Push(resource);
+        }
+    }
+#endif
+
     public readonly struct PooledResource<T> : IDisposable
     {
         public readonly T resource;

package/Tests/Runtime/Core/Threading/SingleThreadedThreadPoolTests.cs

@@ -1,5 +1,6 @@
 namespace WallstopStudios.UnityHelpers.Tests.Core.Threading
 {
+#if !SINGLE_THREADED
     using System.Collections;
     using System.Collections.Generic;
     using NUnit.Framework;
@@ -51,4 +52,5 @@ namespace WallstopStudios.UnityHelpers.Tests.Core.Threading
             }
         }
     }
+#endif
 }

package/Tests/Runtime/Extensions/EnumExtensionTests.cs

@@ -2,6 +2,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
 {
     using NUnit.Framework;
     using UnityEngine.TestTools.Constraints;
+    using WallstopStudios.UnityHelpers.Core.Attributes;
     using WallstopStudios.UnityHelpers.Core.Extension;
     using Is = NUnit.Framework.Is;
 
@@ -26,8 +27,14 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
         private enum SmallTestEnum : short
         {
             None = 0,
+
+            [EnumDisplayName("TestFirst")]
             First = 1 << 0,
+
+            [EnumDisplayName("TestSecond")]
             Second = 1 << 1,
+
+            [EnumDisplayName("TestThird")]
             Third = 1 << 2,
         }
 
@@ -39,6 +46,24 @@ namespace WallstopStudios.UnityHelpers.Tests.Extensions
             Third = 1 << 2,
         }
 
+        [Test]
+        public void DisplayName()
+        {
+            Assert.AreEqual("None", SmallTestEnum.None.ToDisplayName());
+            Assert.AreEqual("TestFirst", SmallTestEnum.First.ToDisplayName());
+            Assert.AreEqual("TestSecond", SmallTestEnum.Second.ToDisplayName());
+            Assert.AreEqual("TestThird", SmallTestEnum.Third.ToDisplayName());
+        }
+
+        [Test]
+        public void CachedName()
+        {
+            Assert.AreEqual("None", SmallTestEnum.None.ToCachedName());
+            Assert.AreEqual("First", SmallTestEnum.First.ToCachedName());
+            Assert.AreEqual("Second", SmallTestEnum.Second.ToCachedName());
+            Assert.AreEqual("Third", SmallTestEnum.Third.ToCachedName());
+        }
+
         [Test]
         public void HasFlagNoAlloc()
         {

package/Tests/Runtime/Utils/BuffersTests.cs

@@ -1,9 +1,18 @@
 namespace WallstopStudios.UnityHelpers.Tests.Utils
 {
+    using System;
+    using System.Collections;
     using System.Collections.Generic;
+    using System.Linq;
     using NUnit.Framework;
+    using UnityEngine.TestTools;
+    using WallstopStudios.UnityHelpers.Core.Extension;
     using WallstopStudios.UnityHelpers.Core.Random;
     using WallstopStudios.UnityHelpers.Utils;
+#if !SINGLETHREADED
+    using System.Threading;
+    using System.Threading.Tasks;
+#endif
 
     public sealed class BuffersTests
     {
@@ -51,5 +60,661 @@ namespace WallstopStudios.UnityHelpers.Tests.Utils
                 }
             }
         }
+
+        [Test]
+        public void WallstopFastArrayPoolGetNegativeSizeThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => WallstopFastArrayPool<int>.Get(-1));
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolGetZeroSizeReturnsEmptyArrayWithNoOpDispose()
+        {
+            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(0);
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(0, pooled.resource.Length);
+            Assert.AreSame(Array.Empty<int>(), pooled.resource);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolGetPositiveSizeReturnsArrayWithCorrectLength()
+        {
+            const int size = 10;
+            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size);
+
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(size, pooled.resource.Length);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolGetSameSizeReusesArrayAfterDispose()
+        {
+            const int size = 5;
+            int[] firstArray;
+
+            using (PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size))
+            {
+                firstArray = pooled.resource;
+                firstArray[0] = 42;
+            }
+
+            using PooledResource<int[]> pooledReused = WallstopFastArrayPool<int>.Get(size);
+            Assert.AreSame(firstArray, pooledReused.resource);
+            Assert.AreEqual(42, pooledReused.resource[0]);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolGetDifferentSizesReturnsCorrectArrays()
+        {
+            int[] sizes = { 1, 5, 10, 100, 1000 };
+            List<PooledResource<int[]>> pooledArrays = new();
+
+            try
+            {
+                foreach (int size in sizes)
+                {
+                    PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size);
+                    pooledArrays.Add(pooled);
+                    Assert.AreEqual(size, pooled.resource.Length);
+                }
+            }
+            finally
+            {
+                foreach (PooledResource<int[]> pooled in pooledArrays)
+                {
+                    pooled.Dispose();
+                }
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolArraysNotClearedOnRelease()
+        {
+            const int size = 10;
+
+            using (PooledResource<string[]> pooled = WallstopFastArrayPool<string>.Get(size))
+            {
+                for (int i = 0; i < size; i++)
+                {
+                    pooled.resource[i] = $"test{i}";
+                }
+            }
+
+            using PooledResource<string[]> pooledReused = WallstopFastArrayPool<string>.Get(size);
+            for (int i = 0; i < size; i++)
+            {
+                Assert.AreEqual($"test{i}", pooledReused.resource[i]);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolPoolGrowsAsNeeded()
+        {
+            const int size = 7;
+            const int count = 5;
+            List<PooledResource<int[]>> pooledArrays = new();
+
+            try
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size);
+                    pooledArrays.Add(pooled);
+                    Assert.AreEqual(size, pooled.resource.Length);
+                }
+
+                HashSet<int[]> distinctArrays = pooledArrays.Select(p => p.resource).ToHashSet();
+                Assert.AreEqual(count, distinctArrays.Count);
+            }
+            finally
+            {
+                foreach (PooledResource<int[]> pooled in pooledArrays)
+                {
+                    pooled.Dispose();
+                }
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolDifferentTypesUseDifferentPools()
+        {
+            const int size = 10;
+
+            using PooledResource<int[]> intPooled = WallstopFastArrayPool<int>.Get(size);
+            using PooledResource<string[]> stringPooled = WallstopFastArrayPool<string>.Get(size);
+            using PooledResource<float[]> floatPooled = WallstopFastArrayPool<float>.Get(size);
+
+            Assert.AreEqual(size, intPooled.resource.Length);
+            Assert.AreEqual(size, stringPooled.resource.Length);
+            Assert.AreEqual(size, floatPooled.resource.Length);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolLargeArraysWork()
+        {
+            const int size = 100000;
+            using PooledResource<byte[]> pooled = WallstopFastArrayPool<byte>.Get(size);
+
+            Assert.AreEqual(size, pooled.resource.Length);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolNestedUsageWorks()
+        {
+            const int outerSize = 5;
+            const int innerSize = 3;
+
+            using PooledResource<int[]> outer = WallstopFastArrayPool<int>.Get(outerSize);
+            Assert.AreEqual(outerSize, outer.resource.Length);
+            Array.Clear(outer.resource, 0, outer.resource.Length);
+            outer.resource[0] = 1;
+
+            using (PooledResource<int[]> inner = WallstopFastArrayPool<int>.Get(innerSize))
+            {
+                inner.resource[0] = 2;
+                Assert.AreEqual(innerSize, inner.resource.Length);
+                Assert.AreEqual(1, outer.resource[0]);
+                Assert.AreEqual(2, inner.resource[0]);
+            }
+
+            Assert.AreEqual(outerSize, outer.resource.Length);
+            Assert.AreEqual(1, outer.resource[0]);
+        }
+
+        [UnityTest]
+        public IEnumerator WallstopFastArrayPoolStressTest()
+        {
+            const int iterations = 1000;
+            const int maxSize = 100;
+            Random random = new(42);
+
+            for (int i = 0; i < iterations; i++)
+            {
+                int size = random.Next(1, maxSize);
+                using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(size);
+
+                Assert.AreEqual(size, pooled.resource.Length);
+
+                for (int j = 0; j < Math.Min(10, size); j++)
+                {
+                    pooled.resource[j] = random.Next();
+                }
+
+                if (i % 100 == 0)
+                {
+                    yield return null;
+                }
+            }
+        }
+
+#if !SINGLETHREADED
+        [Test]
+        public void WallstopFastArrayPoolConcurrentAccessDifferentSizes()
+        {
+            const int threadCount = 10;
+            const int operationsPerThread = 100;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(async () =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            int size = random.Next(1, 50) + threadId;
+                            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(
+                                size
+                            );
+
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            for (int j = 0; j < Math.Min(5, size); j++)
+                            {
+                                pooled.resource[j] = threadId * 1000 + i * 10 + j;
+                            }
+
+                            await Task.Delay(TimeSpan.FromMilliseconds(random.NextDouble()));
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolConcurrentAccessSameSize()
+        {
+            const int threadCount = 8;
+            const int operationsPerThread = 200;
+            const int arraySize = 25;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(
+                                arraySize
+                            );
+
+                            Array.Clear(pooled.resource, 0, pooled.resource.Length);
+                            Assert.AreEqual(arraySize, pooled.resource.Length);
+
+                            for (int j = 0; j < arraySize; j++)
+                            {
+                                Assert.AreEqual(0, pooled.resource[j]);
+                                pooled.resource[j] = threadId * 1000 + i;
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolConcurrentAccessMixedSizes()
+        {
+            const int threadCount = 6;
+            const int operationsPerThread = 150;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+            int[] sizes = { 1, 5, 10, 20, 50, 100 };
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(async () =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId + 100);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            int size = random.NextOf(sizes);
+                            using PooledResource<string[]> pooled =
+                                WallstopFastArrayPool<string>.Get(size);
+                            Array.Clear(pooled.resource, 0, pooled.resource.Length);
+
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            for (int j = 0; j < size; j++)
+                            {
+                                Assert.IsNull(pooled.resource[j]);
+                                pooled.resource[j] = $"T{threadId}-I{i}-J{j}";
+                            }
+
+                            if (i % 50 == 0)
+                            {
+                                await Task.Delay(TimeSpan.FromMilliseconds(random.NextDouble()));
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolConcurrentAccessRapidAllocationDeallocation()
+        {
+            const int threadCount = 12;
+            const int operationsPerThread = 500;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId + 100);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            int size = random.Next(1, 30);
+                            using PooledResource<byte[]> pooled = WallstopFastArrayPool<byte>.Get(
+                                size
+                            );
+
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            for (int j = 0; j < size; j++)
+                            {
+                                pooled.resource[j] = (byte)(threadId + i + j);
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolThreadSafetyPoolExpansion()
+        {
+            const int threadCount = 8;
+            const int maxPoolSize = 1000;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+            Barrier barrier = new(threadCount);
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        barrier.SignalAndWait();
+
+                        for (int size = threadId + 1; size <= maxPoolSize; size += threadCount)
+                        {
+                            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(
+                                size
+                            );
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            pooled.resource[0] = threadId;
+                            pooled.resource[size - 1] = threadId;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                });
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator WallstopFastArrayPoolConcurrentStressTest()
+        {
+            const int threadCount = 4;
+            const int operationsPerThread = 250;
+            Task[] tasks = new Task[threadCount];
+            List<Exception> exceptions = new();
+            int completedThreads = 0;
+
+            for (int t = 0; t < threadCount; t++)
+            {
+                int threadId = t;
+                tasks[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        PcgRandom random = new(threadId + 100);
+                        foreach (int i in Enumerable.Range(0, operationsPerThread).Shuffled(random))
+                        {
+                            int size = random.Next(1, 100);
+                            using PooledResource<float[]> pooled = WallstopFastArrayPool<float>.Get(
+                                size
+                            );
+
+                            Assert.AreEqual(size, pooled.resource.Length);
+
+                            for (int j = 0; j < Math.Min(10, size); j++)
+                            {
+                                pooled.resource[j] = threadId * 1000.0f + i + j * 0.1f;
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        lock (exceptions)
+                        {
+                            exceptions.Add(ex);
+                        }
+                    }
+                    finally
+                    {
+                        Interlocked.Increment(ref completedThreads);
+                    }
+                });
+            }
+
+            while (completedThreads < threadCount)
+            {
+                yield return null;
+            }
+
+            Task.WaitAll(tasks);
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
+        }
+#endif
+
+        [Test]
+        public void WallstopFastArrayPoolEdgeCaseVeryLargeSize()
+        {
+            const int veryLargeSize = 1000000;
+            using PooledResource<int[]> pooled = WallstopFastArrayPool<int>.Get(veryLargeSize);
+
+            Assert.AreEqual(veryLargeSize, pooled.resource.Length);
+            Assert.AreEqual(0, pooled.resource[0]);
+            Assert.AreEqual(0, pooled.resource[veryLargeSize - 1]);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolEdgeCaseSizeOne()
+        {
+            using PooledResource<string[]> pooled = WallstopFastArrayPool<string>.Get(1);
+            Array.Clear(pooled.resource, 0, pooled.resource.Length);
+            Assert.AreEqual(1, pooled.resource.Length);
+            Assert.IsNull(pooled.resource[0]);
+
+            pooled.resource[0] = "test";
+            Assert.AreEqual("test", pooled.resource[0]);
+        }
+
+        [Test]
+        public void WallstopFastArrayPoolPoolingBehaviorLifo()
+        {
+            const int size = 15;
+            int[][] arrays = new int[3][];
+            {
+                using PooledResource<int[]> pooled1 = WallstopFastArrayPool<int>.Get(size);
+                arrays[0] = pooled1.resource;
+                using PooledResource<int[]> pooled2 = WallstopFastArrayPool<int>.Get(size);
+                arrays[1] = pooled2.resource;
+                using PooledResource<int[]> pooled3 = WallstopFastArrayPool<int>.Get(size);
+                arrays[2] = pooled3.resource;
+            }
+
+            using PooledResource<int[]> pooledReuse1 = WallstopFastArrayPool<int>.Get(size);
+            Assert.AreSame(arrays[0], pooledReuse1.resource);
+
+            using PooledResource<int[]> pooledReuse2 = WallstopFastArrayPool<int>.Get(size);
+            Assert.AreSame(arrays[1], pooledReuse2.resource);
+
+            using PooledResource<int[]> pooledReuse3 = WallstopFastArrayPool<int>.Get(size);
+            Assert.AreSame(arrays[2], pooledReuse3.resource);
+        }
+
+        [Test]
+        public void WallstopArrayPoolGetNegativeSizeThrowsArgumentOutOfRangeException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => WallstopArrayPool<int>.Get(-1));
+        }
+
+        [Test]
+        public void WallstopArrayPoolGetZeroSizeReturnsEmptyArrayWithNoOpDispose()
+        {
+            using PooledResource<int[]> pooled = WallstopArrayPool<int>.Get(0);
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(0, pooled.resource.Length);
+            Assert.AreSame(Array.Empty<int>(), pooled.resource);
+        }
+
+        [Test]
+        public void WallstopArrayPoolGetPositiveSizeReturnsArrayWithCorrectLength()
+        {
+            const int size = 10;
+            using PooledResource<int[]> pooled = WallstopArrayPool<int>.Get(size);
+
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(size, pooled.resource.Length);
+        }
+
+        [Test]
+        public void WallstopArrayPoolGetSameSizeReusesArrayAfterDispose()
+        {
+            const int size = 5;
+            int[] firstArray;
+
+            using (PooledResource<int[]> pooled = WallstopArrayPool<int>.Get(size))
+            {
+                firstArray = pooled.resource;
+                firstArray[0] = 42;
+            }
+
+            using PooledResource<int[]> pooledReused = WallstopArrayPool<int>.Get(size);
+            Assert.AreSame(firstArray, pooledReused.resource);
+            Assert.AreEqual(0, pooledReused.resource[0]);
+        }
+
+        [Test]
+        public void WallstopGenericPoolGetReturnsValidPooledResource()
+        {
+            using PooledResource<List<int>> pooled = WallstopGenericPool<List<int>>.Get();
+
+            Assert.NotNull(pooled.resource);
+            Assert.AreEqual(0, pooled.resource.Count);
+        }
+
+        [Test]
+        public void WallstopGenericPoolGetReusesInstanceAfterDispose()
+        {
+            List<int> firstList;
+
+            using (PooledResource<List<int>> pooled = WallstopGenericPool<List<int>>.Get())
+            {
+                firstList = pooled.resource;
+                firstList.Add(42);
+                firstList.Add(100);
+            }
+
+            using PooledResource<List<int>> pooledReused = WallstopGenericPool<List<int>>.Get();
+            Assert.AreSame(firstList, pooledReused.resource);
+            Assert.AreEqual(0, pooledReused.resource.Count);
+        }
+
+        [Test]
+        public void WallstopGenericPoolClearActionWorksWithCustomType()
+        {
+            using PooledResource<HashSet<string>> pooled = WallstopGenericPool<
+                HashSet<string>
+            >.Get();
+
+            pooled.resource.Add("test1");
+            pooled.resource.Add("test2");
+            Assert.AreEqual(2, pooled.resource.Count);
+        }
+
+        [Test]
+        public void PooledResourceDisposeCallsOnDisposeAction()
+        {
+            bool disposeCalled = false;
+            WallstopGenericPool<List<int>>.clearAction ??= list => list.Clear();
+            WallstopGenericPool<List<int>>.clearAction += Callback;
+            try
+            {
+                using (PooledResource<List<int>> pooled = WallstopGenericPool<List<int>>.Get())
+                {
+                    Assert.NotNull(pooled.resource);
+                    Assert.IsFalse(disposeCalled);
+                }
+
+                Assert.IsTrue(disposeCalled);
+            }
+            finally
+            {
+                WallstopGenericPool<List<int>>.clearAction -= Callback;
+            }
+
+            return;
+            void Callback(List<int> list)
+            {
+                disposeCalled = true;
+            }
+        }
     }
 }

package/package.json

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