Even more tests

Author: pakrym

shared/Microsoft.Extensions.Buffers.MemoryPool.Sources/MemoryPoolBlock.Debug.cs

@@ -71,7 +71,15 @@ protected override void Dispose(bool disposing)
             }
         }
 
-        public override Span<byte> GetSpan() => new Span<byte>(_slab.Array, _offset, _length);
+        public override Span<byte> GetSpan()
+        {
+            if (!_slab.IsActive)
+            {
+                MemoryPoolThrowHelper.ThrowObjectDisposedException(MemoryPoolThrowHelper.ExceptionArgument.MemoryPoolBlock);
+            }
+
+            return new Span<byte>(_slab.Array, _offset, _length);
+        }
 
         public override MemoryHandle Pin(int byteOffset = 0)
         {
@@ -95,6 +103,11 @@ public override MemoryHandle Pin(int byteOffset = 0)
 
         protected override bool TryGetArray(out ArraySegment<byte> segment)
         {
+            if (!_slab.IsActive)
+            {
+                MemoryPoolThrowHelper.ThrowObjectDisposedException(MemoryPoolThrowHelper.ExceptionArgument.MemoryPoolBlock);
+            }
+
             segment = new ArraySegment<byte>(_slab.Array, _offset, _length);
             return true;
         }

test/Microsoft.Extensions.Internal.Test/MemoryPoolTests.Debug.cs

@@ -5,6 +5,7 @@
 
 using System;
 using System.Buffers;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.Extensions.Internal.Test
@@ -31,6 +32,67 @@ public void DisposeWithActiveBlocksThrows()
             exception = Assert.Throws<InvalidOperationException>(() => block.Dispose());
             Assert.Equal("Block is being returned to disposed pool", exception.Message);
         }
+
+        [Fact]
+        public void GetMemoryOfDisposedThrows()
+        {
+            var memoryPool = new SlabMemoryPool();
+            var block = memoryPool.Rent();
+
+            var exception = Assert.Throws<InvalidOperationException>(() => memoryPool.Dispose());
+            Assert.Equal("Memory pool with active blocks is being disposed, 30 of 31 returned", exception.Message);
+
+            exception = Assert.Throws<ObjectDisposedException>(() => block.Memory);
+            Assert.Equal("Cannot access a disposed object.\r\nObject name: 'MemoryPoolBlock'.", exception.Message);
+        }
+
+        [Fact]
+        public void GetMemoryPinOfDisposedThrows()
+        {
+            var memoryPool = new SlabMemoryPool();
+            var block = memoryPool.Rent();
+            var memory = block.Memory;
+            var exception = Assert.Throws<InvalidOperationException>(() => memoryPool.Dispose());
+            Assert.Equal("Memory pool with active blocks is being disposed, 30 of 31 returned", exception.Message);
+
+            exception = Assert.Throws<ObjectDisposedException>(() => memory.Pin());
+            Assert.Equal("Cannot access a disposed object.\r\nObject name: 'MemoryPoolBlock'.", exception.Message);
+        }
+
+        [Fact]
+        public void GetMemorySpanOfDisposedThrows()
+        {
+            var memoryPool = new SlabMemoryPool();
+            var block = memoryPool.Rent();
+            var memory = block.Memory;
+            var exception = Assert.Throws<InvalidOperationException>(() => memoryPool.Dispose());
+            Assert.Equal("Memory pool with active blocks is being disposed, 30 of 31 returned", exception.Message);
+
+            var threw = false;
+            try
+            {
+                _ = memory.Span;
+            }
+            catch (ObjectDisposedException ode)
+            {
+                threw = true;
+                Assert.Equal("Cannot access a disposed object.\r\nObject name: 'MemoryPoolBlock'.", ode.Message);
+            }
+            Assert.True(threw);
+        }
+
+        [Fact]
+        public void GetMemoryTryGetArrayOfDisposedThrows()
+        {
+            var memoryPool = new SlabMemoryPool();
+            var block = memoryPool.Rent();
+            var memory = block.Memory;
+            var exception = Assert.Throws<InvalidOperationException>(() => memoryPool.Dispose());
+            Assert.Equal("Memory pool with active blocks is being disposed, 30 of 31 returned", exception.Message);
+
+            exception = Assert.Throws<ObjectDisposedException>(() => MemoryMarshal.TryGetArray<byte>(memory, out _));
+            Assert.Equal("Cannot access a disposed object.\r\nObject name: 'MemoryPoolBlock'.", exception.Message);
+        }
     }
 }