CI Test

src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.cs

@@ -77,7 +77,8 @@ public static void Info(object? thisOrContextObject, object? message, [CallerMem
         [Event(InfoEventId, Level = EventLevel.Informational, Keywords = Keywords.Default)]
         private void Info(string thisOrContextObject, string? memberName, string? message)
         {
-            Debug.Assert(IsEnabled());
+            //Debug.Assert(IsEnabled());
+            if (!IsEnabled()) return;
             WriteEvent(InfoEventId, thisOrContextObject, memberName ?? MissingMember, message);
         }
         #endregion
@@ -102,7 +103,8 @@ public static void Error(object? thisOrContextObject, object message, [CallerMem
         [Event(ErrorEventId, Level = EventLevel.Error, Keywords = Keywords.Default)]
         private void ErrorMessage(string thisOrContextObject, string? memberName, string? message)
         {
-            Debug.Assert(IsEnabled());
+            //Debug.Assert(IsEnabled());
+            if (!IsEnabled()) return;
             WriteEvent(ErrorEventId, thisOrContextObject, memberName ?? MissingMember, message);
         }
         #endregion

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

@@ -188,6 +188,7 @@ public class GenericLoopbackOptions
 #if !NETSTANDARD2_0 && !NETFRAMEWORK
         public SslStreamCertificateContext? CertificateContext { get; set; }
 #endif
+        public Xunit.Abstractions.ITestOutputHelper? TestOutputHelper { get; set; }
     }
 
     public struct HttpHeaderData

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

@@ -52,9 +52,12 @@ public sealed class Http3LoopbackConnection : GenericLoopbackConnection
         public Http3LoopbackStream OutboundControlStream => _outboundControlStream ?? throw new Exception("Control stream has not been opened yet");
         public Http3LoopbackStream InboundControlStream => _inboundControlStream ?? throw new Exception("Inbound control stream has not been accepted yet");
 
-        public Http3LoopbackConnection(QuicConnection connection)
+        private Xunit.Abstractions.ITestOutputHelper? _output;
+
+        public Http3LoopbackConnection(QuicConnection connection, Xunit.Abstractions.ITestOutputHelper? output)
         {
             _connection = connection;
+            _output = output;
         }
 
         public long MaxHeaderListSize { get; private set; } = -1;
@@ -92,12 +95,12 @@ public override async ValueTask DisposeAsync()
 
         public async ValueTask<Http3LoopbackStream> OpenUnidirectionalStreamAsync()
         {
-            return new Http3LoopbackStream(await _connection.OpenOutboundStreamAsync(QuicStreamType.Unidirectional));
+            return new Http3LoopbackStream(await _connection.OpenOutboundStreamAsync(QuicStreamType.Unidirectional), _output);
         }
 
         public async ValueTask<Http3LoopbackStream> OpenBidirectionalStreamAsync()
         {
-            return new Http3LoopbackStream(await _connection.OpenOutboundStreamAsync(QuicStreamType.Bidirectional));
+            return new Http3LoopbackStream(await _connection.OpenOutboundStreamAsync(QuicStreamType.Bidirectional), _output);
         }
 
         public static int GetRequestId(QuicStream stream)
@@ -124,23 +127,23 @@ private Task EnsureControlStreamAcceptedAsync()
             async Task EnsureControlStreamAcceptedInternalAsync()
             {
                 Http3LoopbackStream controlStream;
-
                 while (true)
                 {
+                    _output?.WriteLine($"{this} {_connection} Accepting a new stream");
                     QuicStream quicStream = await _connection.AcceptInboundStreamAsync().ConfigureAwait(false);
-
+                    _output?.WriteLine($"{this} {quicStream} Accepted a stream, CanWrite = {quicStream.CanWrite}");
                     if (!quicStream.CanWrite)
                     {
                         // control stream accepted
-                        controlStream = new Http3LoopbackStream(quicStream);
+                        controlStream = new Http3LoopbackStream(quicStream, _output);
                         break;
                     }
 
                     // control streams are unidirectional, so this must be a request stream
                     // keep it for later and wait for another stream
                     _delayedStreams.Enqueue(quicStream);
                 }
-
+                _output?.WriteLine($"{this} {_connection} All streams has been caught, delayed streams count = {_delayedStreams.Count}");
                 long? streamType = await controlStream.ReadIntegerAsync();
                 Assert.Equal(Http3LoopbackStream.ControlStream, streamType);
 
@@ -157,14 +160,15 @@ async Task EnsureControlStreamAcceptedInternalAsync()
         // This will automatically handle the control stream, including validating its contents
         public async Task<Http3LoopbackStream> AcceptRequestStreamAsync()
         {
+            _output?.WriteLine($"{this} {_connection} Accepting control stream.");
             await EnsureControlStreamAcceptedAsync().ConfigureAwait(false);
 
             if (!_delayedStreams.TryDequeue(out QuicStream quicStream))
             {
                 quicStream = await _connection.AcceptInboundStreamAsync().ConfigureAwait(false);
             }
 
-            var stream = new Http3LoopbackStream(quicStream);
+            var stream = new Http3LoopbackStream(quicStream, _output);
 
             Assert.True(quicStream.CanWrite, "Expected writeable stream.");
 
@@ -185,9 +189,11 @@ public async Task<Http3LoopbackStream> AcceptRequestStreamAsync()
 
         public async Task EstablishControlStreamAsync(SettingsEntry[] settingsEntries)
         {
-            _outboundControlStream = await OpenUnidirectionalStreamAsync();
-            await _outboundControlStream.SendUnidirectionalStreamTypeAsync(Http3LoopbackStream.ControlStream);
-            await _outboundControlStream.SendSettingsFrameAsync(settingsEntries);
+            _output?.WriteLine($"{this} Establishing control stream");
+            _outboundControlStream = await OpenUnidirectionalStreamAsync().ConfigureAwait(false);
+            _output?.WriteLine($"{this} {_outboundControlStream.Stream} Stream opened.");
+            await _outboundControlStream.SendUnidirectionalStreamTypeAsync(Http3LoopbackStream.ControlStream).ConfigureAwait(false);
+            await _outboundControlStream.SendSettingsFrameAsync(settingsEntries).ConfigureAwait(false);
         }
 
         public async Task DisposeCurrentStream()
@@ -241,6 +247,7 @@ public override Task SendPartialResponseHeadersAsync(HttpStatusCode statusCode =
 
         public override async Task<HttpRequestData> HandleRequestAsync(HttpStatusCode statusCode = HttpStatusCode.OK, IList<HttpHeaderData> headers = null, string content = "")
         {
+            _output?.WriteLine($"{this} {_connection} HandleRequestAsync triggered.");
             Http3LoopbackStream stream = await AcceptRequestStreamAsync().ConfigureAwait(false);
 
             HttpRequestData request = await stream.ReadRequestDataAsync().ConfigureAwait(false);

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

@@ -16,6 +16,7 @@ public sealed class Http3LoopbackServer : GenericLoopbackServer
     {
         private X509Certificate2 _cert;
         private QuicListener _listener;
+        private Xunit.Abstractions.ITestOutputHelper? _output;
 
         public override Uri Address => new Uri($"https://{_listener.LocalEndPoint}/");
 
@@ -58,6 +59,8 @@ public Http3LoopbackServer(Http3Options options = null)
             ValueTask<QuicListener> valueTask = QuicListener.ListenAsync(listenerOptions);
             Debug.Assert(valueTask.IsCompleted);
             _listener = valueTask.Result;
+            _output = options.TestOutputHelper;
+            _output?.WriteLine($"{this} Http3LoopbackServer created.");
         }
 
         public override void Dispose()
@@ -68,16 +71,19 @@ public override void Dispose()
 
         private async Task<Http3LoopbackConnection> EstablishHttp3ConnectionAsync(params SettingsEntry[] settingsEntries)
         {
+            _output?.WriteLine($"{this} Accepting connection");
             QuicConnection con = await _listener.AcceptConnectionAsync().ConfigureAwait(false);
-            Http3LoopbackConnection connection = new Http3LoopbackConnection(con);
+            _output?.WriteLine($"{this} Connection accepted: {con}");
+            Http3LoopbackConnection connection = new Http3LoopbackConnection(con, _output);
 
-            await connection.EstablishControlStreamAsync(settingsEntries);
+            await connection.EstablishControlStreamAsync(settingsEntries).ConfigureAwait(false);
+            _output?.WriteLine($"{this} {con} Control stream established");
             return connection;
         }
 
         public override async Task<GenericLoopbackConnection> EstablishGenericConnectionAsync()
         {
-            return await EstablishHttp3ConnectionAsync();
+            return await EstablishHttp3ConnectionAsync().ConfigureAwait(false);
         }
 
         public Task<Http3LoopbackConnection> EstablishConnectionAsync(params SettingsEntry[] settingsEntries)
@@ -94,7 +100,9 @@ public override async Task AcceptConnectionAsync(Func<GenericLoopbackConnection,
 
         public override async Task<HttpRequestData> HandleRequestAsync(HttpStatusCode statusCode = HttpStatusCode.OK, IList<HttpHeaderData> headers = null, string content = "")
         {
-            await using Http3LoopbackConnection con = (Http3LoopbackConnection)await EstablishGenericConnectionAsync().ConfigureAwait(false);
+            _output?.WriteLine("Establishing HTTP/3 connection.");
+            await using Http3LoopbackConnection con = await EstablishHttp3ConnectionAsync().ConfigureAwait(false);
+            _output?.WriteLine($"{con} HTTP/3 Connection established successfully!");
             return await con.HandleRequestAsync(statusCode, headers, content).ConfigureAwait(false);
         }
     }
@@ -138,6 +146,7 @@ private static Http3Options CreateOptions(GenericLoopbackOptions options)
                 http3Options.Certificate = options.Certificate;
                 http3Options.SslProtocols = options.SslProtocols;
                 http3Options.ListenBacklog = options.ListenBacklog;
+                http3Options.TestOutputHelper = options.TestOutputHelper;
             }
             return http3Options;
         }

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

@@ -34,13 +34,19 @@ public sealed class Http3LoopbackStream : IAsyncDisposable
         public bool CanRead => _stream.CanRead;
         public bool CanWrite => _stream.CanWrite;
 
-        public Http3LoopbackStream(QuicStream stream)
+        private Xunit.Abstractions.ITestOutputHelper? _output;
+
+        public Http3LoopbackStream(QuicStream stream, Xunit.Abstractions.ITestOutputHelper? output)
         {
             _stream = stream;
+            _output = output;
+            _output?.WriteLine($"Created stream {stream}, Readable: {stream.CanRead}, Writable: {stream.CanWrite}");
         }
 
         public ValueTask DisposeAsync() => _stream.DisposeAsync();
 
+        public QuicStream Stream => _stream;
+
         public long StreamId => _stream.Id;
 
         public async Task<HttpRequestData> HandleRequestAsync(HttpStatusCode statusCode = HttpStatusCode.OK, IList<HttpHeaderData> headers = null, string content = "")
@@ -162,7 +168,9 @@ private async Task SendFrameHeaderAsync(long frameType, int payloadLength)
         public async Task SendFrameAsync(long frameType, ReadOnlyMemory<byte> framePayload)
         {
             await SendFrameHeaderAsync(frameType, framePayload.Length).ConfigureAwait(false);
+            _output?.WriteLine($"Sent {frameType} header");
             await _stream.WriteAsync(framePayload).ConfigureAwait(false);
+            _output?.WriteLine($"Sent {framePayload} - Length: {framePayload.Length} frame");
         }
 
         static int EncodeHttpInteger(long longToEncode, Span<byte> buffer)
@@ -431,9 +439,11 @@ public void Abort(long errorCode)
         public async Task<(long? frameType, byte[] payload)> ReadFrameAsync()
         {
             long? frameType = await ReadIntegerAsync().ConfigureAwait(false);
+            _output?.WriteLine($"Read frame type: {frameType}");
             if (frameType == null) return (null, null);
 
             long? payloadLength = await ReadIntegerAsync().ConfigureAwait(false);
+            _output?.WriteLine($"Read payload length: {payloadLength}");
             if (payloadLength == null) throw new Exception("Unable to read frame; unexpected end of stream.");
 
             byte[] payload = new byte[checked((int)payloadLength)];
@@ -442,11 +452,13 @@ public void Abort(long errorCode)
             while (totalBytesRead != payloadLength)
             {
                 int bytesRead = await _stream.ReadAsync(payload.AsMemory(totalBytesRead)).ConfigureAwait(false);
+                _output?.WriteLine($"Read {bytesRead} bytes of payload");
                 if (bytesRead == 0) throw new Exception("Unable to read frame; unexpected end of stream.");
 
                 totalBytesRead += bytesRead;
             }
 
+            _output?.WriteLine($"Read frame payload: {payload}");
             return (frameType, payload);
         }
 

src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Cookies.cs

@@ -44,7 +44,7 @@ private static CookieContainer CreateSingleCookieContainer(Uri uri, string cooki
         private static string GetCookieHeaderValue(string cookieName, string cookieValue) => $"{cookieName}={cookieValue}";
 
         [Fact]
-        public virtual async Task GetAsync_DefaultCoookieContainer_NoCookieSent()
+        public async Task GetAsync_DefaultCoookieContainer_NoCookieSent()
         {
             await LoopbackServerFactory.CreateClientAndServerAsync(
                 async uri =>
@@ -216,15 +216,10 @@ private string GetCookieValue(HttpRequestData request)
             return cookieHeaderValue;
         }
 
-        [ConditionalFact]
+        [Fact]
         [SkipOnPlatform(TestPlatforms.Browser, "CookieContainer is not supported on Browser")]
         public async Task GetAsync_SetCookieContainerAndCookieHeader_BothCookiesSent()
         {
-            if (UseVersion == HttpVersion30)
-            {
-                throw new SkipTestException("https://github.com/dotnet/runtime/issues/101377");
-            }
-
             await LoopbackServerFactory.CreateServerAsync(async (server, url) =>
             {
                 HttpClientHandler handler = CreateHttpClientHandler();
@@ -318,7 +313,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async url =>
                 using (HttpClient client = CreateHttpClient(handler))
                 {
                     client.DefaultRequestHeaders.ConnectionClose = true; // to avoid issues with connection pooling
-                    await client.GetAsync(url1);
+                        await client.GetAsync(url1);
                 }
             },
             async server =>

src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.MaxResponseHeadersLength.cs

@@ -14,6 +14,7 @@
 using Microsoft.DotNet.XUnitExtensions;
 using Xunit;
 using Xunit.Abstractions;
+using TestUtilities;
 
 namespace System.Net.Http.Functional.Tests
 {
@@ -56,6 +57,24 @@ public void ValidValue_SetGet_Roundtrips(int validValue)
         [Fact]
         public async Task SetAfterUse_Throws()
         {
+            AsyncLocal<object> asyncLocal = new();
+            asyncLocal.Value = new();
+
+            TestEventListener? listener = null;
+            if (UseVersion == HttpVersion30)
+            {
+                listener = new TestEventListener(e =>
+                {
+                    if (asyncLocal.Value is not null)
+                    {
+                        lock (_output)
+                        {
+                            _output.WriteLine($"[SetAfterUse]{e}");
+                        }
+                    }
+                }, TestEventListener.NetworkingEvents);
+            }
+
             await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             {
                 using HttpClientHandler handler = CreateHttpClientHandler();
@@ -65,14 +84,33 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
                 (await client.GetStreamAsync(uri)).Dispose();
                 Assert.Throws<InvalidOperationException>(() => handler.MaxResponseHeadersLength = 1);
             },
-            server => server.AcceptConnectionSendResponseAndCloseAsync());
+            server => server.AcceptConnectionSendResponseAndCloseAsync(), options: new() { TestOutputHelper = _output });
+            listener?.Dispose();
         }
 
         [Theory]
         [InlineData(1)]
         [InlineData(15)]
         public async Task LargeSingleHeader_ThrowsException(int maxResponseHeadersLength)
         {
+            AsyncLocal<object> asyncLocal = new();
+            asyncLocal.Value = new();
+
+            TestEventListener? listener = null;
+            if (UseVersion == HttpVersion30)
+            {
+                listener = new TestEventListener(e =>
+                {
+                    if (asyncLocal.Value is not null)
+                    {
+                        lock (_output)
+                        {
+                            _output.WriteLine($"[LargeSingleHeader_ThrowsException]{e}");
+                        }
+                    }
+                }, TestEventListener.NetworkingEvents);
+            }
+
             using HttpClientHandler handler = CreateHttpClientHandler();
             handler.MaxResponseHeadersLength = maxResponseHeadersLength;
 
@@ -88,6 +126,7 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
             },
             async server =>
             {
+                _output.WriteLine($"Listening on {server.Address}");
                 try
                 {
                     await server.HandleRequestAsync(headers: new[] { new HttpHeaderData("Foo", new string('a', handler.MaxResponseHeadersLength * 1024)) });
@@ -97,7 +136,9 @@ await LoopbackServerFactory.CreateClientAndServerAsync(async uri =>
 #if !WINHTTPHANDLER_TEST
                 catch (QuicException ex) when (ex.QuicError == QuicError.StreamAborted && ex.ApplicationErrorCode == Http3ExcessiveLoad) {}
 #endif
-            });
+            }, options: new() { TestOutputHelper = _output });
+
+            listener?.Dispose();
         }
 
         [Theory]