Added unit tests for custom array pool overloads

Author: Sergio0694

UnitTests/UnitTests.HighPerformance.Shared/Buffers/Test_ArrayPoolBufferWriter{T}.cs

@@ -9,6 +9,7 @@
 using Microsoft.Toolkit.HighPerformance.Buffers;
 using Microsoft.Toolkit.HighPerformance.Extensions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using UnitTests.HighPerformance.Shared.Buffers;
 
 namespace UnitTests.HighPerformance.Buffers
 {
@@ -54,6 +55,51 @@ public void Test_ArrayPoolBufferWriterOfT_AllocateAndGetMemoryAndSpan()
             Assert.ThrowsException<ObjectDisposedException>(() => writer.Advance(1));
         }
 
+        [TestCategory("ArrayPoolBufferWriterOfT")]
+        [TestMethod]
+        public void Test_ArrayPoolBufferWriterOfT_AllocateFromCustomPoolAndGetMemoryAndSpan()
+        {
+            var pool = new TrackingArrayPool<byte>();
+
+            using (var writer = new ArrayPoolBufferWriter<byte>())
+            {
+                Assert.AreEqual(pool.RentedArrays.Count, 1);
+
+                Assert.AreEqual(writer.Capacity, 256);
+                Assert.AreEqual(writer.FreeCapacity, 256);
+                Assert.AreEqual(writer.WrittenCount, 0);
+                Assert.IsTrue(writer.WrittenMemory.IsEmpty);
+                Assert.IsTrue(writer.WrittenSpan.IsEmpty);
+
+                Span<byte> span = writer.GetSpan(43);
+
+                Assert.IsTrue(span.Length >= 43);
+
+                writer.Advance(43);
+
+                Assert.AreEqual(writer.Capacity, 256);
+                Assert.AreEqual(writer.FreeCapacity, 256 - 43);
+                Assert.AreEqual(writer.WrittenCount, 43);
+                Assert.AreEqual(writer.WrittenMemory.Length, 43);
+                Assert.AreEqual(writer.WrittenSpan.Length, 43);
+
+                Assert.ThrowsException<ArgumentOutOfRangeException>(() => writer.Advance(-1));
+                Assert.ThrowsException<ArgumentOutOfRangeException>(() => writer.GetMemory(-1));
+                Assert.ThrowsException<ArgumentException>(() => writer.Advance(1024));
+
+                writer.Dispose();
+
+                Assert.ThrowsException<ObjectDisposedException>(() => writer.WrittenMemory);
+                Assert.ThrowsException<ObjectDisposedException>(() => writer.WrittenSpan.Length);
+                Assert.ThrowsException<ObjectDisposedException>(() => writer.Capacity);
+                Assert.ThrowsException<ObjectDisposedException>(() => writer.FreeCapacity);
+                Assert.ThrowsException<ObjectDisposedException>(() => writer.Clear());
+                Assert.ThrowsException<ObjectDisposedException>(() => writer.Advance(1));
+            }
+
+            Assert.AreEqual(pool.RentedArrays.Count, 0);
+        }
+
         [TestCategory("ArrayPoolBufferWriterOfT")]
         [TestMethod]
         [ExpectedException(typeof(ArgumentOutOfRangeException))]

UnitTests/UnitTests.HighPerformance.Shared/Buffers/Test_MemoryOwner{T}.cs

@@ -3,10 +3,12 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Buffers;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.Toolkit.HighPerformance.Buffers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using UnitTests.HighPerformance.Shared.Buffers;
 
 namespace UnitTests.HighPerformance.Buffers
 {
@@ -30,6 +32,29 @@ public void Test_MemoryOwnerOfT_AllocateAndGetMemoryAndSpan()
             Assert.IsTrue(buffer.Span.ToArray().All(i => i == 42));
         }
 
+        [TestCategory("MemoryOwnerOfT")]
+        [TestMethod]
+        public void Test_MemoryOwnerOfT_AllocateFromCustomPoolAndGetMemoryAndSpan()
+        {
+            var pool = new TrackingArrayPool<int>();
+
+            using (var buffer = MemoryOwner<int>.Allocate(127, pool))
+            {
+                Assert.AreEqual(pool.RentedArrays.Count, 1);
+
+                Assert.IsTrue(buffer.Length == 127);
+                Assert.IsTrue(buffer.Memory.Length == 127);
+                Assert.IsTrue(buffer.Span.Length == 127);
+
+                buffer.Span.Fill(42);
+
+                Assert.IsTrue(buffer.Memory.Span.ToArray().All(i => i == 42));
+                Assert.IsTrue(buffer.Span.ToArray().All(i => i == 42));
+            }
+
+            Assert.AreEqual(pool.RentedArrays.Count, 0);
+        }
+
         [TestCategory("MemoryOwnerOfT")]
         [TestMethod]
         [ExpectedException(typeof(ArgumentOutOfRangeException))]

UnitTests/UnitTests.HighPerformance.Shared/Buffers/Test_SpanOwner{T}.cs

@@ -7,6 +7,7 @@
 using System.Linq;
 using Microsoft.Toolkit.HighPerformance.Buffers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using UnitTests.HighPerformance.Shared.Buffers;
 
 namespace UnitTests.HighPerformance.Buffers
 {
@@ -28,6 +29,27 @@ public void Test_SpanOwnerOfT_AllocateAndGetMemoryAndSpan()
             Assert.IsTrue(buffer.Span.ToArray().All(i => i == 42));
         }
 
+        [TestCategory("SpanOwnerOfT")]
+        [TestMethod]
+        public void Test_SpanOwnerOfT_AllocateFromCustomPoolAndGetMemoryAndSpan()
+        {
+            var pool = new TrackingArrayPool<int>();
+
+            using (var buffer = SpanOwner<int>.Allocate(127))
+            {
+                Assert.AreEqual(pool.RentedArrays.Count, 1);
+
+                Assert.IsTrue(buffer.Length == 127);
+                Assert.IsTrue(buffer.Span.Length == 127);
+
+                buffer.Span.Fill(42);
+
+                Assert.IsTrue(buffer.Span.ToArray().All(i => i == 42));
+            }
+
+            Assert.AreEqual(pool.RentedArrays.Count, 0);
+        }
+
         [TestCategory("SpanOwnerOfT")]
         [TestMethod]
         [ExpectedException(typeof(ArgumentOutOfRangeException))]

UnitTests/UnitTests.HighPerformance.Shared/Buffers/TrackingArrayPool{T}.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Buffers;
+using System.Collections.Generic;
+
+namespace UnitTests.HighPerformance.Shared.Buffers
+{
+    public sealed class TrackingArrayPool<T> : ArrayPool<T>
+    {
+        private readonly ArrayPool<T> pool = ArrayPool<T>.Create();
+
+        private readonly HashSet<T[]> arrays = new HashSet<T[]>();
+
+        /// <summary>
+        /// Gets the collection of currently rented out arrays
+        /// </summary>
+        public IReadOnlyCollection<T[]> RentedArrays => this.arrays;
+
+        /// <inheritdoc/>
+        public override T[] Rent(int minimumLength)
+        {
+            T[] array = this.pool.Rent(minimumLength);
+
+            this.arrays.Add(array);
+
+            return array;
+        }
+
+        /// <inheritdoc/>
+        public override void Return(T[] array, bool clearArray = false)
+        {
+            this.arrays.Remove(array);
+
+            this.pool.Return(array, clearArray);
+        }
+    }
+}

UnitTests/UnitTests.HighPerformance.Shared/UnitTests.HighPerformance.Shared.projitems

@@ -13,6 +13,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Buffers\Test_ArrayPoolBufferWriter{T}.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Buffers\Test_MemoryOwner{T}.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Buffers\Test_SpanOwner{T}.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Buffers\TrackingArrayPool{T}.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_ArrayExtensions.2D.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_ArrayExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_ArrayPoolExtensions.cs" />