Fix flakey test

src/Servers/Kestrel/Transport.Quic/src/Internal/QuicStreamContext.cs

@@ -188,7 +188,10 @@ private async Task WaitForWritesCompleted()
             catch (Exception ex)
             {
                 // Send error to DoSend loop.
-                _shutdownWriteReason = ex;
+                lock (_shutdownLock)
+                {
+                    _shutdownReason ??= ex;
+                }
             }
             finally
             {

src/Servers/Kestrel/Transport.Quic/test/QuicStreamContextTests.cs

@@ -402,6 +402,7 @@ public async Task ServerToClientUnidirectionalStream_ServerAborts_ClientGetsAbor
 
             Assert.Equal(TestData, data);
 
+            Logger.LogInformation("Server aborting stream");
             ((IProtocolErrorCodeFeature)serverStream).Error = (long)Http3ErrorCode.InternalError;
             serverStream.Abort(new ConnectionAbortedException("Test message"));
 

src/Servers/Kestrel/test/Interop.FunctionalTests/Http3/Http3RequestTests.cs

@@ -526,6 +526,8 @@ public async Task POST_ClientCancellationBidirectional_RequestAbortRaised(HttpPr
             var readAsyncTask = new TaskCompletionSource<Task>(TaskCreationOptions.RunContinuationsAsynchronously);
             var clientHasCancelledSyncPoint = new SyncPoint();
 
+            using var httpEventSource = new HttpEventSourceListener(LoggerFactory);
+
             var builder = CreateHostBuilder(async context =>
             {
                 context.RequestAborted.Register(() =>
@@ -586,6 +588,7 @@ public async Task POST_ClientCancellationBidirectional_RequestAbortRaised(HttpPr
                 await requestStream.FlushAsync().DefaultTimeout();
                 // Write content
                 await requestStream.WriteAsync(TestData).DefaultTimeout();
+                await requestStream.FlushAsync().DefaultTimeout();
 
                 var response = await responseTask.DefaultTimeout();
 

src/Servers/Kestrel/test/Interop.FunctionalTests/Http3/HttpEventSourceListener.cs

@@ -0,0 +1,92 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.Tracing;
+using System.Text;
+using Microsoft.Extensions.Logging;
+
+namespace Interop.FunctionalTests.Http3
+{
+    public sealed class HttpEventSourceListener : EventListener
+    {
+        private readonly StringBuilder _messageBuilder = new StringBuilder();
+        private readonly ILogger _logger;
+        private readonly object _lock = new object();
+        private bool _disposed;
+
+        public HttpEventSourceListener(ILoggerFactory loggerFactory)
+        {
+            _logger = loggerFactory.CreateLogger(nameof(HttpEventSourceListener));
+            _logger.LogDebug($"Starting {nameof(HttpEventSourceListener)}.");
+        }
+
+        protected override void OnEventSourceCreated(EventSource eventSource)
+        {
+            base.OnEventSourceCreated(eventSource);
+
+            if (eventSource.Name.Contains("System.Net.Quic") ||
+                eventSource.Name.Contains("System.Net.Http"))
+            {
+                lock (_lock)
+                {
+                    if (!_disposed)
+                    {
+                        EnableEvents(eventSource, EventLevel.LogAlways, EventKeywords.All);
+                    }
+                }
+            }
+        }
+
+        protected override void OnEventWritten(EventWrittenEventArgs eventData)
+        {
+            base.OnEventWritten(eventData);
+
+            string message;
+            lock (_messageBuilder)
+            {
+                _messageBuilder.Append("<- Event ");
+                _messageBuilder.Append(eventData.EventSource.Name);
+                _messageBuilder.Append(" - ");
+                _messageBuilder.Append(eventData.EventName);
+                _messageBuilder.Append(" : ");
+                _messageBuilder.AppendJoin(',', eventData.Payload!);
+                _messageBuilder.Append(" ->");
+                message = _messageBuilder.ToString();
+                _messageBuilder.Clear();
+            }
+
+            // We don't know the state of the logger after dispose.
+            // Ensure that any messages written in the background aren't
+            // logged after the listener has been disposed in the test.
+            lock (_lock)
+            {
+                if (!_disposed)
+                {
+                    // EventListener base constructor subscribes to events.
+                    // It is possible to start getting events before the
+                    // super constructor is run and logger is assigned.
+                    _logger?.LogDebug(message);
+                }
+            }
+        }
+
+        public override string ToString()
+        {
+            return _messageBuilder.ToString();
+        }
+
+        public override void Dispose()
+        {
+            base.Dispose();
+
+            lock (_lock)
+            {
+                if (!_disposed)
+                {
+                    _logger?.LogDebug($"Stopping {nameof(HttpEventSourceListener)}.");
+                    _disposed = true;
+                }
+            }
+        }
+    }
+}