Bug fixed in Pin methods, added unit tests

Author: Sergio0694

Microsoft.Toolkit.HighPerformance/Buffers/Internals/ArrayMemoryManager{TFrom,TTo}.cs

@@ -73,11 +73,11 @@ public override unsafe MemoryHandle Pin(int elementIndex = 0)
         {
             if ((uint)elementIndex >= (uint)(this.length * Unsafe.SizeOf<TFrom>() / Unsafe.SizeOf<TTo>()))
             {
-                ThrowArgumentExceptionForInvalidIndex();
+                ThrowArgumentOutOfRangeExceptionForInvalidIndex();
             }
 
             int
-                bytePrefix = this.offset + Unsafe.SizeOf<TFrom>(),
+                bytePrefix = this.offset * Unsafe.SizeOf<TFrom>(),
                 byteSuffix = elementIndex * Unsafe.SizeOf<TTo>(),
                 byteOffset = bytePrefix + byteSuffix;
 
@@ -126,7 +126,7 @@ public Memory<T> GetMemory<T>(int offset, int length)
         /// <summary>
         /// Throws an <see cref="ArgumentOutOfRangeException"/> when the target index for <see cref="Pin"/> is invalid.
         /// </summary>
-        private static void ThrowArgumentExceptionForInvalidIndex()
+        private static void ThrowArgumentOutOfRangeExceptionForInvalidIndex()
         {
             throw new ArgumentOutOfRangeException("elementIndex", "The input index is not in the valid range");
         }

Microsoft.Toolkit.HighPerformance/Buffers/Internals/ProxyMemoryManager{TFrom,TTo}.cs

@@ -64,7 +64,10 @@ public override MemoryHandle Pin(int elementIndex = 0)
                 ThrowArgumentExceptionForInvalidIndex();
             }
 
-            int byteOffset = elementIndex * Unsafe.SizeOf<TTo>();
+            int
+                bytePrefix = this.offset * Unsafe.SizeOf<TFrom>(),
+                byteSuffix = elementIndex * Unsafe.SizeOf<TTo>(),
+                byteOffset = bytePrefix + byteSuffix;
 
 #if NETSTANDARD1_4
             int
@@ -79,7 +82,7 @@ public override MemoryHandle Pin(int elementIndex = 0)
                 ThrowArgumentExceptionForInvalidAlignment();
             }
 
-            return this.memoryManager.Pin(this.length + shiftedOffset);
+            return this.memoryManager.Pin(shiftedOffset);
         }
 
         /// <inheritdoc/>

UnitTests/UnitTests.HighPerformance.Shared/Extensions/Test_MemoryExtensions.cs

@@ -397,6 +397,56 @@ public void Test_MemoryExtensions_FromMemoryManager_CastFromByteAndBack_WithSlic
             Assert.IsTrue(span1 == span2);
         }
 
+        [TestCategory("MemoryExtensions")]
+        [TestMethod]
+        [DataRow(64, 0, 0)]
+        [DataRow(64, 4, 0)]
+        [DataRow(64, 0, 4)]
+        [DataRow(64, 4, 4)]
+        [DataRow(64, 4, 0)]
+        [DataRow(256, 16, 0)]
+        [DataRow(256, 4, 16)]
+        [DataRow(256, 64, 0)]
+        [DataRow(256, 64, 8)]
+        public unsafe void Test_MemoryExtensions_FromArray_CastFromByte_Pin(int size, int preOffset, int postOffset)
+        {
+            var data = new byte[size];
+            Memory<byte> memoryOfBytes = data.AsMemory(preOffset);
+            Memory<float> memoryOfFloats = memoryOfBytes.Cast<byte, float>().Slice(postOffset);
+
+            using var handle = memoryOfFloats.Pin();
+
+            void* p1 = handle.Pointer;
+            void* p2 = Unsafe.AsPointer(ref data[preOffset + (postOffset * sizeof(float))]);
+
+            Assert.IsTrue(p1 == p2);
+        }
+
+        [TestCategory("MemoryExtensions")]
+        [TestMethod]
+        [DataRow(64, 0, 0)]
+        [DataRow(64, 4, 0)]
+        [DataRow(64, 0, 4)]
+        [DataRow(64, 4, 4)]
+        [DataRow(64, 4, 0)]
+        [DataRow(256, 16, 0)]
+        [DataRow(256, 4, 16)]
+        [DataRow(256, 64, 0)]
+        [DataRow(256, 64, 8)]
+        public unsafe void Test_MemoryExtensions_FromMemoryManager_CastFromByte_Pin(int size, int preOffset, int postOffset)
+        {
+            var data = new ArrayMemoryManager<byte>(size);
+            Memory<byte> memoryOfBytes = data.Memory.Slice(preOffset);
+            Memory<float> memoryOfFloats = memoryOfBytes.Cast<byte, float>().Slice(postOffset);
+
+            using var handle = memoryOfFloats.Pin();
+
+            void* p1 = handle.Pointer;
+            void* p2 = Unsafe.AsPointer(ref data.GetSpan()[preOffset + (postOffset * sizeof(float))]);
+
+            Assert.IsTrue(p1 == p2);
+        }
+
         [TestCategory("MemoryExtensions")]
         [TestMethod]
         public void Test_MemoryExtensions_EmptyMemoryStream()