improve resiliency of quic test

src/libraries/System.Net.Quic/ref/System.Net.Quic.cs

@@ -44,6 +44,7 @@ public partial class QuicException : System.Exception
     {
         public QuicException(string? message) { }
         public QuicException(string? message, System.Exception? innerException) { }
+        public QuicException(string? message, System.Exception? innerException, int result) { }
     }
     public static partial class QuicImplementationProviders
     {

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

@@ -159,6 +159,9 @@
   <data name="net_quic_cert_chain_validation" xml:space="preserve">
     <value>The remote certificate is invalid because of errors in the certificate chain: {0}</value>
   </data>
+  <data name="net_quic_not_connected" xml:space="preserve">
+    <value>Connection is not connected.</value>
+  </data>
   <data name="net_ssl_app_protocols_invalid" xml:space="preserve">
     <value>The application protocol list is invalid.</value>
   </data>

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/Internal/QuicExceptionHelpers.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Net.Sockets;
+
 namespace System.Net.Quic.Implementations.MsQuic.Internal
 {
     internal static class QuicExceptionHelpers
@@ -15,7 +17,22 @@ internal static void ThrowIfFailed(uint status, string? message = null, Exceptio
 
         internal static Exception CreateExceptionForHResult(uint status, string? message = null, Exception? innerException = null)
         {
-            return new QuicException($"{message} Error Code: {MsQuicStatusCodes.GetError(status)}", innerException);
+            return new QuicException($"{message} Error Code: {MsQuicStatusCodes.GetError(status)}", innerException, MapMsQuicStatusToHResult(status));
+        }
+
+        internal static int MapMsQuicStatusToHResult(uint status)
+        {
+            switch (status)
+            {
+                case MsQuicStatusCodes.ConnectionRefused:
+                    return (int)SocketError.ConnectionRefused;  // 0x8007274D - WSAECONNREFUSED
+                case MsQuicStatusCodes.ConnectionTimeout:
+                    return (int)SocketError.TimedOut;           // 0x8007274C - WSAETIMEDOUT
+                case MsQuicStatusCodes.HostUnreachable:
+                    return (int)SocketError.HostUnreachable;
+                default:
+                    return 0;
+            }
         }
     }
 }

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicConnection.cs

@@ -171,7 +171,12 @@ public MsQuicConnection(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, Saf
         // constructor for outbound connections
         public MsQuicConnection(QuicClientConnectionOptions options)
         {
-            _remoteEndPoint = options.RemoteEndPoint!;
+            if (options.RemoteEndPoint == null)
+            {
+                throw new ArgumentNullException(nameof(options.RemoteEndPoint));
+            }
+
+            _remoteEndPoint = options.RemoteEndPoint;
             _configuration = SafeMsQuicConfigurationHandle.Create(options);
             _state.RemoteCertificateRequired = true;
             if (options.ClientAuthenticationOptions != null)
@@ -523,13 +528,21 @@ internal override ValueTask WaitForAvailableBidirectionalStreamsAsync(Cancellati
         internal override QuicStreamProvider OpenUnidirectionalStream()
         {
             ThrowIfDisposed();
+            if (!Connected)
+            {
+                throw new InvalidOperationException(SR.net_quic_not_connected);
+            }
 
             return new MsQuicStream(_state, QUIC_STREAM_OPEN_FLAGS.UNIDIRECTIONAL);
         }
 
         internal override QuicStreamProvider OpenBidirectionalStream()
         {
             ThrowIfDisposed();
+            if (!Connected)
+            {
+                throw new InvalidOperationException(SR.net_quic_not_connected);
+            }
 
             return new MsQuicStream(_state, QUIC_STREAM_OPEN_FLAGS.NONE);
         }
@@ -552,15 +565,15 @@ internal override ValueTask ConnectAsync(CancellationToken cancellationToken = d
 
             if (_configuration is null)
             {
-                throw new Exception($"{nameof(ConnectAsync)} must not be called on a connection obtained from a listener.");
+                throw new InvalidOperationException($"{nameof(ConnectAsync)} must not be called on a connection obtained from a listener.");
             }
 
             QUIC_ADDRESS_FAMILY af = _remoteEndPoint.AddressFamily switch
             {
                 AddressFamily.Unspecified => QUIC_ADDRESS_FAMILY.UNSPEC,
                 AddressFamily.InterNetwork => QUIC_ADDRESS_FAMILY.INET,
                 AddressFamily.InterNetworkV6 => QUIC_ADDRESS_FAMILY.INET6,
-                _ => throw new Exception(SR.Format(SR.net_quic_unsupported_address_family, _remoteEndPoint.AddressFamily))
+                _ => throw new ArgumentException(SR.Format(SR.net_quic_unsupported_address_family, _remoteEndPoint.AddressFamily))
             };
 
             Debug.Assert(_state.StateGCHandle.IsAllocated);
@@ -592,7 +605,7 @@ internal override ValueTask ConnectAsync(CancellationToken cancellationToken = d
             }
             else
             {
-                throw new Exception($"Unsupported remote endpoint type '{_remoteEndPoint.GetType()}'.");
+                throw new ArgumentException($"Unsupported remote endpoint type '{_remoteEndPoint.GetType()}'.");
             }
 
             // We store TCS to local variable to avoid NRE if callbacks finish fast and set _state.ConnectTcs to null.
@@ -759,7 +772,7 @@ private void Dispose(bool disposing)
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(_state, $"{TraceId()} Connection disposing {disposing}");
 
             // If we haven't already shutdown gracefully (via a successful CloseAsync call), then force an abortive shutdown.
-            if (_state.Handle != null)
+            if (_state.Handle != null && !_state.Handle.IsInvalid && !_state.Handle.IsClosed)
             {
                 // Handle can be null if outbound constructor failed and we are called from finalizer.
                 Debug.Assert(!Monitor.IsEntered(_state));

src/libraries/System.Net.Quic/src/System/Net/Quic/Implementations/MsQuic/MsQuicListener.cs

@@ -12,7 +12,6 @@
 using System.Threading.Channels;
 using System.Threading.Tasks;
 using static System.Net.Quic.Implementations.MsQuic.Internal.MsQuicNativeMethods;
-using System.Security.Authentication;
 
 namespace System.Net.Quic.Implementations.MsQuic
 {
@@ -37,6 +36,12 @@ private sealed class State
 
             public QuicOptions ConnectionOptions = new QuicOptions();
             public SslServerAuthenticationOptions AuthenticationOptions = new SslServerAuthenticationOptions();
+#if DEBUG
+            public int EventCount;
+            public int ErrorCount;
+            public int ConnectionCount;
+            public Exception? ex;
+#endif
 
             public State(QuicListenerOptions options)
             {
@@ -219,15 +224,20 @@ private static unsafe uint NativeCallbackHandler(
             IntPtr context,
             ref ListenerEvent evt)
         {
-            if (evt.Type != QUIC_LISTENER_EVENT.NEW_CONNECTION)
-            {
-                return MsQuicStatusCodes.InternalError;
-            }
-
             GCHandle gcHandle = GCHandle.FromIntPtr(context);
             Debug.Assert(gcHandle.IsAllocated);
             Debug.Assert(gcHandle.Target is not null);
             var state = (State)gcHandle.Target;
+#if DEBUG
+            state.EventCount++;
+#endif
+            if (evt.Type != QUIC_LISTENER_EVENT.NEW_CONNECTION)
+            {
+#if DEBUG
+                state.ErrorCount++;
+#endif
+                return MsQuicStatusCodes.InternalError;
+            }
 
             SafeMsQuicConnectionHandle? connectionHandle = null;
             MsQuicConnection? msQuicConnection = null;
@@ -266,6 +276,10 @@ private static unsafe uint NativeCallbackHandler(
                     if (connectionConfiguration == null)
                     {
                         // We don't have safe handle yet so MsQuic will cleanup new connection.
+#if DEBUG
+                        state.ErrorCount++;
+#endif
+
                         return MsQuicStatusCodes.InternalError;
                     }
                 }
@@ -280,6 +294,10 @@ private static unsafe uint NativeCallbackHandler(
 
                     if (state.AcceptConnectionQueue.Writer.TryWrite(msQuicConnection))
                     {
+#if DEBUG
+                        state.ConnectionCount++;
+#endif
+
                         return MsQuicStatusCodes.Success;
                     }
                 }
@@ -288,12 +306,18 @@ private static unsafe uint NativeCallbackHandler(
             }
             catch (Exception ex)
             {
+#if DEBUG
+                state.ex = ex;
+#endif
+
                 if (NetEventSource.Log.IsEnabled())
                 {
                     NetEventSource.Error(state, $"[Listener#{state.GetHashCode()}] Exception occurred during handling {(QUIC_LISTENER_EVENT)evt.Type} connection callback: {ex}");
                 }
             }
-
+#if DEBUG
+            state.ErrorCount++;
+#endif
             // This handle will be cleaned up by MsQuic by returning InternalError.
             connectionHandle?.SetHandleAsInvalid();
             msQuicConnection?.Dispose();

src/libraries/System.Net.Quic/src/System/Net/Quic/QuicException.cs

@@ -13,5 +13,11 @@ public QuicException(string? message, Exception? innerException)
             : base(message, innerException)
         {
         }
+
+        public QuicException(string? message, Exception? innerException, int result)
+            : base(message, innerException)
+        {
+            HResult = result;
+        }
     }
 }