Add a few missing async tests

Author: Jericho

Source/HttpMultipartParser.UnitTests/ParserScenarios/TinyData.cs

@@ -2,6 +2,7 @@
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace HttpMultipartParser.UnitTests.ParserScenarios
@@ -55,6 +56,19 @@ public void CanAutoDetectBoundary()
             }
         }
 
+        /// <summary>
+        ///     Tests for correct detection of the boundary in the input stream.
+        /// </summary>
+        [Fact]
+        public async Task CanAutoDetectBoundaryAsync()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
         /// <summary>
         ///     Ensures that boundary detection works even when the boundary spans
         ///     two different buffers.
@@ -69,6 +83,20 @@ public void CanDetectBoundariesCrossBuffer()
             }
         }
 
+        /// <summary>
+        ///     Ensures that boundary detection works even when the boundary spans
+        ///     two different buffers.
+        /// </summary>
+        [Fact]
+        public async Task CanDetectBoundariesCrossBufferAsync()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, "boundry", Encoding.UTF8, 16).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
         /// <summary>
         ///     Ensure that mixed newline formats are correctly handled.
         /// </summary>
@@ -85,6 +113,22 @@ public void CorrectlyHandleMixedNewlineFormats()
             }
         }
 
+        /// <summary>
+        ///     Ensure that mixed newline formats are correctly handled.
+        /// </summary>
+        [Fact]
+        public async Task CorrectlyHandleMixedNewlineFormatsAsync()
+        {
+            // Replace the first '\n' with '\r\n'
+            var regex = new Regex(Regex.Escape("\n"));
+            string request = regex.Replace(_testCase.Request, "\r\n", 1);
+            using (Stream stream = TestUtil.StringToStream(request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, "boundry", Encoding.UTF8).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
         /// <summary>
         ///     Tests for correct handling of <c>crlf (\r\n)</c> in the input stream.
         /// </summary>
@@ -99,6 +143,20 @@ public void CorrectlyHandlesCRLF()
             }
         }
 
+        /// <summary>
+        ///     Tests for correct handling of <c>crlf (\r\n)</c> in the input stream.
+        /// </summary>
+        [Fact]
+        public async Task CorrectlyHandlesCRLFAsync()
+        {
+            string request = _testCase.Request.Replace("\n", "\r\n");
+            using (Stream stream = TestUtil.StringToStream(request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, "boundry", Encoding.UTF8).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
         /// <summary>
         ///     The tiny data test.
         /// </summary>
@@ -112,6 +170,19 @@ public void TinyDataTest()
             }
         }
 
+        /// <summary>
+        ///     The tiny data test.
+        /// </summary>
+        [Fact]
+        public async Task TinyDataTestAsync()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, "boundry", Encoding.UTF8).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+            }
+        }
+
         [Fact]
         public void DoesNotCloseTheStream()
         {
@@ -125,6 +196,19 @@ public void DoesNotCloseTheStream()
             }
         }
 
+        [Fact]
+        public async Task DoesNotCloseTheStreamAsync()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, "boundry", Encoding.UTF8).ConfigureAwait(false);
+                Assert.True(_testCase.Validate(parser));
+
+                stream.Position = 0;
+                Assert.True(true, "A closed stream would throw ObjectDisposedException");
+            }
+        }
+
         [Fact]
         public void GetParameterValueReturnsNullIfNoParameterFound()
         {
@@ -135,6 +219,16 @@ public void GetParameterValueReturnsNullIfNoParameterFound()
             }
         }
 
+        [Fact]
+        public async Task GetParameterValueReturnsNullIfNoParameterFoundAsync()
+        {
+            using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+            {
+                var parser = await MultipartFormDataParser.ParseAsync(stream, "boundry", Encoding.UTF8).ConfigureAwait(false);
+                Assert.Null(parser.GetParameterValue("does not exist"));
+            }
+        }
+
         [Fact]
         public void CanDetectBoundriesWithNewLineInNextBuffer()
         {
@@ -147,5 +241,18 @@ public void CanDetectBoundriesWithNewLineInNextBuffer()
                 }
             }
         }
+
+        [Fact]
+        public async Task CanDetectBoundriesWithNewLineInNextBufferAsync()
+        {
+            for (int i = 16; i < _testCase.Request.Length; i++)
+            {
+                using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
+                {
+                    var parser = await MultipartFormDataParser.ParseAsync(stream, "boundry", Encoding.UTF8, i).ConfigureAwait(false);
+                    Assert.True(_testCase.Validate(parser), $"Failure in buffer length {i}");
+                }
+            }
+        }
     }
 }