Add timeouts to SendReceive tests (#90631)

Fixes #89784

Author: antonfirsov

src/libraries/System.Net.Sockets/tests/FunctionalTests/SendReceive/SendReceive.cs

@@ -60,7 +60,7 @@ public async Task SendRecv_Stream_TCP(IPAddress listenAt, bool useMultipleBuffer
 
                 Task serverProcessingTask = Task.Run(async () =>
                 {
-                    using (Socket remote = await AcceptAsync(server))
+                    using (Socket remote = await AcceptAsync(server).WaitAsync(TestSettings.PassingTestTimeout))
                     {
                         if (!useMultipleBuffers)
                         {
@@ -109,7 +109,7 @@ public async Task SendRecv_Stream_TCP(IPAddress listenAt, bool useMultipleBuffer
                 EndPoint clientEndpoint = server.LocalEndPoint;
                 using (var client = new Socket(clientEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
                 {
-                    await ConnectAsync(client, clientEndpoint);
+                    await ConnectAsync(client, clientEndpoint).WaitAsync(TestSettings.PassingTestTimeout);
 
                     var random = new Random();
                     if (!useMultipleBuffers)
@@ -152,7 +152,7 @@ public async Task SendRecv_Stream_TCP(IPAddress listenAt, bool useMultipleBuffer
 
                     client.LingerState = new LingerOption(true, LingerTime);
                     client.Shutdown(SocketShutdown.Send);
-                    await serverProcessingTask;
+                    await serverProcessingTask.WaitAsync(TestSettings.PassingTestTimeout);
                 }
 
                 Assert.Equal(bytesSent, bytesReceived);
@@ -231,7 +231,7 @@ public async Task SendRecv_Stream_TCP_AlternateBufferAndBufferList(IPAddress lis
 
                 Task serverProcessingTask = Task.Run(async () =>
                 {
-                    using (Socket remote = await AcceptAsync(server))
+                    using (Socket remote = await AcceptAsync(server).WaitAsync(TestSettings.PassingTestTimeout))
                     {
                         byte[] recvBuffer1 = new byte[256], recvBuffer2 = new byte[256];
                         long iter = 0;
@@ -269,7 +269,7 @@ public async Task SendRecv_Stream_TCP_AlternateBufferAndBufferList(IPAddress lis
                 EndPoint clientEndpoint = server.LocalEndPoint;
                 using (var client = new Socket(clientEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
                 {
-                    await ConnectAsync(client, clientEndpoint);
+                    await ConnectAsync(client, clientEndpoint).WaitAsync(TestSettings.PassingTestTimeout);
 
                     var random = new Random();
                     byte[] sendBuffer1 = new byte[512], sendBuffer2 = new byte[512];
@@ -308,7 +308,7 @@ public async Task SendRecv_Stream_TCP_AlternateBufferAndBufferList(IPAddress lis
                     }
 
                     client.Shutdown(SocketShutdown.Send);
-                    await serverProcessingTask;
+                    await serverProcessingTask.WaitAsync(TestSettings.PassingTestTimeout);
                 }
 
                 Assert.Equal(bytesSent, bytesReceived);
@@ -330,7 +330,7 @@ public async Task SendRecv_Stream_TCP_MultipleConcurrentReceives(IPAddress liste
                 using (var client = new Socket(clientEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
                 {
                     Task clientConnect = ConnectAsync(client, clientEndpoint);
-                    using (Socket remote = await AcceptAsync(server))
+                    using (Socket remote = await AcceptAsync(server).WaitAsync(TestSettings.PassingTestTimeout))
                     {
                         await clientConnect.WaitAsync(TestSettings.PassingTestTimeout);
 
@@ -440,9 +440,9 @@ public async Task SendRecv_Stream_TCP_MultipleConcurrentSends(IPAddress listenAt
                 using (var client = new Socket(clientEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
                 {
                     Task clientConnect = ConnectAsync(client, clientEndpoint);
-                    using (Socket remote = await AcceptAsync(server))
+                    using (Socket remote = await AcceptAsync(server).WaitAsync(TestSettings.PassingTestTimeout))
                     {
-                        await clientConnect;
+                        await clientConnect.WaitAsync(TestSettings.PassingTestTimeout);
 
                         Task<int> send1, send2, send3;
                         if (useMultipleBuffers)
@@ -503,7 +503,7 @@ public async Task SendRecvPollSync_TcpListener_Socket(IPAddress listenAt, bool p
                 _output?.WriteLine($"{DateTime.Now} Starting listener at {listener.LocalEndpoint}");
                 Task serverTask = Task.Run(async () =>
                 {
-                    using (Socket remote = await listener.AcceptSocketAsync())
+                    using (Socket remote = await listener.AcceptSocketAsync().WaitAsync(TestSettings.PassingTestTimeout))
                     {
                         var recvBuffer = new byte[256];
                         int count = 0;
@@ -537,7 +537,7 @@ public async Task SendRecvPollSync_TcpListener_Socket(IPAddress listenAt, bool p
 
                     using (var client = new Socket(clientEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
                     {
-                        await ConnectAsync(client, clientEndpoint);
+                        await ConnectAsync(client, clientEndpoint).WaitAsync(TestSettings.PassingTestTimeout);
 
                         if (pollBeforeOperation)
                         {
@@ -592,7 +592,8 @@ public async Task Send_0ByteSend_Success()
                 Task<Socket> acceptTask = AcceptAsync(listener);
                 await Task.WhenAll(
                     acceptTask,
-                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)));
+                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)))
+                    .WaitAsync(TestSettings.PassingTestTimeout);
 
                 using (Socket server = await acceptTask)
                 {
@@ -625,7 +626,8 @@ public async Task SendRecv_0ByteReceive_Success()
                 Task<Socket> acceptTask = AcceptAsync(listener);
                 await Task.WhenAll(
                     acceptTask,
-                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)));
+                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)))
+                    .WaitAsync(TestSettings.PassingTestTimeout);
 
                 using (Socket server = await acceptTask)
                 {
@@ -682,7 +684,7 @@ public async Task Send_0ByteSendTo_Success()
                     Assert.Equal(client.LocalEndPoint, result.RemoteEndPoint);
 
                     // Read real packet.
-                    result = await ReceiveFromAsync(server, buffer, new IPEndPoint(IPAddress.Any, 0));
+                    result = await ReceiveFromAsync(server, buffer, new IPEndPoint(IPAddress.Any, 0)).WaitAsync(TestSettings.PassingTestTimeout);
 
                     Assert.Equal(1, result.ReceivedBytes);
                     Assert.Equal(client.LocalEndPoint, result.RemoteEndPoint);
@@ -703,7 +705,8 @@ public async Task Receive0ByteReturns_WhenPeerDisconnects()
                 Task<Socket> acceptTask = AcceptAsync(listener);
                 await Task.WhenAll(
                     acceptTask,
-                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)));
+                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)))
+                    .WaitAsync(TestSettings.PassingTestTimeout);
 
                 using (Socket server = await acceptTask)
                 {
@@ -743,7 +746,8 @@ public async Task SendRecv_BlockingNonBlocking_LingerTimeout_Success(bool blocki
                 Task<Socket> acceptTask = AcceptAsync(listener);
                 await Task.WhenAll(
                     acceptTask,
-                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)));
+                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)))
+                    .WaitAsync(TestSettings.PassingTestTimeout);
 
                 using (Socket server = await acceptTask)
                 {
@@ -773,7 +777,8 @@ public async Task SendRecv_NoBuffering_Success()
                 Task<Socket> acceptTask = AcceptAsync(listener);
                 await Task.WhenAll(
                     acceptTask,
-                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)));
+                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)))
+                    .WaitAsync(TestSettings.PassingTestTimeout);
 
                 using (Socket server = await acceptTask)
                 {
@@ -812,7 +817,8 @@ public async Task SendRecv_DisposeDuringPendingReceive_ThrowsSocketException()
                 Task<Socket> acceptTask = AcceptAsync(listener);
                 await Task.WhenAll(
                     acceptTask,
-                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)));
+                    ConnectAsync(client, new IPEndPoint(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndPoint).Port)))
+                    .WaitAsync(TestSettings.PassingTestTimeout);
 
                 using (Socket server = await acceptTask)
                 {