Allow zero byte reads on the test server response body #41692 (#44020)

Author: Tratcher

src/Hosting/TestHost/src/ResponseBodyReaderStream.cs

@@ -70,7 +70,7 @@ public override int Read(byte[] buffer, int offset, int count)
 
         public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
-            VerifyBuffer(buffer, offset, count);
+            ValidateBufferArguments(buffer, offset, count);
             CheckAborted();
 
             if (_readerComplete)
@@ -101,22 +101,6 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
             return (int)actual;
         }
 
-        private static void VerifyBuffer(byte[] buffer, int offset, int count)
-        {
-            if (buffer == null)
-            {
-                throw new ArgumentNullException(nameof(buffer));
-            }
-            if (offset < 0 || offset > buffer.Length)
-            {
-                throw new ArgumentOutOfRangeException(nameof(offset), offset, string.Empty);
-            }
-            if (count <= 0 || count > buffer.Length - offset)
-            {
-                throw new ArgumentOutOfRangeException(nameof(count), count, string.Empty);
-            }
-        }
-
         internal void Cancel()
         {
             Abort(new OperationCanceledException());

src/Hosting/TestHost/test/ResponseBodyTests.cs

@@ -122,6 +122,40 @@ public async Task BodyStream_SyncEnabled_FlushSucceeds()
             Assert.Equal(contentBytes, responseBytes);
         }
 
+        [Fact]
+        public async Task BodyStream_ZeroByteRead_Success()
+        {
+            var emptyReadStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            var contentBytes = new byte[] { 32 };
+            using var host = await CreateHost(async httpContext =>
+            {
+                await httpContext.Response.Body.WriteAsync(contentBytes);
+                await emptyReadStarted.Task;
+                await httpContext.Response.Body.WriteAsync(contentBytes);
+            });
+
+            var client = host.GetTestServer().CreateClient();
+            var response = await client.GetAsync("/", HttpCompletionOption.ResponseHeadersRead);
+            var stream = await response.Content.ReadAsStreamAsync();
+            var bytes = new byte[5];
+            var read = await stream.ReadAsync(bytes);
+            Assert.Equal(1, read);
+            Assert.Equal(contentBytes[0], bytes[0]);
+
+            // This will chain to the Memory overload, but that does less restrictive validation on the input.
+            // https://github.com/dotnet/aspnetcore/issues/41692#issuecomment-1248714684
+            var zeroByteRead = stream.ReadAsync(Array.Empty<byte>(), 0, 0);
+            Assert.False(zeroByteRead.IsCompleted);
+            emptyReadStarted.SetResult();
+            read = await zeroByteRead;
+            Assert.Equal(0, read);
+
+            read = await stream.ReadAsync(bytes);
+            Assert.Equal(1, read);
+            Assert.Equal(contentBytes[0], bytes[0]);
+        }
+
         private Task<IHost> CreateHost(RequestDelegate appDelegate)
         {
             return new HostBuilder()