Refactor tests to use centralized test data and clarify Windows trailing space behavior

Co-authored-by: stephentoub <[email protected]>

Author: Copilot

src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/Copy.cs

@@ -498,10 +498,12 @@ public void UnixCopyWithEmbeddedControlCharacters(string sourceFileName, string
         [PlatformSpecific(TestPlatforms.Windows)]
         public void WindowsCopyWithTrailingSpacePeriod_ViaExtendedSyntax(string sourceFileName, string destFileName)
         {
-            // Files with trailing spaces/periods require \\?\ syntax on Windows for creation.
-            // However, enumeration APIs like Directory.GetFiles can find them and return their names,
-            // but regular APIs like File.OpenRead will fail without \\?\ prefix.
-            // See: https://learn.microsoft.com/windows/win32/fileio/naming-a-file#naming-conventions
+            // On Windows, files with trailing spaces/periods must use \\?\ prefix for creation
+            // because path normalization strips these characters. While enumeration APIs like
+            // Directory.GetFiles can discover these files, direct string-based APIs (File.OpenRead,
+            // File.Exists) will fail because the trailing characters get stripped during normalization.
+            // Only FileInfo/DirectoryInfo objects from enumeration use EnsureExtendedPrefixIfNeeded
+            // internally and can access these files. See TrimmedPaths.cs for comprehensive tests.
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
             string sourcePath = Path.Combine(testDir.FullName, sourceFileName);
             string destPath = Path.Combine(testDir.FullName, destFileName);

src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/Create.cs

@@ -341,11 +341,8 @@ public void WindowsAlternateDataStream_OnExisting(string streamName)
             }
         }
 
-        [Theory]
-        [InlineData(" leading")]
-        [InlineData("  leading")]
-        [InlineData("   leading")]
-        public void LeadingSpace(string fileName)
+        [Theory, MemberData(nameof(TestData.ValidFileNames), MemberType = typeof(TestData))]
+        public void CreateWithProblematicNames(string fileName)
         {
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
             string filePath = Path.Combine(testDir.FullName, fileName);
@@ -355,42 +352,9 @@ public void LeadingSpace(string fileName)
             }
         }
 
-        [Theory]
-        [InlineData(".leading")]
-        [InlineData("..leading")]
-        [InlineData("...leading")]
-        public void LeadingDot(string fileName)
-        {
-            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
-            string filePath = Path.Combine(testDir.FullName, fileName);
-            using (Create(filePath))
-            {
-                Assert.True(File.Exists(filePath));
-            }
-        }
-
-        [Theory]
-        [InlineData("-")]
-        [InlineData("--")]
-        [InlineData("-filename")]
-        [InlineData("--filename")]
-        public void DashPrefixedNames(string fileName)
-        {
-            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
-            string filePath = Path.Combine(testDir.FullName, fileName);
-            using (Create(filePath))
-            {
-                Assert.True(File.Exists(filePath));
-            }
-        }
-
-        [Theory]
-        [InlineData("file\tname")]
-        [InlineData("file\rname")]
-        [InlineData("file\vname")]
-        [InlineData("file\fname")]
+        [Theory, MemberData(nameof(TestData.UnixOnlyFileNames), MemberType = typeof(TestData))]
         [PlatformSpecific(TestPlatforms.AnyUnix)]
-        public void UnixEmbeddedControlCharacters(string fileName)
+        public void UnixCreateWithControlCharacters(string fileName)
         {
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
             string filePath = Path.Combine(testDir.FullName, fileName);
@@ -401,16 +365,13 @@ public void UnixEmbeddedControlCharacters(string fileName)
         }
 
         [ConditionalTheory(nameof(UsingNewNormalization))]
-        [InlineData("trailing ")]
-        [InlineData("trailing  ")]
-        [InlineData("trailing.")]
-        [InlineData("trailing..")]
-        [InlineData("trailing .")]
-        [InlineData("trailing. ")]
+        [MemberData(nameof(TestData.WindowsTrailingProblematicFileNames), MemberType = typeof(TestData))]
         [PlatformSpecific(TestPlatforms.Windows)]
-        public void WindowsTrailingSpacePeriod_CreateViaExtendedSyntax(string fileName)
+        public void WindowsCreateWithTrailingSpacePeriod(string fileName)
         {
-            // Files with trailing spaces/periods require \\?\ syntax on Windows
+            // On Windows, files with trailing spaces/periods must be created using \\?\ prefix.
+            // This is by design - Windows path normalization strips these characters unless
+            // the extended path syntax is used. See TrimmedPaths.cs for more detailed tests.
             DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
             string filePath = Path.Combine(testDir.FullName, fileName);
             string extendedPath = @"\\?\" + filePath;
@@ -420,40 +381,11 @@ public void WindowsTrailingSpacePeriod_CreateViaExtendedSyntax(string fileName)
                 Assert.True(File.Exists(extendedPath));
             }
 
-            // Verify we can find it via enumeration
+            // Verify the file can be found via enumeration
             string[] files = Directory.GetFiles(testDir.FullName);
             Assert.Contains(files, f => Path.GetFileName(f) == fileName);
         }
 
-        [Theory]
-        [InlineData("name with spaces")]
-        [InlineData("name  with  multiple  spaces")]
-        [InlineData("name.with.periods")]
-        [InlineData("name with spaces.txt")]
-        public void EmbeddedSpacesPeriods(string fileName)
-        {
-            // Embedded spaces and periods should work fine on all platforms
-            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
-            string filePath = Path.Combine(testDir.FullName, fileName);
-            using (Create(filePath))
-            {
-                Assert.True(File.Exists(filePath));
-            }
-        }
-
-        [Theory]
-        [InlineData("name\twith\ttabs")]
-        [PlatformSpecific(TestPlatforms.AnyUnix)]
-        public void UnixEmbeddedTabs(string fileName)
-        {
-            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
-            string filePath = Path.Combine(testDir.FullName, fileName);
-            using (Create(filePath))
-            {
-                Assert.True(File.Exists(filePath));
-            }
-        }
-
         #endregion
     }
 

src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/TestData.cs

@@ -91,4 +91,76 @@ public static TheoryData<char> TrailingCharacters
             return data;
         }
     }
+
+    /// <summary>
+    /// Filenames with problematic but valid characters that work on all platforms.
+    /// These test scenarios from: https://www.dwheeler.com/essays/fixing-unix-linux-filenames.html
+    /// </summary>
+    public static TheoryData<string> ValidFileNames
+    {
+        get
+        {
+            TheoryData<string> data = new TheoryData<string>
+            {
+                // Leading spaces
+                " leading",
+                "  leading",
+                "   leading",
+                // Leading dots
+                ".leading",
+                "..leading",
+                "...leading",
+                // Dash-prefixed names
+                "-",
+                "--",
+                "-filename",
+                "--filename",
+                // Embedded spaces and periods
+                "name with spaces",
+                "name  with  multiple  spaces",
+                "name.with.periods",
+                "name with spaces.txt"
+            };
+
+            return data;
+        }
+    }
+
+    /// <summary>
+    /// Filenames with control characters that are only valid on Unix.
+    /// Windows reserves control characters 0-31 as invalid.
+    /// </summary>
+    public static TheoryData<string> UnixOnlyFileNames
+    {
+        get
+        {
+            return new TheoryData<string>
+            {
+                "file\tname",      // tab
+                "file\rname",      // carriage return
+                "file\vname",      // vertical tab
+                "file\fname"       // form feed
+            };
+        }
+    }
+
+    /// <summary>
+    /// Filenames with trailing spaces or periods. On Windows, these require \\?\ prefix for creation
+    /// but can be enumerated. Direct string-based APIs will have the trailing characters stripped.
+    /// </summary>
+    public static TheoryData<string> WindowsTrailingProblematicFileNames
+    {
+        get
+        {
+            return new TheoryData<string>
+            {
+                "trailing ",
+                "trailing  ",
+                "trailing.",
+                "trailing..",
+                "trailing .",
+                "trailing. "
+            };
+        }
+    }
 }