From 58a107b27e7a73cf24f68b7ad38818a59b5289b9 Mon Sep 17 00:00:00 2001
From: Matyas Richter <matyas.richter@gmail.com>
Date: Sat, 25 Jan 2020 15:26:26 +0000
Subject: [PATCH] Don't throw exception while flushing ReferenceReadStream
 #18503 (#18548)

---
 .../Http/src/Internal/ReferenceReadStream.cs  |  6 +-
 .../test/Internal/ReferenceReadStreamTests.cs | 77 +++++++++++++++++++
 2 files changed, 82 insertions(+), 1 deletion(-)
 create mode 100644 src/Http/Http/test/Internal/ReferenceReadStreamTests.cs

diff --git a/src/Http/Http/src/Internal/ReferenceReadStream.cs b/src/Http/Http/src/Internal/ReferenceReadStream.cs
index e7160407d9..cee967d0cc 100644
--- a/src/Http/Http/src/Internal/ReferenceReadStream.cs
+++ b/src/Http/Http/src/Internal/ReferenceReadStream.cs
@@ -132,7 +132,11 @@ namespace Microsoft.AspNetCore.Http
 
         public override void Flush()
         {
-            throw new NotSupportedException();
+        }
+
+        public override Task FlushAsync(CancellationToken cancellationToken)
+        {
+            return Task.CompletedTask;
         }
 
         protected override void Dispose(bool disposing)
diff --git a/src/Http/Http/test/Internal/ReferenceReadStreamTests.cs b/src/Http/Http/test/Internal/ReferenceReadStreamTests.cs
new file mode 100644
index 0000000000..bce99b4133
--- /dev/null
+++ b/src/Http/Http/test/Internal/ReferenceReadStreamTests.cs
@@ -0,0 +1,77 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Moq;
+using Xunit;
+
+namespace Microsoft.AspNetCore.Http
+{
+    public class ReferenceReadStreamTests
+    {
+        [Fact]
+        public void CanRead_ReturnsTrue()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            Assert.True(stream.CanRead);
+        }
+
+        [Fact]
+        public void CanSeek_ReturnsFalse()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            Assert.False(stream.CanSeek);
+        }
+
+        [Fact]
+        public void CanWrite_ReturnsFalse()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            Assert.False(stream.CanWrite);
+        }
+
+        [Fact]
+        public void SetLength_Throws()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            Assert.Throws<NotSupportedException>(() => stream.SetLength(0));
+        }
+
+        [Fact]
+        public void Write_Throws()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            Assert.Throws<NotSupportedException>(() => stream.Write(new byte[1], 0, 1));
+        }
+
+        [Fact]
+        public void WriteByte_Throws()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            Assert.Throws<NotSupportedException>(() => stream.WriteByte(0));
+        }
+
+        [Fact]
+        public async Task WriteAsync_Throws()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            await Assert.ThrowsAsync<NotSupportedException>(() => stream.WriteAsync(new byte[1], 0, 1));
+        }
+
+        [Fact]
+        public void Flush_DoesNotThrow()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            stream.Flush();
+        }
+
+        [Fact]
+        public async Task FlushAsync_DoesNotThrow()
+        {
+            var stream = new ReferenceReadStream(Mock.Of<Stream>(), 0, 1);
+            await stream.FlushAsync();
+        }
+    }
+}