QUIC stream limits

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

@@ -63,7 +63,6 @@ private sealed class State
             // Set once writes have been shutdown.
             public readonly TaskCompletionSource ShutdownWriteCompletionSource = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
 
-
             public ShutdownState ShutdownState;
 
             // Set once stream have been shutdown.

src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs

@@ -53,6 +53,56 @@ public async Task UnidirectionalAndBidirectionalChangeValues()
             Assert.Equal(20, serverConnection.GetRemoteAvailableUnidirectionalStreamCount());
         }
 
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/52048")]
+        public async Task WaitForAvailableUnidirectionStreamsAsyncWorks()
+        {
+            using QuicListener listener = CreateQuicListener(maxUnidirectionalStreams: 1);
+            using QuicConnection clientConnection = CreateQuicConnection(listener.ListenEndPoint);
+
+            ValueTask clientTask = clientConnection.ConnectAsync();
+            using QuicConnection serverConnection = await listener.AcceptConnectionAsync();
+            await clientTask;
+
+            // No stream openned yet, should return immediately.
+            Assert.True(clientConnection.WaitForAvailableUnidirectionalStreamsAsync().IsCompletedSuccessfully);
+
+            // Open one stream, should wait till it closes.
+            QuicStream stream = clientConnection.OpenUnidirectionalStream();
+            ValueTask waitTask = clientConnection.WaitForAvailableUnidirectionalStreamsAsync();
+            Assert.False(waitTask.IsCompleted);
+            Assert.Throws<QuicException>(() => clientConnection.OpenUnidirectionalStream());
+
+            // Close the stream, the waitTask should finish as a result.
+            stream.Dispose();
+            await waitTask.AsTask().WaitAsync(TimeSpan.FromSeconds(10));
+        }
+
+        [Fact]
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/52048")]
+        public async Task WaitForAvailableBidirectionStreamsAsyncWorks()
+        {
+            using QuicListener listener = CreateQuicListener(maxBidirectionalStreams: 1);
+            using QuicConnection clientConnection = CreateQuicConnection(listener.ListenEndPoint);
+
+            ValueTask clientTask = clientConnection.ConnectAsync();
+            using QuicConnection serverConnection = await listener.AcceptConnectionAsync();
+            await clientTask;
+
+            // No stream openned yet, should return immediately.
+            Assert.True(clientConnection.WaitForAvailableBidirectionalStreamsAsync().IsCompletedSuccessfully);
+
+            // Open one stream, should wait till it closes.
+            QuicStream stream = clientConnection.OpenBidirectionalStream();
+            ValueTask waitTask = clientConnection.WaitForAvailableBidirectionalStreamsAsync();
+            Assert.False(waitTask.IsCompleted);
+            Assert.Throws<QuicException>(() => clientConnection.OpenBidirectionalStream());
+
+            // Close the stream, the waitTask should finish as a result.
+            stream.Dispose();
+            await waitTask.AsTask().WaitAsync(TimeSpan.FromSeconds(10));
+        }
+
         [Fact]
         [OuterLoop("May take several seconds")]
         public async Task SetListenerTimeoutWorksWithSmallTimeout()

src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestBase.cs

@@ -53,16 +53,30 @@ internal QuicConnection CreateQuicConnection(IPEndPoint endpoint)
             return new QuicConnection(ImplementationProvider, endpoint, GetSslClientAuthenticationOptions());
         }
 
-        internal QuicListener CreateQuicListener()
+        internal QuicListener CreateQuicListener(int maxUnidirectionalStreams = 100, int maxBidirectionalStreams = 100)
         {
-            return CreateQuicListener(new IPEndPoint(IPAddress.Loopback, 0));
+            var options = new QuicListenerOptions()
+            {
+                ListenEndPoint = new IPEndPoint(IPAddress.Loopback, 0),
+                ServerAuthenticationOptions = GetSslServerAuthenticationOptions(),
+                MaxUnidirectionalStreams = maxUnidirectionalStreams,
+                MaxBidirectionalStreams = maxBidirectionalStreams
+            };
+            return CreateQuicListener(options);
         }
 
         internal QuicListener CreateQuicListener(IPEndPoint endpoint)
         {
-            return new QuicListener(ImplementationProvider, endpoint, GetSslServerAuthenticationOptions());
+            var options = new QuicListenerOptions()
+            {
+                ListenEndPoint = endpoint,
+                ServerAuthenticationOptions = GetSslServerAuthenticationOptions()
+            };
+            return CreateQuicListener(options);
         }
 
+        private QuicListener CreateQuicListener(QuicListenerOptions options) => new QuicListener(ImplementationProvider, options);
+
         internal async Task RunClientServer(Func<QuicConnection, Task> clientFunction, Func<QuicConnection, Task> serverFunction, int iterations = 1, int millisecondsTimeout = 10_000)
         {
             using QuicListener listener = CreateQuicListener();