Review feedback

src/libraries/System.Net.Requests/src/Resources/Strings.resx

@@ -264,4 +264,7 @@
   <data name="net_proxyschemenotsupported" xml:space="preserve">
     <value>The ServicePointManager does not support proxies with the {0} scheme.</value>
   </data>
+  <data name="net_maximumbindretries" xml:space="preserve">
+    <value>Reached maximum number of BindIPEndPointDelegate retries</value>
+  </data>
 </root>

src/libraries/System.Net.Requests/src/System/Net/HttpWebRequest.cs

@@ -42,6 +42,7 @@ public class HttpWebRequest : WebRequest, ISerializable
         private Task<HttpResponseMessage>? _sendRequestTask;
 
         private static int _defaultMaxResponseHeadersLength = HttpHandlerDefaults.DefaultMaxResponseHeadersLength;
+        private static int _defaultMaximumErrorResponseLength = -1;
 
         private int _beginGetRequestStreamCalled;
         private int _beginGetResponseCalled;
@@ -674,11 +675,22 @@ public static int DefaultMaximumResponseHeadersLength
             }
             set
             {
+                ArgumentOutOfRangeException.ThrowIfLessThan(value, 0);
                 _defaultMaxResponseHeadersLength = value;
             }
         }
 
-        public static int DefaultMaximumErrorResponseLength { get; set; } = -1;
+        public static int DefaultMaximumErrorResponseLength {
+            get
+            {
+                return _defaultMaximumErrorResponseLength;
+            }
+            set
+            {
+                ArgumentOutOfRangeException.ThrowIfLessThan(value, -1);
+                _defaultMaximumErrorResponseLength = value;
+            }
+        }
 
         private static RequestCachePolicy? _defaultCachePolicy = new RequestCachePolicy(RequestCacheLevel.BypassCache);
         private static bool _isDefaultCachePolicySet;
@@ -1734,7 +1746,7 @@ static void BindHelper(ServicePoint servicePoint, IPAddress[] addresses, Socket
 
                                     if (retryCount >= MaxRetries)
                                     {
-                                        throw new OverflowException(); //TODO (aaksoy): Add SR for this.
+                                        throw new OverflowException(SR.net_maximumbindretries);
                                     }
                                 }
                             }

src/libraries/System.Net.Requests/src/System/Net/ServicePoint/ServicePointManager.cs

@@ -156,7 +156,8 @@ public static ServicePoint FindServicePoint(Uri address, IWebProxy? proxy)
                     IdleSince = DateTime.Now,
                     Expect100Continue = Expect100Continue,
                     UseNagleAlgorithm = UseNagleAlgorithm,
-                    KeepAlive = KeepAlive
+                    KeepAlive = KeepAlive,
+                    MaxIdleTime = MaxServicePointIdleTime
                 };
                 s_servicePointTable[tableKey] = new WeakReference<ServicePoint>(sp);
 

src/libraries/System.Net.Requests/tests/HttpWebRequestTest.cs

@@ -2194,9 +2194,9 @@ await LoopbackServer.CreateClientAndServerAsync(
                 async (server) =>
                 {
                     await server.AcceptConnectionAsync(
-                        async (client) =>
+                        async connection =>
                         {
-                            await client.SendResponseAsync(statusCode: HttpStatusCode.BadRequest, content: new string('a', 10));
+                            await connection.SendResponseAsync(statusCode: HttpStatusCode.BadRequest, content: new string('a', 10));
                             await tcs.Task;
                         });
                 });
@@ -2215,64 +2215,72 @@ public void HttpWebRequest_SetProtocolVersion_Success()
             Assert.Equal(HttpVersion.Version11, request.ServicePoint.ProtocolVersion);
         }
 
-        [Fact]
-        public async Task SendHttpRequest_BindIPEndPoint_Success()
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void SendHttpRequest_BindIPEndPoint_Success()
         {
-            TaskCompletionSource tcs = new TaskCompletionSource();
-            await LoopbackServer.CreateClientAndServerAsync(
-                async (uri) =>
-                {
-                    HttpWebRequest request = WebRequest.CreateHttp(uri);
-                    request.ServicePoint.BindIPEndPointDelegate = (_, _, _) => new IPEndPoint(IPAddress.Loopback, 27277);
-                    using (var response = (HttpWebResponse)await GetResponseAsync(request))
+            RemoteExecutor.Invoke(async (async) =>
+            {
+                TaskCompletionSource tcs = new TaskCompletionSource();
+                await LoopbackServer.CreateClientAndServerAsync(
+                    async (uri) =>
                     {
-                        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
-                    }
-                    tcs.SetResult();
-                },
-                async (server) =>
-                {
-                    await server.AcceptConnectionAsync(
-                        async (client) =>
+                        HttpWebRequest request = WebRequest.CreateHttp(uri);
+                        request.ServicePoint.BindIPEndPointDelegate = (_, _, _) => new IPEndPoint(IPAddress.Loopback, 27277);
+                        var responseTask = bool.Parse(async) ? request.GetResponseAsync() : Task.Run(() => request.GetResponse());
+                        using (var response = (HttpWebResponse)await responseTask)
                         {
-                            var ipEp = (IPEndPoint)client.Socket.RemoteEndPoint;
-                            Assert.Equal(27277, ipEp.Port);
-                            await client.SendResponseAsync();
-                            await tcs.Task;
-                        });
-                });
+                            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+                        }
+                        tcs.SetResult();
+                    },
+                    async (server) =>
+                    {
+                        await server.AcceptConnectionAsync(
+                            async connection =>
+                            {
+                                var ipEp = (IPEndPoint)connection.Socket.RemoteEndPoint;
+                                Assert.Equal(27277, ipEp.Port);
+                                await connection.SendResponseAsync();
+                                await tcs.Task;
+                            });
+                    });
+            }, IsAsync.ToString());
         }
 
-        [Fact]
-        public async Task SendHttpRequest_BindIPEndPoint_Throws()
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void SendHttpRequest_BindIPEndPoint_Throws()
         {
-            Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-            socket.Bind(new IPEndPoint(IPAddress.Loopback, 0));
-            ValueTask<Socket>? clientSocket = null;
-            CancellationTokenSource cts = new CancellationTokenSource();
-            if (PlatformDetection.IsLinux)
+            RemoteExecutor.Invoke(async (async) =>
             {
-                socket.Listen();
-                clientSocket = socket.AcceptAsync(cts.Token);
-            }
+                Socket socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+                socket.Bind(new IPEndPoint(IPAddress.Loopback, 0));
+                ValueTask<Socket>? clientSocket = null;
+                CancellationTokenSource cts = new CancellationTokenSource();
+                if (PlatformDetection.IsLinux)
+                {
+                    socket.Listen();
+                    clientSocket = socket.AcceptAsync(cts.Token);
+                }
 
-            try
-            {
-                // URI shouldn't matter because it should throw exception before connection open.
-                HttpWebRequest request = WebRequest.CreateHttp(Configuration.Http.RemoteEchoServer);
-                request.ServicePoint.BindIPEndPointDelegate = (_, _, _) => (IPEndPoint)socket.LocalEndPoint!;
-                var exception = await Assert.ThrowsAsync<WebException>(() => GetResponseAsync(request));
-                Assert.IsType<OverflowException>(exception.InnerException?.InnerException);
-            }
-            finally
-            {
-                if (clientSocket is not null)
+                try
                 {
-                    await cts.CancelAsync();
+                    // URI shouldn't matter because it should throw exception before connection open.
+                    HttpWebRequest request = WebRequest.CreateHttp(Configuration.Http.RemoteEchoServer);
+                    request.ServicePoint.BindIPEndPointDelegate = (_, _, _) => (IPEndPoint)socket.LocalEndPoint!;
+                    var exception = await Assert.ThrowsAsync<WebException>(() =>
+                        bool.Parse(async) ? request.GetResponseAsync() : Task.Run(() => request.GetResponse()));
+                    Assert.IsType<OverflowException>(exception.InnerException?.InnerException);
                 }
-                socket.Dispose();
-                cts.Dispose();
-            }
+                finally
+                {
+                    if (clientSocket is not null)
+                    {
+                        await cts.CancelAsync();
+                    }
+                    socket.Dispose();
+                    cts.Dispose();
+                }
+            }, IsAsync.ToString());
         }
 
         private void RequestStreamCallback(IAsyncResult asynchronousResult)