Added comments to unit tests

Author: Sergio0694

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

@@ -130,6 +130,12 @@ public void Test_MemoryOwnerOfT_AllocateAndGetArray()
         {
             var buffer = MemoryOwner<int>.Allocate(127);
 
+            // Here we allocate a MemoryOwner<T> instance with a requested size of 127, which means it
+            // internally requests an array of size 127 from ArrayPool<T>.Shared. We then get the array
+            // segment, so we need to verify that (since buffer is not disposed) the returned array is
+            // not null, is of size >= the requested one (since ArrayPool<T> by definition returns an
+            // array that is at least of the requested size), and that the offset and count properties
+            // match our input values (same length, and offset at 0 since the buffer was not sliced).
             var segment = buffer.DangerousGetArray();
 
             Assert.IsNotNull(segment.Array);
@@ -139,10 +145,14 @@ public void Test_MemoryOwnerOfT_AllocateAndGetArray()
 
             var second = buffer.Slice(10, 80);
 
+            // The original buffer instance is disposed here, because calling Slice transfers
+            // the ownership of the internal buffer to the new instance (this is documented in
+            // XML docs for the MemoryOwner<T>.Slice method).
             Assert.ThrowsException<ObjectDisposedException>(() => buffer.DangerousGetArray());
 
             segment = second.DangerousGetArray();
 
+            // Same as before, but we now also verify the initial offset != 0, as we used Slice
             Assert.IsNotNull(segment.Array);
             Assert.IsTrue(segment.Array.Length >= second.Length);
             Assert.AreEqual(segment.Offset, 10);

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

@@ -88,6 +88,10 @@ public void Test_SpanOwnerOfT_AllocateAndGetArray()
 
             var segment = buffer.DangerousGetArray();
 
+            // See comments in the MemoryOwner<T> tests about this. The main difference
+            // here is that we don't do the disposed checks, as SpanOwner<T> is optimized
+            // with the assumption that usages after dispose are undefined behavior. This
+            // is all documented in the XML docs for the SpanOwner<T> type.
             Assert.IsNotNull(segment.Array);
             Assert.IsTrue(segment.Array.Length >= buffer.Length);
             Assert.AreEqual(segment.Offset, 0);