Fix HttpListener Read_LargeLength tests

Author: stephentoub

src/System.Net.HttpListener/tests/HttpRequestStreamTests.cs

@@ -123,37 +123,32 @@ public async Task Read_FullLengthSynchronous_Success(bool transferEncodingChunke
         [ConditionalTheory(nameof(PlatformDetection) + "." + nameof(PlatformDetection.IsNotOneCoreUAP))]
         [InlineData(true)]
         [InlineData(false)]
-        [ActiveIssue(18128, platforms: TestPlatforms.AnyUnix)] // Different behaviour when not chunked, that needs investigation.
         public async Task Read_LargeLengthAsynchronous_Success(bool transferEncodingChunked)
         {
-            string text = new string('a', 128 * 1024 + 1); // More than 128kb
-            byte[] expected = Encoding.UTF8.GetBytes(text);
+            var rand = new Random(42);
+            byte[] expected = Enumerable
+                .Range(0, 128*1024 + 1) // More than 128kb
+                .Select(_ => (byte)('a' + rand.Next(0, 26)))
+                .ToArray();
+
             Task<HttpListenerContext> contextTask = _listener.GetContextAsync();
 
             using (HttpClient client = new HttpClient())
             {
                 client.DefaultRequestHeaders.TransferEncodingChunked = transferEncodingChunked;
-                Task<HttpResponseMessage> clientTask = client.PostAsync(_factory.ListeningUrl, new StringContent(text));
+                Task<HttpResponseMessage> clientTask = client.PostAsync(_factory.ListeningUrl, new ByteArrayContent(expected));
 
                 HttpListenerContext context = await contextTask;
 
                 // If the size is greater than 128K, then we limit the size, and have to do multiple reads on
                 // Windows, which uses http.sys internally.
                 byte[] buffer = new byte[expected.Length];
-                int bytesRead = await context.Request.InputStream.ReadAsync(buffer, 0, buffer.Length);
-                if (PlatformDetection.IsWindows)
-                {
-                    Assert.Equal(expected.Length - 1, bytesRead);
-                    Assert.NotEqual(expected, buffer);
-
-                    bytesRead = await context.Request.InputStream.ReadAsync(buffer, buffer.Length - 1, 1);
-                    Assert.Equal(1, bytesRead);
-                    Assert.Equal(expected, buffer);
-                }
-                else
+                int totalRead = 0;
+                while (totalRead < expected.Length)
                 {
-                    Assert.Equal(expected.Length, bytesRead);
-                    Assert.Equal(expected, buffer);
+                    int bytesRead = await context.Request.InputStream.ReadAsync(buffer, totalRead, expected.Length - totalRead);
+                    Assert.InRange(bytesRead, 1, expected.Length - totalRead);
+                    totalRead += bytesRead;
                 }
 
                 // Subsequent reads don't do anything.
@@ -167,37 +162,32 @@ public async Task Read_LargeLengthAsynchronous_Success(bool transferEncodingChun
         [ConditionalTheory(nameof(PlatformDetection) + "." + nameof(PlatformDetection.IsNotOneCoreUAP))]
         [InlineData(true)]
         [InlineData(false)]
-        [ActiveIssue(18128, platforms: TestPlatforms.AnyUnix)] // Different behaviour when not chunked, that needs investigation.
         public async Task Read_LargeLengthSynchronous_Success(bool transferEncodingChunked)
         {
-            string text = new string('a', 128 * 1024 + 1); // More than 128kb
-            byte[] expected = Encoding.UTF8.GetBytes(text);
+            var rand = new Random(42);
+            byte[] expected = Enumerable
+                .Range(0, 128 * 1024 + 1) // More than 128kb
+                .Select(_ => (byte)('a' + rand.Next(0, 26)))
+                .ToArray();
+
             Task<HttpListenerContext> contextTask = _listener.GetContextAsync();
 
             using (HttpClient client = new HttpClient())
             {
                 client.DefaultRequestHeaders.TransferEncodingChunked = transferEncodingChunked;
-                Task<HttpResponseMessage> clientTask = client.PostAsync(_factory.ListeningUrl, new StringContent(text));
+                Task<HttpResponseMessage> clientTask = client.PostAsync(_factory.ListeningUrl, new ByteArrayContent(expected));
 
                 HttpListenerContext context = await contextTask;
 
                 // If the size is greater than 128K, then we limit the size, and have to do multiple reads on
                 // Windows, which uses http.sys internally.
                 byte[] buffer = new byte[expected.Length];
-                int bytesRead = context.Request.InputStream.Read(buffer, 0, buffer.Length);
-                if (PlatformDetection.IsWindows)
-                {
-                    Assert.Equal(expected.Length - 1, bytesRead);
-                    Assert.NotEqual(expected, buffer);
-
-                    bytesRead = context.Request.InputStream.Read(buffer, buffer.Length - 1, 1);
-                    Assert.Equal(1, bytesRead);
-                    Assert.Equal(expected, buffer);
-                }
-                else
+                int totalRead = 0;
+                while (totalRead < expected.Length)
                 {
-                    Assert.Equal(expected.Length, bytesRead);
-                    Assert.Equal(expected, buffer);
+                    int bytesRead = context.Request.InputStream.Read(buffer, totalRead, expected.Length - totalRead);
+                    Assert.InRange(bytesRead, 1, expected.Length - totalRead);
+                    totalRead += bytesRead;
                 }
 
                 // Subsequent reads don't do anything.