Only call WaitOne for ERROR_IO_PENDING, extend test to verify handle usability after failure

Co-authored-by: adamsitnik <6011991+adamsitnik@users.noreply.github.com>

Author: Copilot

src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Windows.cs

@@ -79,11 +79,12 @@ private static unsafe int ReadSyncUsingAsyncHandle(SafeFileHandle handle, Span<b
                     Interop.Kernel32.ReadFile(handle, pinned, buffer.Length, IntPtr.Zero, overlapped);
 
                     int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
-                    if (errorCode is Interop.Errors.ERROR_IO_PENDING or Interop.Errors.ERROR_SUCCESS)
+                    if (errorCode is Interop.Errors.ERROR_IO_PENDING)
                     {
                         try
                         {
                             waitEvent.WaitOne();
+                            errorCode = Interop.Errors.ERROR_SUCCESS;
                         }
                         catch
                         {
@@ -94,7 +95,10 @@ private static unsafe int ReadSyncUsingAsyncHandle(SafeFileHandle handle, Span<b
                             Interop.Kernel32.GetOverlappedResult(handle, overlapped, ref canceledBytes, bWait: true);
                             throw;
                         }
+                    }
 
+                    if (errorCode is Interop.Errors.ERROR_SUCCESS)
+                    {
                         int result = 0;
                         if (Interop.Kernel32.GetOverlappedResult(handle, overlapped, ref result, bWait: false))
                         {
@@ -170,11 +174,12 @@ private static unsafe void WriteSyncUsingAsyncHandle(SafeFileHandle handle, Read
                     Interop.Kernel32.WriteFile(handle, pinned, buffer.Length, IntPtr.Zero, overlapped);
 
                     int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
-                    if (errorCode is Interop.Errors.ERROR_IO_PENDING or Interop.Errors.ERROR_SUCCESS)
+                    if (errorCode is Interop.Errors.ERROR_IO_PENDING)
                     {
                         try
                         {
                             waitEvent.WaitOne();
+                            errorCode = Interop.Errors.ERROR_SUCCESS;
                         }
                         catch
                         {
@@ -185,7 +190,10 @@ private static unsafe void WriteSyncUsingAsyncHandle(SafeFileHandle handle, Read
                             Interop.Kernel32.GetOverlappedResult(handle, overlapped, ref canceledBytes, bWait: true);
                             throw;
                         }
+                    }
 
+                    if (errorCode is Interop.Errors.ERROR_SUCCESS)
+                    {
                         int result = 0;
                         if (Interop.Kernel32.GetOverlappedResult(handle, overlapped, ref result, bWait: false))
                         {

src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/RandomAccess/Mixed.Windows.cs

@@ -152,12 +152,14 @@ public void SyncIOOnAsyncHandle_DoesNotCorruptMemory_WhenSynchronizationContextT
             // the pending IO is properly canceled before freeing the NativeOverlapped,
             // preventing use-after-free / heap corruption.
             string filePath = GetTestFilePath();
-            File.WriteAllBytes(filePath, new byte[1024]);
+            byte[] expectedData = new byte[1024];
+            Random.Shared.NextBytes(expectedData);
+            File.WriteAllBytes(filePath, expectedData);
 
             SynchronizationContext previous = SynchronizationContext.Current;
             try
             {
-                var throwingContext = new ThrowingSynchronizationContext();
+                ThrowingSynchronizationContext throwingContext = new();
                 SynchronizationContext.SetSynchronizationContext(throwingContext);
 
                 using SafeFileHandle handle = File.OpenHandle(filePath, FileMode.Open, FileAccess.Read, options: FileOptions.Asynchronous);
@@ -167,6 +169,14 @@ public void SyncIOOnAsyncHandle_DoesNotCorruptMemory_WhenSynchronizationContextT
                 // The ThrowingSynchronizationContext.Wait throws, which should be caught
                 // and the IO should be canceled gracefully.
                 Assert.Throws<InvalidOperationException>(() => RandomAccess.Read(handle, buffer, 0));
+
+                // Restore the previous context and verify the handle is still usable.
+                SynchronizationContext.SetSynchronizationContext(previous);
+
+                byte[] readBuffer = new byte[expectedData.Length];
+                int bytesRead = RandomAccess.Read(handle, readBuffer, 0);
+                Assert.Equal(expectedData.Length, bytesRead);
+                Assert.Equal(expectedData, readBuffer);
             }
             finally
             {