Run the NewLineTests line ending tests on all target frameworks

StringWithDifferingNewline and TrailingNewlinesRaw were each pinned to a single
target framework via #if. They write fixed, unsuffixed verified files into the
source directory and mutate them repeatedly, so every target framework's test
run would otherwise contend over the same paths.

Give each run its own paths via UniqueForRuntimeAndVersion, so all target
frameworks can run both tests concurrently. Received paths are now deterministic,
so the glob based cleanup collapses to direct deletes.

Also disable the diff tool, since these verifies are expected to fail and were
launching it, and move cleanup into a finally. The temp verified files
deliberately contain \r, so a leftover one that got committed would be normalized
to \n by .gitattributes and silently void the test.

Author: SimonCropp

.gitignore

@@ -16,9 +16,8 @@ src/Verify.Tests/Tests.TextNegative.verified.tmp
 *.ncrunchproject
 *nCrunchTemp*
 *.cache
-src/Verify.Tests/NewLineTests.StringWithDifferingNewline.verified.txt
-src/Verify.Tests/NewLineTests.StringWithDifferingNewline.verified.json
-src/Verify.Tests/NewLineTests.TrailingNewlinesRaw.verified.txt
+src/Verify.Tests/NewLineTests.StringWithDifferingNewline.*
+src/Verify.Tests/NewLineTests.TrailingNewlinesRaw.*
 src/Verify.MSTest.Tests/Tests.AutoVerifyHasAttachment.verified.txt
 src/Verify.NUnit.Tests/Tests.AutoVerifyHasAttachment.verified.txt
 src/Verify.TUnit.Tests/Tests.AutoVerifyHasAttachment.verified.txt

src/Verify.Tests/NewLineTests.cs

@@ -38,66 +38,60 @@ public async Task WithNestedNewlineAddedByScrubber()
     public Task Newlines() =>
         Verify("a\r\nb\nc\rd\r\n");
 
-#if NET9_0
     [Fact]
     public async Task StringWithDifferingNewline()
     {
-        var fullPath = CurrentFile.Relative("NewLineTests.StringWithDifferingNewline.verified.txt");
+        // This writes verified files into the source directory and mutates them repeatedly,
+        // so every target framework has to own a distinct set of paths. UniqueForRuntimeAndVersion
+        // puts the runtime in the name, which is what allows this to run on all of them at once.
+        var prefix = $"NewLineTests.StringWithDifferingNewline.{Namer.RuntimeAndVersion}";
+        var verifiedPath = CurrentFile.Relative($"{prefix}.verified.txt");
+        var receivedPath = CurrentFile.Relative($"{prefix}.received.txt");
         // The suggested .gitattributes line uses the extension of the failing file,
         // which is not always txt
-        var jsonPath = CurrentFile.Relative("NewLineTests.StringWithDifferingNewline.verified.json");
-        var directory = Path.GetDirectoryName(fullPath)!;
-        // Globbed because received carries the namer uniqueness suffix, while the verified
-        // files above are the unsuffixed fallback.
-        const string receivedPattern = "NewLineTests.StringWithDifferingNewline*.received.txt";
-        const string receivedJsonPattern = "NewLineTests.StringWithDifferingNewline*.received.json";
-        File.Delete(fullPath);
-        File.Delete(jsonPath);
+        var verifiedJsonPath = CurrentFile.Relative($"{prefix}.verified.json");
+        var receivedJsonPath = CurrentFile.Relative($"{prefix}.received.json");
+        File.Delete(verifiedPath);
+        File.Delete(verifiedJsonPath);
         var settings = new VerifySettings();
+        settings.UniqueForRuntimeAndVersion();
         settings.DisableRequireUniquePrefix();
         // Every verify below is expected to fail, so without this the diff tool is launched
         settings.DisableDiff();
 
         try
         {
             // A verified file containing \r is rejected rather than silently normalized
-            await File.WriteAllTextAsync(fullPath, "a\r\nb");
+            await File.WriteAllTextAsync(verifiedPath, "a\r\nb");
             var crlf = await Assert.ThrowsAnyAsync<Exception>(() => Verify("a\nb", settings));
             Assert.Contains("carriage return", crlf.ToString());
 
-            await File.WriteAllTextAsync(fullPath, "a\rb");
+            await File.WriteAllTextAsync(verifiedPath, "a\rb");
             var cr = await Assert.ThrowsAnyAsync<Exception>(() => Verify("a\nb", settings));
             Assert.Contains("carriage return", cr.ToString());
 
             // The rejection writes received, so the run is not silent, and is not wrapped in a
             // generic "Failed to compare files" that hides the cause.
-            foreach (var stale in Directory.EnumerateFiles(directory, receivedPattern))
-            {
-                File.Delete(stale);
-            }
+            File.Delete(receivedPath);
 
-            await File.WriteAllTextAsync(fullPath, "a\r\nb");
+            await File.WriteAllTextAsync(verifiedPath, "a\r\nb");
             var rejection = await Assert.ThrowsAnyAsync<Exception>(() => Verify("a\nb", settings));
             Assert.DoesNotContain("Failed to compare files", rejection.Message);
             Assert.Contains("*.verified.txt text eol=lf", rejection.Message);
-            var received = Directory.EnumerateFiles(directory, receivedPattern).Single();
-            Assert.Equal("a\nb", await File.ReadAllTextAsync(received));
-            File.Delete(received);
+            Assert.Equal("a\nb", await File.ReadAllTextAsync(receivedPath));
+            File.Delete(receivedPath);
 
-            await File.WriteAllTextAsync(jsonPath, "{\r\n}");
+            await File.WriteAllTextAsync(verifiedJsonPath, "{\r\n}");
             var json = await Assert.ThrowsAnyAsync<Exception>(
                 () => Verify("{\n}", extension: "json", settings: settings));
             Assert.Contains("*.verified.json text eol=lf", json.Message);
             // Inline, not only in the finally, since the verifies below would otherwise treat
             // the json as a dangling verified file for this test and fail on it
-            File.Delete(jsonPath);
-            foreach (var stale in Directory.EnumerateFiles(directory, receivedJsonPattern))
-            {
-                File.Delete(stale);
-            }
+            File.Delete(verifiedJsonPath);
+            File.Delete(receivedJsonPath);
 
             // A verified file using \n still matches received content normalized to \n
-            await File.WriteAllTextAsync(fullPath, "a\nb");
+            await File.WriteAllTextAsync(verifiedPath, "a\nb");
             await Verify("a\r\nb", settings);
             await Verify("a\rb", settings);
             await Verify("a\nb", settings);
@@ -106,13 +100,10 @@ public async Task StringWithDifferingNewline()
         {
             // In a finally since these deliberately contain \r. A leftover verified file is
             // normalized to \n by .gitattributes if committed, silently voiding this test.
-            File.Delete(fullPath);
-            File.Delete(jsonPath);
-            foreach (var stale in Directory.EnumerateFiles(directory, receivedPattern)
-                         .Concat(Directory.EnumerateFiles(directory, receivedJsonPattern)))
-            {
-                File.Delete(stale);
-            }
+            File.Delete(verifiedPath);
+            File.Delete(receivedPath);
+            File.Delete(verifiedJsonPath);
+            File.Delete(receivedJsonPath);
         }
     }
 
@@ -140,19 +131,16 @@ public async Task StringWithDifferingNewline()
     //     await Verify(target, settings);
     // }
 
-#endif
-
-#if NET10_0
     [Fact]
     public async Task TrailingNewlinesRaw()
     {
-        var file = CurrentFile.Relative("NewLineTests.TrailingNewlinesRaw.verified.txt");
-        var directory = Path.GetDirectoryName(file)!;
-        // Globbed because received carries the namer uniqueness suffix, while the verified
-        // file above is the unsuffixed fallback.
-        const string receivedPattern = "NewLineTests.TrailingNewlinesRaw*.received.txt";
+        // Per target framework paths, for the same reason as StringWithDifferingNewline above
+        var prefix = $"NewLineTests.TrailingNewlinesRaw.{Namer.RuntimeAndVersion}";
+        var file = CurrentFile.Relative($"{prefix}.verified.txt");
+        var receivedPath = CurrentFile.Relative($"{prefix}.received.txt");
         File.Delete(file);
         var settings = new VerifySettings();
+        settings.UniqueForRuntimeAndVersion();
         settings.DisableRequireUniquePrefix();
         // Several verifies below are expected to fail, so without this the diff tool is launched
         settings.DisableDiff();
@@ -178,11 +166,7 @@ public async Task TrailingNewlinesRaw()
             // Deleting verified orphans received, so no subsequent run reconciles it, and
             // DiffEngineTray shows it as a pending change forever.
             File.Delete(file);
-            foreach (var stale in Directory.EnumerateFiles(directory, receivedPattern))
-            {
-                File.Delete(stale);
-            }
+            File.Delete(receivedPath);
         }
     }
-#endif
 }