Add async tests for RebufferableBinaryReader

Author: Jericho

Source/HttpMultipartParser.UnitTests/RebufferableBinaryReaderUnitTests.cs

@@ -2,6 +2,7 @@
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace HttpMultipartParser.UnitTests
@@ -68,6 +69,63 @@ public void CanReadMixedAsciiAndUTFCharactersOverBuffers()
 
         #endregion
 
+        #region ReadAsync() Tests
+
+        [Fact]
+        public async Task CanReadSingleCharacterBufferAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("abc"), Encoding.UTF8);
+
+            Assert.Equal('a', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('b', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('c', await reader.ReadAsync().ConfigureAwait(false));
+        }
+
+        [Fact]
+        public async Task CanReadSingleCharacterOverBuffersAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("def"), Encoding.UTF8);
+            reader.Buffer(TestUtil.StringToByteNoBom("abc"));
+
+            Assert.Equal('a', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('b', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('c', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('d', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('e', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('f', await reader.ReadAsync().ConfigureAwait(false));
+        }
+
+        [Fact]
+        public async Task CanReadMixedAsciiAndUTFCharactersAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("abcdèfg"), Encoding.UTF8);
+
+            Assert.Equal('a', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('b', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('c', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('d', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('è', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('f', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('g', await reader.ReadAsync().ConfigureAwait(false));
+        }
+
+        [Fact]
+        public async Task CanReadMixedAsciiAndUTFCharactersOverBuffersAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("dèfg"), Encoding.UTF8);
+            reader.Buffer(TestUtil.StringToByteNoBom("abc"));
+
+            Assert.Equal('a', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('b', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('c', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('d', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('è', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('f', await reader.ReadAsync().ConfigureAwait(false));
+            Assert.Equal('g', await reader.ReadAsync().ConfigureAwait(false));
+        }
+
+        #endregion
+
         #region Read(buffer, index, count) Tests
 
         [Fact]
@@ -185,6 +243,123 @@ public void ReadCanResumeInterruptedStream()
 
         #endregion
 
+        #region ReadAsync(buffer, index, count) Tests
+
+        [Fact]
+        public async Task CanReadSingleBufferAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("6chars"), Encoding.UTF8);
+
+            var buffer = new byte[Encoding.UTF8.GetByteCount("6chars")];
+            await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            string result = Encoding.UTF8.GetString(buffer);
+            Assert.Equal("6chars", result);
+        }
+
+        [Fact]
+        public async Task CanReadAcrossMultipleBuffersAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("ars"), Encoding.UTF8);
+            reader.Buffer(TestUtil.StringToByteNoBom("6ch"));
+
+            var buffer = new byte[6];
+            await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            Assert.Equal("6chars", Encoding.UTF8.GetString(buffer));
+        }
+
+        [Fact]
+        public async Task CanReadMixedAsciiAndUTF8Async()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("5èats"), Encoding.UTF8);
+
+            var buffer = new byte[Encoding.UTF8.GetByteCount("5èats")];
+            await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            string result = Encoding.UTF8.GetString(buffer);
+            Assert.Equal("5èats", result);
+        }
+
+        [Fact]
+        public async Task CanReadMixedAsciiAndUTF8AcrossMultipleBuffersAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("ts"), Encoding.UTF8);
+            reader.Buffer(TestUtil.StringToByteNoBom(("5èa")));
+
+            var buffer = new byte[Encoding.UTF8.GetByteCount("5èats")];
+            await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            string result = Encoding.UTF8.GetString(buffer);
+            Assert.Equal("5èats", result);
+        }
+
+        [Fact]
+        public async Task ReadCorrectlyHandlesSmallerBufferThenStreamAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("6chars"), Encoding.UTF8);
+
+            var buffer = new byte[4];
+            await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            Assert.Equal("6cha", Encoding.UTF8.GetString(buffer));
+
+            buffer = new byte[2];
+            await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            Assert.Equal("rs", Encoding.UTF8.GetString(buffer));
+        }
+
+        [Fact]
+        public async Task ReadCorrectlyHandlesLargerBufferThenStreamAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("6chars"), Encoding.UTF8);
+
+            var buffer = new byte[10];
+            int amountRead = await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            Assert.Equal("6chars\0\0\0\0", Encoding.UTF8.GetString(buffer));
+            Assert.Equal(6, amountRead);
+        }
+
+        [Fact]
+        public async Task ReadReturnsZeroOnNoDataAsync()
+        {
+            var reader = new RebufferableBinaryReader(new MemoryStream(), Encoding.UTF8);
+
+            var buffer = new byte[6];
+            int amountRead = await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            Assert.Equal("\0\0\0\0\0\0", Encoding.UTF8.GetString(buffer));
+            Assert.Equal(0, amountRead);
+        }
+
+        [Fact]
+        public async Task ReadLineReturnsNullOnNoDataAsync()
+        {
+            var reader = new RebufferableBinaryReader(new MemoryStream(new byte[6]), Encoding.UTF8);
+
+            var s = await reader.ReadLineAsync().ConfigureAwait(false);
+            Assert.Equal("\0\0\0\0\0\0", s);
+            Assert.Null(await reader.ReadLineAsync().ConfigureAwait(false));
+        }
+
+        [Fact]
+        public async Task ReadCanResumeInterruptedStreamAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("6chars"), Encoding.UTF8);
+
+            var buffer = new byte[4];
+            int amountRead = await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            Assert.Equal("6cha", Encoding.UTF8.GetString(buffer));
+            Assert.Equal(4, amountRead);
+
+            reader.Buffer(TestUtil.StringToByteNoBom("14intermission"));
+            buffer = new byte[14];
+            amountRead = await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            Assert.Equal("14intermission", Encoding.UTF8.GetString(buffer));
+            Assert.Equal(14, amountRead);
+
+            buffer = new byte[2];
+            amountRead = await reader.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
+            Assert.Equal("rs", Encoding.UTF8.GetString(buffer));
+            Assert.Equal(2, amountRead);
+        }
+
+        #endregion
+
         #region ReadByteLine() Tests
 
         [Fact]
@@ -201,5 +376,22 @@ public void CanReadByteLineOnMixedAsciiAndUTF8Text()
         }
 
         #endregion
+
+        #region ReadByteLineAsync() Tests
+
+        [Fact]
+        public async Task CanReadByteLineOnMixedAsciiAndUTF8TextAsync()
+        {
+            var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("Bonjour poignée"), Encoding.UTF8);
+            byte[] bytes = await reader.ReadByteLineAsync().ConfigureAwait(false);
+            var expected = new byte[] { 66, 111, 110, 106, 111, 117, 114, 32, 112, 111, 105, 103, 110, 195, 169, 101 };
+
+            foreach (var pair in expected.Zip(bytes, Tuple.Create))
+            {
+                Assert.Equal(pair.Item1, pair.Item2);
+            }
+        }
+
+        #endregion
     }
 }