Fixed KeepAlive test dependency on frame chronology.

On slower platforms, PINGs were coming sooner than requests themselves causing errors while reading the request and receiving PING frame instead of HEADERS frame.

src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs

@@ -24,6 +24,7 @@ public class Http2LoopbackConnection : GenericLoopbackConnection
         private Stream _connectionStream;
         private TaskCompletionSource<bool> _ignoredSettingsAckPromise;
         private bool _ignoreWindowUpdates;
+        private TaskCompletionSource<PingFrame> _expectPingFrame;
         private readonly TimeSpan _timeout;
         private int _lastStreamId;
 
@@ -186,6 +187,13 @@ private async Task<Frame> ReadFrameAsync(CancellationToken cancellationToken)
                 return await ReadFrameAsync(cancellationToken).ConfigureAwait(false);
             }
 
+            if (_expectPingFrame != null && header.Type == FrameType.Ping)
+            {
+                _expectPingFrame.SetResult(PingFrame.ReadFrom(header, data));
+                _expectPingFrame = null;
+                return await ReadFrameAsync(cancellationToken).ConfigureAwait(false);
+            }
+
             // Construct the correct frame type and return it.
             switch (header.Type)
             {
@@ -245,6 +253,15 @@ public void IgnoreWindowUpdates()
             _ignoreWindowUpdates = true;
         }
 
+        // Set up loopback server to expect PING frames among other frames.
+        // Once PING frame is read in ReadFrameAsync, the returned task is completed.
+        // The returned task is canceled in ReadPingAsync if no PING frame has been read so far.
+        public Task<PingFrame> ExpectPingFrameAsync()
+        {
+            _expectPingFrame ??= new TaskCompletionSource<PingFrame>();
+            return _expectPingFrame.Task;
+        }
+
         public async Task ReadRstStreamAsync(int streamId)
         {
             Frame frame = await ReadFrameAsync(_timeout);
@@ -677,6 +694,9 @@ public async Task PingPong()
 
         public async Task<PingFrame> ReadPingAsync(TimeSpan timeout)
         {
+            _expectPingFrame?.TrySetCanceled();
+            _expectPingFrame = null;
+
             Frame frame = await ReadFrameAsync(timeout).ConfigureAwait(false);
             Assert.NotNull(frame);
             Assert.Equal(FrameType.Ping, frame.Type);

src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs

@@ -307,26 +307,31 @@ public void SettersExceptions()
 
         public static IEnumerable<object[]> KeepAliveTestDataSource()
         {
-            yield return new object[] { Timeout.InfiniteTimeSpan, TimeSpan.FromSeconds(0), HttpKeepAlivePingPolicy.Always, false, false, false };
-            yield return new object[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(0), HttpKeepAlivePingPolicy.WithActiveRequests, true, false, false };
-            yield return new object[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(0), HttpKeepAlivePingPolicy.Always, true, true, false };
-            yield return new object[] { TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5), HttpKeepAlivePingPolicy.WithActiveRequests, true, true, true };
+            yield return new object[] { Timeout.InfiniteTimeSpan, HttpKeepAlivePingPolicy.Always, false };
+            yield return new object[] { TimeSpan.FromSeconds(1), HttpKeepAlivePingPolicy.WithActiveRequests, false };
+            yield return new object[] { TimeSpan.FromSeconds(1), HttpKeepAlivePingPolicy.Always, false };
+            yield return new object[] { TimeSpan.FromSeconds(1), HttpKeepAlivePingPolicy.WithActiveRequests, true };
         }
 
         [OuterLoop("Significant delay.")]
         [Theory]
         [MemberData(nameof(KeepAliveTestDataSource))]
-        public async Task KeepAlive(TimeSpan keepAlivePingDelay, TimeSpan pongDelay, HttpKeepAlivePingPolicy keepAlivePingPolicy, bool expectStreamPing,
-            bool expectPingWithoutStream, bool expectRequestFail)
+        public async Task KeepAlive(TimeSpan keepAlivePingDelay, HttpKeepAlivePingPolicy keepAlivePingPolicy, bool expectRequestFail)
         {
-            var pingTimeout = keepAlivePingDelay.Add(TimeSpan.FromSeconds(4));
+            TimeSpan pingTimeout = TimeSpan.FromSeconds(5);
+            // Simulate failure by delaying the pong, otherwise send it immediately.
+            TimeSpan pongDelay = expectRequestFail ? pingTimeout * 2 : TimeSpan.Zero;
+            // Pings are send only if KeepAlivePingDelay is not infinite.
+            bool expectStreamPing = keepAlivePingDelay != Timeout.InfiniteTimeSpan;
+            // Pings (regardless ongoing communication) are send only if sending is on and policy is set to always.
+            bool expectPingWithoutStream = expectStreamPing && keepAlivePingPolicy == HttpKeepAlivePingPolicy.Always;
 
             await Http2LoopbackServer.CreateClientAndServerAsync(
                 async uri =>
                 {
                     SocketsHttpHandler handler = new SocketsHttpHandler()
                     {
-                        KeepAlivePingTimeout = TimeSpan.FromSeconds(1),
+                        KeepAlivePingTimeout = pingTimeout,
                         KeepAlivePingPolicy = keepAlivePingPolicy,
                         KeepAlivePingDelay = keepAlivePingDelay
                     };
@@ -339,16 +344,23 @@ await Http2LoopbackServer.CreateClientAndServerAsync(
                     await client.GetStringAsync(uri);
                     // Request under the test scope.
                     if (expectRequestFail)
+                    {
                         await Assert.ThrowsAsync<HttpRequestException>(() => client.GetStringAsync(uri));
+                    }
                     else
+                    {
                         await client.GetStringAsync(uri);
+                    }
 
                     // Let connection live for a while.
                     await Task.Delay(pingTimeout);
                 },
                 async server =>
                 {
                     using Http2LoopbackConnection connection = await server.EstablishConnectionAsync();
+
+                    Task<PingFrame> receivePingTask = expectStreamPing ? connection.ExpectPingFrameAsync() : null;
+
                     // Warmup the connection.
                     int streamId1 = await connection.ReadRequestHeaderAsync();
                     await connection.SendDefaultResponseAsync(streamId1);
@@ -363,7 +375,15 @@ await Http2LoopbackServer.CreateClientAndServerAsync(
                     }
                     else
                     {
-                        PingFrame ping = await connection.ReadPingAsync(pingTimeout);
+                        PingFrame ping;
+                        if (receivePingTask != null && receivePingTask.IsCompleted)
+                        {
+                            ping = await receivePingTask;
+                        }
+                        else
+                        {
+                            ping = await connection.ReadPingAsync(pingTimeout);
+                        }
                         await Task.Delay(pongDelay);
 
                         await connection.SendPingAckAsync(ping.Data);
@@ -372,7 +392,7 @@ await Http2LoopbackServer.CreateClientAndServerAsync(
                     // Send response and close the stream.
                     if (expectRequestFail)
                     {
-                        await Assert.ThrowsAsync<IOException>(() => connection.SendDefaultResponseAsync(streamId2));
+                        await Assert.ThrowsAsync<NetworkException>(() => connection.SendDefaultResponseAsync(streamId2));
                         // As stream is closed we don't want to continue with sending data.
                         return;
                     }