Apply suggestions from code review

Co-authored-by: Miha Zupan <[email protected]>
dotnet · liveans · Mar 1, 2024 · Jan 26, 2024 · Jan 31, 2024 · Feb 1, 2024
commit 06f8d95988907c33a68063d1ad1ea298e5e1a758
diff --git a/src/libraries/System.Net.Requests/src/System/Net/HttpWebRequest.cs b/src/libraries/System.Net.Requests/src/System/Net/HttpWebRequest.cs
@@ -1667,6 +1667,7 @@ private static HttpClient CreateHttpClient(HttpClientParameters parameters, Http
                     {
                         servicePoint.Certificate = cert;
                     }
+
                     if (rcvc is not null)
                     {
                         return rcvc(request!, cert, chain, errors);
@@ -1682,10 +1683,10 @@ private static HttpClient CreateHttpClient(HttpClientParameters parameters, Http
 
                     try
                     {
-                        //Start dns resolve
                         IPAddress[] addresses = parameters.Async ?
                             await Dns.GetHostAddressesAsync(context.DnsEndPoint.Host, cancellationToken).ConfigureAwait(false) :
                             Dns.GetHostAddresses(context.DnsEndPoint.Host);
+
                         if (parameters.ServicePoint is { } servicePoint)
                         {
                             if (servicePoint.ReceiveBufferSize != -1)
@@ -1719,6 +1720,7 @@ static void BindHelper(ServicePoint servicePoint, IPAddress[] addresses, Socket
                                         {
                                             break;
                                         }
+
                                         try
                                         {
                                             socket.Bind(endPoint);

diff --git a/src/libraries/System.Net.Requests/src/System/Net/HttpWebResponse.cs b/src/libraries/System.Net.Requests/src/System/Net/HttpWebResponse.cs
@@ -384,42 +384,46 @@ private void CheckDisposed()
         internal sealed class TruncatedReadStream(Stream innerStream, int maxSize) : Stream
         {
             public override bool CanRead => true;
-
             public override bool CanSeek => false;
-
             public override bool CanWrite => false;
 
             public override long Length => throw new NotSupportedException();
-
             public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
 
             public override void Flush() => innerStream.Flush();
             public override Task FlushAsync(CancellationToken cancellationToken) => innerStream.FlushAsync(cancellationToken);
+
             public override int Read(byte[] buffer, int offset, int count)
             {
                 return Read(new Span<byte>(buffer, offset, count));
             }
+
             public override int Read(Span<byte> buffer)
             {
                 int readBytes = innerStream.Read(buffer.Slice(0, Math.Min(buffer.Length, maxSize)));
                 maxSize -= readBytes;
                 return readBytes;
             }
+
             public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
             {
                 return ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
             }
+
             public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
             {
                 int readBytes = await innerStream.ReadAsync(buffer.Slice(0, Math.Min(buffer.Length, maxSize)), cancellationToken)
                     .ConfigureAwait(false);
                 maxSize -= readBytes;
                 return readBytes;
             }
+
             public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
             public override void SetLength(long value) => throw new NotSupportedException();
             public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
-            public override ValueTask DisposeAsync() => base.DisposeAsync();
+
+            public override ValueTask DisposeAsync() => innerStream.DisposeAsync();
+
             protected override void Dispose(bool disposing)
             {
                 if (disposing)

diff --git a/src/libraries/System.Net.Requests/tests/HttpWebRequestTest.cs b/src/libraries/System.Net.Requests/tests/HttpWebRequestTest.cs
@@ -2188,6 +2188,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                         int readLen = responseStream.Read(buffer, 0, buffer.Length);
                         Assert.Equal(5, readLen);
                         Assert.Equal(new string('a', 5), Encoding.UTF8.GetString(buffer[0..readLen]));
+                        Assert.Equal(0, responseStream.Read(buffer));
                     }
                 },
                 async (server) =>
@@ -2199,7 +2200,7 @@ await server.AcceptConnectionAsync(
                             await tcs.Task;
                         });
                 });
-            }, (this is HttpWebRequestTest_Async).ToString()).Dispose();
+            }, IsAsync.ToString()).Dispose();
         }
 
         [Fact]
@@ -2222,8 +2223,7 @@ await LoopbackServer.CreateClientAndServerAsync(
                 async (uri) =>
                 {
                     HttpWebRequest request = WebRequest.CreateHttp(uri);
-                    request.ServicePoint.BindIPEndPointDelegate =
-                        (sp, ep, retryCount) => { return new IPEndPoint(IPAddress.Loopback, 27277); };
+                    request.ServicePoint.BindIPEndPointDelegate = (_, _, _) => new IPEndPoint(IPAddress.Loopback, 27277);
                     using (var response = (HttpWebResponse)await GetResponseAsync(request))
                     {
                         Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@@ -2260,8 +2260,7 @@ public async Task SendHttpRequest_BindIPEndPoint_Throws()
             {
                 // URI shouldn't matter because it should throw exception before connection open.
                 HttpWebRequest request = WebRequest.CreateHttp(Configuration.Http.RemoteEchoServer);
-                request.ServicePoint.BindIPEndPointDelegate =
-                    (sp, ep, retryCount) => { return (IPEndPoint)socket.LocalEndPoint!; };
+                request.ServicePoint.BindIPEndPointDelegate = (_, _, _) => (IPEndPoint)socket.LocalEndPoint!;
                 var exception = await Assert.ThrowsAsync<WebException>(() => GetResponseAsync(request));
                 Assert.IsType<OverflowException>(exception.InnerException?.InnerException);
             }