fix: address review of the handle registry and adopted streams

- `Flush`, `Flush(bool)` and `FlushAsync` on a stream whose handle has
  been closed throw `ObjectDisposedException`, as `FileStream` does;
  disposing it still succeeds.
- The registry is published with `LazyInitializer`, so threads that
  open their first handle at the same time share one registry.
- `OpenHandle` accepts `BackupOrRestore` (0x02000000), which the
  runtime's options check allows.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TymoqrVYgZwdNSper5ZZB1

Author: mpdreamz

src/TestableIO.System.IO.Abstractions.TestingHelpers/MockFileStream.cs

@@ -384,16 +384,21 @@ public override void WriteByte(byte value)
     /// <inheritdoc />
     public override void Flush()
     {
+        ThrowIfHandleClosed();
         InternalFlush();
     }
 
     /// <inheritdoc />
     public override void Flush(bool flushToDisk)
-        => InternalFlush();
+    {
+        ThrowIfHandleClosed();
+        InternalFlush();
+    }
 
     /// <inheritdoc />
     public override Task FlushAsync(CancellationToken cancellationToken)
     {
+        ThrowIfHandleClosed();
         InternalFlush();
         return Task.CompletedTask;
     }
@@ -477,20 +482,23 @@ private static bool ContentsEqual(byte[] left, byte[] right)
     /// </summary>
     private void ThrowIfHandleDenies(FileAccess required)
     {
-        if (adoptedHandle == null)
+        ThrowIfHandleClosed();
+        if (adoptedHandle != null && !handleAccess.HasFlag(required))
         {
-            return;
+            throw CommonExceptions.AccessDenied(path);
         }
+    }
 
-        if (adoptedHandle.IsClosed)
+    /// <summary>
+    /// Disposing the stream still succeeds once its handle is closed, so this is only checked by the operations the
+    /// caller invokes.
+    /// </summary>
+    private void ThrowIfHandleClosed()
+    {
+        if (adoptedHandle is { IsClosed: true })
         {
             throw CommonExceptions.HandleIsClosed();
         }
-
-        if (!handleAccess.HasFlag(required))
-        {
-            throw CommonExceptions.AccessDenied(path);
-        }
     }
 
     private void RefreshBufferFromSharedFileData()

src/TestableIO.System.IO.Abstractions.TestingHelpers/MockFileSystem.cs

@@ -138,7 +138,8 @@ public MockFileSystem(IDictionary<string, MockFileData> files, MockFileSystemOpt
     /// <summary>
     /// The handles handed out by <see cref="MockFile.OpenHandle"/>. Not serialized, since they stand for open files.
     /// </summary>
-    internal MockSafeFileHandles SafeFileHandles => safeFileHandles ??= new MockSafeFileHandles(this);
+    internal MockSafeFileHandles SafeFileHandles
+        => Threading.LazyInitializer.EnsureInitialized(ref safeFileHandles, () => new MockSafeFileHandles(this));
 #endif
 
     /// <summary>

src/TestableIO.System.IO.Abstractions.TestingHelpers/MockSafeFileHandles.cs

@@ -30,7 +30,8 @@ internal sealed class MockSafeFileHandles
                                                  FileOptions.DeleteOnClose |
                                                  FileOptions.SequentialScan |
                                                  FileOptions.Encrypted |
-                                                 (FileOptions)0x20000000; // NoBuffering
+                                                 (FileOptions)0x20000000 | // NoBuffering
+                                                 (FileOptions)0x02000000; // BackupOrRestore
 
     private readonly IMockFileDataAccessor mockFileDataAccessor;
     private readonly Dictionary<IntPtr, Entry> entries = new();

tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockFileOpenHandleTests.cs

@@ -143,6 +143,21 @@ await That(() => fileSystem.File.OpenHandle(FilePath, FileMode.Create, FileAcces
             .Throws<ArgumentOutOfRangeException>().WithParamName("preallocationSize");
     }
 
+    [TestCase((FileOptions)0x02000000)]
+    [TestCase((FileOptions)0x20000000)]
+    [TestCase(FileOptions.Asynchronous | FileOptions.WriteThrough)]
+    public async Task OpenHandle_WithAnOptionTheRuntimeAccepts_ShouldOpen(FileOptions options)
+    {
+        var fileSystem = new MockFileSystem();
+        fileSystem.AddFile(FilePath, new MockFileData("content"));
+
+        await That(() =>
+        {
+            using var handle = fileSystem.File.OpenHandle(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read,
+                options);
+        }).DoesNotThrow();
+    }
+
     [Test]
     public async Task OpenHandle_PreallocationSizeOnExistingFile_ShouldThrowArgumentException()
     {

tests/TestableIO.System.IO.Abstractions.TestingHelpers.Tests/MockRandomAccessTests.cs

@@ -521,5 +521,43 @@ public async Task Write_ConcurrentlyAtDistinctOffsets_ShouldKeepEveryWrite()
         await That(fileSystem.File.ReadAllBytes(FilePath)).IsEqualTo(expected)
             .Because("RandomAccess permits concurrent writes at distinct offsets");
     }
+    [Test]
+    public async Task FileStreamNew_FlushAfterTheHandleIsClosed_ShouldThrowObjectDisposedException()
+    {
+        var (fileSystem, handle) = Arrange(new byte[] { 1 });
+        var stream = fileSystem.FileStream.New(handle, FileAccess.ReadWrite);
+        handle.Dispose();
+
+        await That(() => stream.Flush()).Throws<ObjectDisposedException>();
+        await That(() => stream.Flush(flushToDisk: true)).Throws<ObjectDisposedException>();
+        await That(() => stream.FlushAsync()).Throws<ObjectDisposedException>();
+        await That(() => stream.Dispose()).DoesNotThrow()
+            .Because("disposing a stream whose handle is already closed succeeds, as it does for FileStream");
+    }
+
+    [Test]
+    public async Task OpenHandle_FromManyThreadsAtOnce_ShouldResolveEveryHandle()
+    {
+        for (var attempt = 0; attempt < 20; attempt++)
+        {
+            var fileSystem = new MockFileSystem();
+            var paths = new string[16];
+            for (var i = 0; i < paths.Length; i++)
+            {
+                paths[i] = XFS.Path($@"C:\temp\file{i}.bin");
+                fileSystem.AddFile(paths[i], new MockFileData(new byte[] { (byte)i }));
+            }
+
+            var handles = new SafeFileHandle[paths.Length];
+            Parallel.For(0, paths.Length, i => handles[i] = fileSystem.File.OpenHandle(paths[i]));
+
+            for (var i = 0; i < handles.Length; i++)
+            {
+                using var open = handles[i];
+                await That(fileSystem.RandomAccess.GetLength(open)).IsEqualTo(1)
+                    .Because("every handle is registered with the one registry of its file system");
+            }
+        }
+    }
 }
 #endif