Reverted postponing reading FIN, if data have chance to get buffered …

…with FIN, we will do that.

src/libraries/Common/tests/TestUtilities/System/PlatformDetection.cs

@@ -195,7 +195,6 @@ private static bool GetLinqExpressionsBuiltWithIsInterpretingOnly()
 
         public static bool IsRareEnumsSupported => !IsNativeAot;
 
-        public static bool IsIntMaxValueArrayIndexSupported => !s_largeArrayIsNotSupported.Value;
         public static bool IsNotIntMaxValueArrayIndexSupported => s_largeArrayIsNotSupported.Value;
 
         public static bool IsAssemblyLoadingSupported => !IsNativeAot;

src/libraries/System.Net.Quic/src/System/Net/Quic/Internal/ReceiveBuffers.cs

@@ -12,7 +12,6 @@ internal struct ReceiveBuffers
     private readonly object _syncRoot;
     private MultiArrayBuffer _buffer;
     private bool _final;
-    private int _lastReceiveSize;
 
     public ReceiveBuffers()
     {
@@ -48,7 +47,6 @@ public int CopyFrom(ReadOnlySpan<QUIC_BUFFER> quicBuffers, int totalLength, bool
             }
 
             _final = final;
-            _lastReceiveSize = totalLength;
             _buffer.EnsureAvailableSpace(totalLength);
 
             int totalCopied = 0;
@@ -68,7 +66,7 @@ public int CopyFrom(ReadOnlySpan<QUIC_BUFFER> quicBuffers, int totalLength, bool
         }
     }
 
-    public int CopyTo(Memory<byte> buffer, out bool completed, out bool empty, out int lastReceiveSize)
+    public int CopyTo(Memory<byte> buffer, out bool completed, out bool empty)
     {
         lock (_syncRoot)
         {
@@ -83,7 +81,6 @@ public int CopyTo(Memory<byte> buffer, out bool completed, out bool empty, out i
 
             completed = _buffer.IsEmpty && _final;
             empty = _buffer.IsEmpty;
-            lastReceiveSize = _lastReceiveSize;
 
             return copied;
         }

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

@@ -284,21 +284,14 @@ public override async ValueTask<int> ReadAsync(Memory<byte> buffer, Cancellation
             }
 
             // Copy data from the buffer, reduce target and increment total.
-            int copied = _receiveBuffers.CopyTo(buffer, out bool complete, out bool empty, out int lastReceiveSize);
+            int copied = _receiveBuffers.CopyTo(buffer, out bool complete, out bool empty);
             buffer = buffer.Slice(copied);
             totalCopied += copied;
 
             // Make sure the task transitions into final state before the method finishes.
             if (complete)
             {
                 _receiveTcs.TrySetResult(final: true);
-                unsafe
-                {
-                    // Confirm the last data which came with the FIN flag.
-                    MsQuicApi.Api.StreamReceiveComplete(
-                        _handle,
-                        (ulong)lastReceiveSize);
-                }
             }
 
             // Unblock the next await to end immediately, i.e. there were/are any data in the buffer.
@@ -551,9 +544,6 @@ private unsafe int HandleEventReceive(ref RECEIVE_DATA data)
             (int)data.TotalBufferLength,
             data.Flags.HasFlag(QUIC_RECEIVE_FLAGS.FIN));
 
-        // If we copied all the data and also received FIN flag, postpone the confirmation of the data until they are consumed.
-        bool lastReceive = (totalCopied == data.TotalBufferLength) && data.Flags.HasFlag(QUIC_RECEIVE_FLAGS.FIN);
-
         if (totalCopied < data.TotalBufferLength)
         {
             Volatile.Write(ref _receivedNeedsEnable, 1);
@@ -562,7 +552,7 @@ private unsafe int HandleEventReceive(ref RECEIVE_DATA data)
         _receiveTcs.TrySetResult();
 
         data.TotalBufferLength = totalCopied;
-        return (_receiveBuffers.HasCapacity() && Interlocked.CompareExchange(ref _receivedNeedsEnable, 0, 1) == 1) ? QUIC_STATUS_CONTINUE : lastReceive ? QUIC_STATUS_PENDING : QUIC_STATUS_SUCCESS;
+        return (_receiveBuffers.HasCapacity() && Interlocked.CompareExchange(ref _receivedNeedsEnable, 0, 1) == 1) ? QUIC_STATUS_CONTINUE : QUIC_STATUS_SUCCESS;
     }
     private unsafe int HandleEventSendComplete(ref SEND_COMPLETE_DATA data)
     {

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

@@ -1218,7 +1218,7 @@ async ValueTask ReleaseOnReadsClosedAsync()
         public static IEnumerable<object[]> PayloadSizeAndTwoBools()
         {
             var boolValues = new [] { true, false };
-            var payloadValues = PlatformDetection.IsIntMaxValueArrayIndexSupported ?
+            var payloadValues = !PlatformDetection.IsInHelix ?
                                     new [] { SmallestPayload, SmallPayload, BufferPayload, BufferPlusPayload, BigPayload } :
                                     new [] { SmallestPayload, SmallPayload, BufferPayload, BufferPlusPayload };
             return
@@ -1232,6 +1232,7 @@ from bool2 in boolValues
         [MemberData(nameof(PayloadSizeAndTwoBools))]
         public async Task ReadsClosedFinishes_ConnectionClose(int payloadSize, bool closeServer, bool useDispose)
         {
+            //using var logger = new TestUtilities.TestEventListener(Console.Out, "Private.InternalDiagnostics.System.Net.Quic");
             using SemaphoreSlim serverSem = new SemaphoreSlim(0);
             using SemaphoreSlim clientSem = new SemaphoreSlim(0);
 
@@ -1243,6 +1244,11 @@ await RunClientServer(
 
                     await using QuicStream stream = await connection.AcceptInboundStreamAsync();
                     await stream.WriteAsync(new byte[payloadSize], completeWrites: true);
+                    // Make sure the data gets received by the peer if we expect the reading side to get buffered including FIN.
+                    if (payloadSize <= BufferPayload)
+                    {
+                        await stream.WritesClosed;
+                    }
                     serverSem.Release();
                     await clientSem.WaitAsync();
 
@@ -1260,15 +1266,7 @@ await RunClientServer(
                         }
                     }
 
-                    var ex = await AssertThrowsQuicExceptionAsync(expectedError, () => stream.ReadsClosed);
-                    if (expectedError == QuicError.OperationAborted)
-                    {
-                        Assert.Null(ex.ApplicationErrorCode);
-                    }
-                    else
-                    {
-                        Assert.Equal(expectedErrorCode, ex.ApplicationErrorCode);
-                    }
+                    await CheckReadsClosed(stream, expectedError, expectedErrorCode);
                 },
                 clientFunction: async connection =>
                 {
@@ -1277,6 +1275,10 @@ await RunClientServer(
 
                     await using QuicStream stream = await connection.OpenOutboundStreamAsync(QuicStreamType.Bidirectional);
                     await stream.WriteAsync(new byte[payloadSize], completeWrites: true);
+                    if (payloadSize <= BufferPayload)
+                    {
+                        await stream.WritesClosed;
+                    }
                     clientSem.Release();
                     await serverSem.WaitAsync();
 
@@ -1294,6 +1296,23 @@ await RunClientServer(
                         }
                     }
 
+                    await CheckReadsClosed(stream, expectedError, expectedErrorCode);
+                }
+            );
+
+            async ValueTask CheckReadsClosed(QuicStream stream, QuicError expectedError, long expectedErrorCode)
+            {
+                // All data should be buffered if they fit in the internal buffer, reading should still pass.
+                if (payloadSize <= BufferPayload)
+                {
+                    Assert.False(stream.ReadsClosed.IsCompleted);
+                    var buffer = new byte[BufferPayload];
+                    var length = await ReadAll(stream, buffer);
+                    Assert.True(stream.ReadsClosed.IsCompletedSuccessfully);
+                    Assert.Equal(payloadSize, length);
+                }
+                else
+                {
                     var ex = await AssertThrowsQuicExceptionAsync(expectedError, () => stream.ReadsClosed);
                     if (expectedError == QuicError.OperationAborted)
                     {
@@ -1304,7 +1323,7 @@ await RunClientServer(
                         Assert.Equal(expectedErrorCode, ex.ApplicationErrorCode);
                     }
                 }
-            );
+            }
         }
 
         [Theory]
@@ -1339,15 +1358,7 @@ await RunClientServer(
                         }
                     }
 
-                    var ex = await AssertThrowsQuicExceptionAsync(expectedError, () => stream.WritesClosed);
-                    if (expectedError == QuicError.OperationAborted)
-                    {
-                        Assert.Null(ex.ApplicationErrorCode);
-                    }
-                    else
-                    {
-                        Assert.Equal(expectedErrorCode, ex.ApplicationErrorCode);
-                    }
+                    await CheckWritesClosed(stream, expectedError, expectedErrorCode);
                 },
                 clientFunction: async connection =>
                 {
@@ -1373,17 +1384,22 @@ await RunClientServer(
                         }
                     }
 
-                    var ex = await AssertThrowsQuicExceptionAsync(expectedError, () => stream.WritesClosed);
-                    if (expectedError == QuicError.OperationAborted)
-                    {
-                        Assert.Null(ex.ApplicationErrorCode);
-                    }
-                    else
-                    {
-                        Assert.Equal(expectedErrorCode, ex.ApplicationErrorCode);
-                    }
+                    await CheckWritesClosed(stream, expectedError, expectedErrorCode);
                 }
             );
+
+            async ValueTask CheckWritesClosed(QuicStream stream, QuicError expectedError, long expectedErrorCode)
+            {
+                var ex = await AssertThrowsQuicExceptionAsync(expectedError, () => stream.WritesClosed);
+                if (expectedError == QuicError.OperationAborted)
+                {
+                    Assert.Null(ex.ApplicationErrorCode);
+                }
+                else
+                {
+                    Assert.Equal(expectedErrorCode, ex.ApplicationErrorCode);
+                }
+            }
         }
 
         [Theory]