Fix correctness and perf issues in compare, recording, naming and checks

- StreamComparer: compare both streams' read counts and return NotEqual on a
  length difference, closing a silent false-pass for non-seekable/empty
  received streams
- Callbacks: await every registered OnFirstVerify/OnDelete/OnVerifyMismatch
  handler via GetInvocationList instead of only the last (static and instance)
- Recording.TryStop: snapshot the items then Clear and Pause the shared State,
  so a stop consumed inside the engine's async flow is observable to the test
  (no re-appending on a second verify, IsRecording reflects it)
- Recording: Disposable/NamedDisposable use TryPause so disposing after an
  explicit Stop is a no-op instead of throwing
- Recording.IgnoreNames: copy-on-write HashSet read via Volatile.Read, so
  IsIgnored on Recording.Add cannot race a concurrent mutation
- MatchingFileFinder: account for a trailing separator on the directory so
  UseDirectory("snapshots/") still finds verified files and cleans received
- InnerVerifyChecks: look for .gitignore (was .gitIgnore), so the check runs on
  case-sensitive file systems; message updated to match
- Naming: pass pathFriendly through to collection items so pathFriendly:false
  callers keep path chars raw in snapshot content
- DanglingSnapshotsCheck: materialize tracked files into HashSets once instead
  of LINQ Contains over a ConcurrentBag per file (O(files*tracked) -> O(files))
- Add tests for the above; update the two VerifyChecksTests snapshots for the
  .gitignore casing

Author: SimonCropp

src/Verify.Tests/CallbackTests.cs

@@ -0,0 +1,29 @@
+public class CallbackTests
+{
+    [Fact]
+    public async Task OnFirstVerifyAwaitsAllHandlers()
+    {
+        var settings = new VerifySettings();
+        var ran = new List<int>();
+        // The slower handler is registered first: if only the last handler is
+        // awaited (the bug), it will not have completed by the assert.
+        settings.OnFirstVerify(
+            async (_, _, _) =>
+            {
+                await Task.Delay(200);
+                ran.Add(1);
+            });
+        settings.OnFirstVerify(
+            async (_, _, _) =>
+            {
+                await Task.Delay(1);
+                ran.Add(2);
+            });
+
+        var filePair = new FilePair("txt", "received.txt", "verified.txt");
+        var result = new NewResult(filePair, null);
+        await settings.RunOnFirstVerify(result, false);
+
+        Assert.Equal(2, ran.Count);
+    }
+}

src/Verify.Tests/InnerVerifyChecksTests/VerifyChecksTests.GitIgnore.verified.txt

@@ -1,8 +1,8 @@
 {
   Type: VerifyCheckException,
   Message:
-Expected .gitIgnore to contain settings for Verify.
-Path: file:///{ProjectDirectory}InnerVerifyChecksTests/Invalid/.gitIgnore
+Expected .gitignore to contain settings for Verify.
+Path: file:///{ProjectDirectory}InnerVerifyChecksTests/Invalid/.gitignore
 Recommended settings:
 
 # Verify

src/Verify.Tests/InnerVerifyChecksTests/VerifyChecksTests.Invalid.verified.txt

@@ -1,8 +1,8 @@
 {
   Type: VerifyCheckException,
   Message:
-Expected .gitIgnore to contain settings for Verify.
-Path: file:///{ProjectDirectory}InnerVerifyChecksTests/Invalid/.gitIgnore
+Expected .gitignore to contain settings for Verify.
+Path: file:///{ProjectDirectory}InnerVerifyChecksTests/Invalid/.gitignore
 Recommended settings:
 
 # Verify

src/Verify.Tests/Naming/MatchingFileFinderTests.cs

@@ -0,0 +1,51 @@
+public class MatchingFileFinderTests
+{
+    [Fact]
+    public void FindVerifiedWithTrailingSeparator()
+    {
+        var directory = CreateTempDirectory();
+        try
+        {
+            File.WriteAllText(Path.Combine(directory, "SomeTest.verified.txt"), "a");
+            File.WriteAllText(Path.Combine(directory, "Other.verified.txt"), "b");
+
+            var withSeparator = directory + Path.DirectorySeparatorChar;
+            var found = MatchingFileFinder.FindVerified("SomeTest", withSeparator)
+                .ToList();
+
+            Assert.Single(found);
+            Assert.EndsWith("SomeTest.verified.txt", found[0]);
+        }
+        finally
+        {
+            Directory.Delete(directory, true);
+        }
+    }
+
+    [Fact]
+    public void FindVerifiedWithoutTrailingSeparator()
+    {
+        var directory = CreateTempDirectory();
+        try
+        {
+            File.WriteAllText(Path.Combine(directory, "SomeTest.verified.txt"), "a");
+            File.WriteAllText(Path.Combine(directory, "Other.verified.txt"), "b");
+
+            var found = MatchingFileFinder.FindVerified("SomeTest", directory)
+                .ToList();
+
+            Assert.Single(found);
+        }
+        finally
+        {
+            Directory.Delete(directory, true);
+        }
+    }
+
+    static string CreateTempDirectory()
+    {
+        var directory = Path.Combine(Path.GetTempPath(), $"MatchingFileFinder{Guid.NewGuid():N}");
+        Directory.CreateDirectory(directory);
+        return directory;
+    }
+}

src/Verify.Tests/Naming/NameForParameterTests.cs

@@ -12,6 +12,21 @@ public Task StringEmpty() =>
     public Task StringInvalidPathChar() =>
         Verify(VerifierSettings.GetNameForParameter("a/a", counter: CounterBuilder.Empty()));
 
+    [Fact]
+    public void CollectionItemPathFriendlyFalseNotCleaned()
+    {
+        // pathFriendly must flow to collection items, so path chars are kept
+        // raw when the caller does not want file-name cleaning applied.
+        var name = VerifierSettings.GetNameForParameter(
+            new List<string>
+            {
+                "a/b"
+            },
+            counter: CounterBuilder.Empty(),
+            pathFriendly: false);
+        Assert.Contains("a/b", name);
+    }
+
     [Fact]
     public Task Int() =>
         Verify(VerifierSettings.GetNameForParameter(10, counter: CounterBuilder.Empty()));

src/Verify.Tests/RecordingTests.cs

@@ -10,6 +10,37 @@ public Task IgnoreNames()
         return Verify();
     }
 
+    [Fact]
+    public async Task StoppedInChildContextIsNotRecording()
+    {
+        Recording.Start();
+        Recording.Add("name", "value");
+        // Consuming inside a child execution context (as the verify engine does)
+        // must not leave the recording active in this context.
+        await Task.Run(() => Recording.TryStop(out _));
+        Assert.False(Recording.IsRecording());
+    }
+
+    [Fact]
+    public void DisposeAfterStopDoesNotThrow()
+    {
+        using (Recording.Start())
+        {
+            Recording.Add("name", "value");
+            Recording.Stop();
+        }
+    }
+
+    [Fact]
+    public void DisposeNamedAfterStopDoesNotThrow()
+    {
+        using (Recording.Start("DisposeNamedAfterStop"))
+        {
+            Recording.Add("DisposeNamedAfterStop", "name", "value");
+            Recording.Stop("DisposeNamedAfterStop");
+        }
+    }
+
     [Fact]
     public Task Dates()
     {

src/Verify.Tests/StreamComparerTests.cs

@@ -35,6 +35,34 @@ public async Task BinaryNotEquals()
         Assert.False(result.IsEqual);
     }
 
+    [Fact]
+    public async Task PrefixIsNotEqual()
+    {
+        // received is an 8-byte-aligned prefix of verified; must not be Equal.
+        using var received = new MemoryStream(new byte[16]);
+        using var verified = new MemoryStream(new byte[32]);
+        var result = await StreamComparer.AreEqual(received, verified);
+        Assert.False(result.IsEqual);
+    }
+
+    [Fact]
+    public async Task EmptyReceivedIsNotEqual()
+    {
+        using var received = new MemoryStream();
+        using var verified = new MemoryStream(new byte[16]);
+        var result = await StreamComparer.AreEqual(received, verified);
+        Assert.False(result.IsEqual);
+    }
+
+    [Fact]
+    public async Task LongerReceivedIsNotEqual()
+    {
+        using var received = new MemoryStream(new byte[32]);
+        using var verified = new MemoryStream(new byte[16]);
+        var result = await StreamComparer.AreEqual(received, verified);
+        Assert.False(result.IsEqual);
+    }
+
     [Fact]
     public async Task ShouldNotLock()
     {

src/Verify/Callbacks/VerifierSettings.cs

@@ -35,14 +35,20 @@ public static void OnFirstVerify(FirstVerify firstVerify)
         handleOnFirstVerify += firstVerify;
     }
 
-    internal static Task RunOnFirstVerify(NewResult item, bool autoVerify)
+    internal static async Task RunOnFirstVerify(NewResult item, bool autoVerify)
     {
         if (handleOnFirstVerify is null)
         {
-            return Task.CompletedTask;
+            return;
         }
 
-        return handleOnFirstVerify(item.File, item.ReceivedText?.ToString(), autoVerify);
+        var receivedText = item.ReceivedText?.ToString();
+        // Await every registered handler; invoking the multicast delegate
+        // directly would only await the last handler's Task.
+        foreach (var handler in handleOnFirstVerify.GetInvocationList())
+        {
+            await ((FirstVerify) handler)(item.File, receivedText, autoVerify);
+        }
     }
 
     static VerifyDelete? handleOnVerifyDelete;
@@ -55,24 +61,30 @@ public static void OnDelete(VerifyDelete verifyDelete)
 
     static VerifyMismatch? handleOnVerifyMismatch;
 
-    internal static Task RunOnVerifyDelete(string file, bool autoVerify)
+    internal static async Task RunOnVerifyDelete(string file, bool autoVerify)
     {
         if (handleOnVerifyDelete is null)
         {
-            return Task.CompletedTask;
+            return;
         }
 
-        return handleOnVerifyDelete(file, autoVerify);
+        foreach (var handler in handleOnVerifyDelete.GetInvocationList())
+        {
+            await ((VerifyDelete) handler)(file, autoVerify);
+        }
     }
 
-    internal static Task RunOnVerifyMismatch(FilePair item, string? message, bool autoVerify)
+    internal static async Task RunOnVerifyMismatch(FilePair item, string? message, bool autoVerify)
     {
         if (handleOnVerifyMismatch is null)
         {
-            return Task.CompletedTask;
+            return;
         }
 
-        return handleOnVerifyMismatch(item, message, autoVerify);
+        foreach (var handler in handleOnVerifyMismatch.GetInvocationList())
+        {
+            await ((VerifyMismatch) handler)(item, message, autoVerify);
+        }
     }
 
     public static void OnVerifyMismatch(VerifyMismatch verifyMismatch)

src/Verify/Callbacks/VerifySettings.cs

@@ -10,7 +10,11 @@ internal async Task RunOnFirstVerify(NewResult item, bool autoVerify)
     {
         if (handleOnFirstVerify is not null)
         {
-            await handleOnFirstVerify(item.File, item.ReceivedText?.ToString(), autoVerify);
+            var receivedText = item.ReceivedText?.ToString();
+            foreach (var handler in handleOnFirstVerify.GetInvocationList())
+            {
+                await ((FirstVerify) handler)(item.File, receivedText, autoVerify);
+            }
         }
 
         await VerifierSettings.RunOnFirstVerify(item, autoVerify);
@@ -26,7 +30,10 @@ internal async Task RunOnVerifyDelete(string file, bool autoVerify)
     {
         if (handleOnVerifyDelete is not null)
         {
-            await handleOnVerifyDelete(file, autoVerify);
+            foreach (var handler in handleOnVerifyDelete.GetInvocationList())
+            {
+                await ((VerifyDelete) handler)(file, autoVerify);
+            }
         }
 
         await VerifierSettings.RunOnVerifyDelete(file, autoVerify);
@@ -38,7 +45,10 @@ internal async Task RunOnVerifyMismatch(FilePair item, string? message, bool aut
     {
         if (handleOnVerifyMismatch is not null)
         {
-            await handleOnVerifyMismatch(item, message, autoVerify);
+            foreach (var handler in handleOnVerifyMismatch.GetInvocationList())
+            {
+                await ((VerifyMismatch) handler)(item, message, autoVerify);
+            }
         }
 
         await VerifierSettings.RunOnVerifyMismatch(item, message, autoVerify);

src/Verify/Compare/StreamComparer.cs

@@ -14,18 +14,23 @@ public static async Task<CompareResult> AreEqual(Stream stream1, Stream stream2)
 
         while (true)
         {
-            var count = await ReadBufferAsync(stream1, buffer1);
+            var count1 = await ReadBufferAsync(stream1, buffer1);
+            var count2 = await ReadBufferAsync(stream2, buffer2);
 
-            //no need to compare size here since only enter on files being same size
+            // Callers do not always guarantee the streams are the same length
+            // (e.g. a non-seekable received stream), so a length difference must
+            // be treated as not-equal instead of a short-circuit to equal.
+            if (count1 != count2)
+            {
+                return CompareResult.NotEqual();
+            }
 
-            if (count == 0)
+            if (count1 == 0)
             {
                 return CompareResult.Equal;
             }
 
-            await ReadBufferAsync(stream2, buffer2);
-
-            for (var i = 0; i < count; i += sizeof(long))
+            for (var i = 0; i < count1; i += sizeof(long))
             {
                 if (BitConverter.ToInt64(buffer1, i) != BitConverter.ToInt64(buffer2, i))
                 {