API tweaks to match latest updates to spec (#27102)

* API tweaks to match latest updates to spec

Add a few new tests

See #25873

* Properly clear state when enumerating on Unix.
Make sure we don't include special directories in subdir processing. Add test.
Collapse helper that was only called in one place, and remove dead one.

15 files changed, 186 insertions, 72 deletions

diff --git a/src/System.IO.FileSystem/ref/System.IO.FileSystem.cs b/src/System.IO.FileSystem/ref/System.IO.FileSystem.cs
index 9cd3d088a5..3546723d0a 100644
--- a/src/System.IO.FileSystem/ref/System.IO.FileSystem.cs
+++ b/src/System.IO.FileSystem/ref/System.IO.FileSystem.cs
@@ -20,15 +20,15 @@ namespace System.IO
         public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories(string path) { throw null; }
         public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories(string path, string searchPattern) { throw null; }
         public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories(string path, string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories(string path, string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public static System.Collections.Generic.IEnumerable<string> EnumerateDirectories(string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public static System.Collections.Generic.IEnumerable<string> EnumerateFiles(string path) { throw null; }
         public static System.Collections.Generic.IEnumerable<string> EnumerateFiles(string path, string searchPattern) { throw null; }
         public static System.Collections.Generic.IEnumerable<string> EnumerateFiles(string path, string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public static System.Collections.Generic.IEnumerable<string> EnumerateFiles(string path, string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public static System.Collections.Generic.IEnumerable<string> EnumerateFiles(string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public static System.Collections.Generic.IEnumerable<string> EnumerateFileSystemEntries(string path) { throw null; }
         public static System.Collections.Generic.IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern) { throw null; }
         public static System.Collections.Generic.IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public static System.Collections.Generic.IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public static System.Collections.Generic.IEnumerable<string> EnumerateFileSystemEntries(string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public static bool Exists(string path) { throw null; }
         public static System.DateTime GetCreationTime(string path) { throw null; }
         public static System.DateTime GetCreationTimeUtc(string path) { throw null; }
@@ -36,16 +36,16 @@ namespace System.IO
         public static string[] GetDirectories(string path) { throw null; }
         public static string[] GetDirectories(string path, string searchPattern) { throw null; }
         public static string[] GetDirectories(string path, string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public static string[] GetDirectories(string path, string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public static string[] GetDirectories(string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public static string GetDirectoryRoot(string path) { throw null; }
         public static string[] GetFiles(string path) { throw null; }
         public static string[] GetFiles(string path, string searchPattern) { throw null; }
         public static string[] GetFiles(string path, string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public static string[] GetFiles(string path, string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public static string[] GetFiles(string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public static string[] GetFileSystemEntries(string path) { throw null; }
         public static string[] GetFileSystemEntries(string path, string searchPattern) { throw null; }
         public static string[] GetFileSystemEntries(string path, string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public static string[] GetFileSystemEntries(string path, string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public static string[] GetFileSystemEntries(string path, string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public static System.DateTime GetLastAccessTime(string path) { throw null; }
         public static System.DateTime GetLastAccessTimeUtc(string path) { throw null; }
         public static System.DateTime GetLastWriteTime(string path) { throw null; }
@@ -73,13 +73,13 @@ namespace System.IO
         public override void Delete() { }
         public void Delete(bool recursive) { }
         public System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo> EnumerateDirectories() { throw null; }
-        public System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo> EnumerateDirectories(string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
-        public System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo> EnumerateFileSystemInfos(string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo> EnumerateDirectories(string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
+        public System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo> EnumerateFileSystemInfos(string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public System.Collections.Generic.IEnumerable<System.IO.DirectoryInfo> EnumerateDirectories(string searchPattern) { throw null; }
         public System.Collections.Generic.IEnumerable<System.IO.FileInfo> EnumerateFiles() { throw null; }
         public System.Collections.Generic.IEnumerable<System.IO.FileInfo> EnumerateFiles(string searchPattern) { throw null; }
         public System.Collections.Generic.IEnumerable<System.IO.FileInfo> EnumerateFiles(string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public System.Collections.Generic.IEnumerable<System.IO.FileInfo> EnumerateFiles(string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public System.Collections.Generic.IEnumerable<System.IO.FileInfo> EnumerateFiles(string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo> EnumerateFileSystemInfos() { throw null; }
         public System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo> EnumerateFileSystemInfos(string searchPattern) { throw null; }
         public System.Collections.Generic.IEnumerable<System.IO.FileSystemInfo> EnumerateFileSystemInfos(string searchPattern, System.IO.SearchOption searchOption) { throw null; }
@@ -87,15 +87,15 @@ namespace System.IO
         public System.IO.DirectoryInfo[] GetDirectories() { throw null; }
         public System.IO.DirectoryInfo[] GetDirectories(string searchPattern) { throw null; }
         public System.IO.DirectoryInfo[] GetDirectories(string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public System.IO.DirectoryInfo[] GetDirectories(string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public System.IO.DirectoryInfo[] GetDirectories(string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public System.IO.FileInfo[] GetFiles() { throw null; }
         public System.IO.FileInfo[] GetFiles(string searchPattern) { throw null; }
         public System.IO.FileInfo[] GetFiles(string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public System.IO.FileInfo[] GetFiles(string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public System.IO.FileInfo[] GetFiles(string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public System.IO.FileSystemInfo[] GetFileSystemInfos() { throw null; }
         public System.IO.FileSystemInfo[] GetFileSystemInfos(string searchPattern) { throw null; }
         public System.IO.FileSystemInfo[] GetFileSystemInfos(string searchPattern, System.IO.SearchOption searchOption) { throw null; }
-        public System.IO.FileSystemInfo[] GetFileSystemInfos(string searchPattern, System.IO.Enumeration.EnumerationOptions enumerationOptions) { throw null; }
+        public System.IO.FileSystemInfo[] GetFileSystemInfos(string searchPattern, System.IO.EnumerationOptions enumerationOptions) { throw null; }
         public void MoveTo(string destDirName) { }
         public override string ToString() { throw null; }
     }
@@ -223,9 +223,6 @@ namespace System.IO
         AllDirectories = 1,
         TopDirectoryOnly = 0,
     }
-}
-namespace System.IO.Enumeration
-{
     public enum MatchType
     {
         Simple,
@@ -240,7 +237,6 @@ namespace System.IO.Enumeration
     public class EnumerationOptions
     {
         public EnumerationOptions() { }
-
         public bool RecurseSubdirectories { get { throw null; } set { } }
         public bool IgnoreInaccessible { get { throw null; } set { } }
         public int BufferSize { get { throw null; } set { } }
@@ -249,6 +245,9 @@ namespace System.IO.Enumeration
         public MatchCasing MatchCasing { get { throw null; } set { } }
         public bool ReturnSpecialDirectories { get { throw null; } set { } }
     }
+}
+namespace System.IO.Enumeration
+{
     public ref struct FileSystemEntry
     {
         public ReadOnlySpan<char> Directory { get { throw null; } }
diff --git a/src/System.IO.FileSystem/src/System.IO.FileSystem.csproj b/src/System.IO.FileSystem/src/System.IO.FileSystem.csproj
index abb0b37cd0..93d318a1bc 100644
--- a/src/System.IO.FileSystem/src/System.IO.FileSystem.csproj
+++ b/src/System.IO.FileSystem/src/System.IO.FileSystem.csproj
@@ -24,15 +24,15 @@
     <Compile Include="System\IO\Enumeration\FileSystemEnumerableFactory.cs" />
     <Compile Include="System\IO\Enumeration\FileSystemEnumerator.cs" />
     <Compile Include="System\IO\Enumeration\FileSystemName.cs" />
-    <Compile Include="System\IO\Enumeration\MatchCasing.cs" />
-    <Compile Include="System\IO\Enumeration\MatchType.cs" />
+    <Compile Include="System\IO\MatchCasing.cs" />
+    <Compile Include="System\IO\MatchType.cs" />
     <Compile Include="System\IO\Error.cs" />
     <Compile Include="System\IO\Directory.cs" />
     <Compile Include="System\IO\DirectoryInfo.cs" />
     <Compile Include="System\IO\File.cs" />
     <Compile Include="System\IO\FileInfo.cs" />
     <Compile Include="System\IO\FileSystemInfo.cs" />
-    <Compile Include="System\IO\Enumeration\EnumerationOptions.cs" />
+    <Compile Include="System\IO\EnumerationOptions.cs" />
     <Compile Include="System\IO\Iterator.cs" />
     <Compile Include="System\IO\PathHelpers.cs" />
     <Compile Include="System\IO\ReadLinesIterator.cs" />
@@ -422,4 +422,4 @@
     <Reference Include="System.Threading" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEntry.Unix.cs b/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEntry.Unix.cs
index 2e6a5c1a91..148364fa73 100644
--- a/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEntry.Unix.cs
+++ b/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEntry.Unix.cs
@@ -30,6 +30,8 @@ namespace System.IO.Enumeration
             entry.RootDirectory = rootDirectory;
             entry.OriginalRootDirectory = originalRootDirectory;
             entry._pathBuffer = pathBuffer;
+            entry._fullPath = ReadOnlySpan<char>.Empty;
+            entry._fileName = ReadOnlySpan<char>.Empty;
 
             // Get from the dir entry whether the entry is a file or directory.
             // We classify everything as a file unless we know it to be a directory.
@@ -48,6 +50,7 @@ namespace System.IO.Enumeration
                 isDirectory = (targetStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR;
             }
 
+            entry._status = default;
             FileStatus.Initialize(ref entry._status, isDirectory);
             return isDirectory;
         }
diff --git a/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerable.cs b/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerable.cs
index b05b1375d6..861a8fa616 100644
--- a/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerable.cs
+++ b/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerable.cs
@@ -8,6 +8,9 @@ using System.Threading;
 
 namespace System.IO.Enumeration
 {
+    /// <summary>
+    /// Enumerable that allows utilizing custom filter predicates and tranform delegates.
+    /// </summary>
     public class FileSystemEnumerable<TResult> : IEnumerable<TResult>
     {
         private DelegateEnumerator _enumerator;
diff --git a/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerator.Unix.cs b/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerator.Unix.cs
index 7e9bbd6e4c..ae1c5fbd9d 100644
--- a/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerator.Unix.cs
+++ b/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerator.Unix.cs
@@ -109,7 +109,20 @@ namespace System.IO.Enumeration
 
                     bool isDirectory = FileSystemEntry.Initialize(ref entry, _entry, _currentPath, _rootDirectory, _originalRootDirectory, new Span<char>(_pathBuffer));
 
-                    if (_options.AttributesToSkip != 0)
+                    bool isSpecialDirectory = false;
+                    if (isDirectory)
+                    {
+                        // Subdirectory found
+                        if (_entry.Name[0] == '.' && (_entry.Name[1] == 0 || (_entry.Name[1] == '.' && _entry.Name[2] == 0)))
+                        {
+                            // "." or "..", don't process unless the option is set
+                            if (!_options.ReturnSpecialDirectories)
+                                continue;
+                            isSpecialDirectory = true;
+                        }
+                    }
+
+                    if (!isSpecialDirectory && _options.AttributesToSkip != 0)
                     {
                         if ((_options.AttributesToSkip & ~(FileAttributes.Directory | FileAttributes.Hidden | FileAttributes.ReparsePoint)) == 0)
                         {
@@ -119,23 +132,16 @@ namespace System.IO.Enumeration
                                 || ((_options.AttributesToSkip & FileAttributes.ReparsePoint) != 0 && _entry.InodeType == Interop.Sys.NodeType.DT_LNK))
                                 continue;
                         }
-                        else if ((_options.AttributesToSkip & entry.Attributes) != 0)
+                        else if (entry.Attributes != (FileAttributes)(-1) && (_options.AttributesToSkip & entry.Attributes) != 0)
                         {
                             // Hitting Attributes on the FileSystemEntry will cause a stat call
                             continue;
                         }
                     }
 
-                    if (isDirectory)
+                    if (isDirectory && !isSpecialDirectory)
                     {
-                        // Subdirectory found
-                        if (_entry.Name[0] == '.' && (_entry.Name[1] == 0 || (_entry.Name[1] == '.' && _entry.Name[2] == 0)))
-                        {
-                            // "." or "..", don't process unless the option is set
-                            if (!_options.ReturnSpecialDirectories)
-                                continue;
-                        }
-                        else if (_options.RecurseSubdirectories && ShouldRecurseIntoEntry(ref entry))
+                        if (_options.RecurseSubdirectories && ShouldRecurseIntoEntry(ref entry))
                         {
                             // Recursion is on and the directory was accepted, Queue it
                             if (_pending == null)
diff --git a/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerator.Windows.cs b/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerator.Windows.cs
index 38947487f6..98b902a802 100644
--- a/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerator.Windows.cs
+++ b/src/System.IO.FileSystem/src/System/IO/Enumeration/FileSystemEnumerator.Windows.cs
@@ -147,7 +147,7 @@ namespace System.IO.Enumeration
                     if ((_entry->FileAttributes & FileAttributes.Directory) != 0)
                     {
                         // Subdirectory found
-                        if (PathHelpers.IsDotOrDotDot(_entry->FileName))
+                        if (!(_entry->FileName.Length > 2 || _entry->FileName[0] != '.' || (_entry->FileName.Length == 2 && _entry->FileName[1] != '.')))
                         {
                             // "." or "..", don't process unless the option is set
                             if (!_options.ReturnSpecialDirectories)
diff --git a/src/System.IO.FileSystem/src/System/IO/Enumeration/EnumerationOptions.cs b/src/System.IO.FileSystem/src/System/IO/EnumerationOptions.cs
index 18e5eec47f..3659ee7472 100644
--- a/src/System.IO.FileSystem/src/System/IO/Enumeration/EnumerationOptions.cs
+++ b/src/System.IO.FileSystem/src/System/IO/EnumerationOptions.cs
@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System.IO.Enumeration
+namespace System.IO
 {
     public class EnumerationOptions
     {
@@ -10,9 +10,11 @@ namespace System.IO.Enumeration
         /// For internal use. These are the options we want to use if calling the existing Directory/File APIs where you don't
         /// explicitly specify EnumerationOptions.
         /// </summary>
-        internal static EnumerationOptions Compatible { get; } = new EnumerationOptions { MatchType = MatchType.Dos };
+        internal static EnumerationOptions Compatible { get; } = new EnumerationOptions
+            { MatchType = MatchType.Dos, AttributesToSkip = 0, IgnoreInaccessible = false };
 
-        private static EnumerationOptions CompatibleRecursive { get; } = new EnumerationOptions { RecurseSubdirectories = true, MatchType = MatchType.Dos };
+        private static EnumerationOptions CompatibleRecursive { get; } = new EnumerationOptions
+            { RecurseSubdirectories = true, MatchType = MatchType.Dos, AttributesToSkip = 0, IgnoreInaccessible = false };
 
         /// <summary>
         /// Internal singleton for default options.
@@ -24,6 +26,8 @@ namespace System.IO.Enumeration
         /// </summary>
         public EnumerationOptions()
         {
+            IgnoreInaccessible = true;
+            AttributesToSkip = FileAttributes.Hidden | FileAttributes.System;
         }
 
         /// <summary>
@@ -39,16 +43,18 @@ namespace System.IO.Enumeration
 
         /// <summary>
         /// Should we recurse into subdirectories while enumerating?
+        /// Default is false.
         /// </summary>
         public bool RecurseSubdirectories { get; set; }
 
         /// <summary>
-        /// Skip files/directories when access is denied (e.g. AccessDeniedException/SecurityException)
+        /// Skip files/directories when access is denied (e.g. AccessDeniedException/SecurityException).
+        /// Default is true.
         /// </summary>
         public bool IgnoreInaccessible { get; set; }
 
         /// <summary>
-        /// Suggested buffer size, in bytes.
+        /// Suggested buffer size, in bytes. Default is 0 (no suggestion).
         /// </summary>
         /// <remarks>
         /// Not all platforms use user allocated buffers, and some require either fixed buffers or a
@@ -63,7 +69,7 @@ namespace System.IO.Enumeration
         public int BufferSize { get; set; }
 
         /// <summary>
-        /// Skip entries with the given attributes.
+        /// Skip entries with the given attributes. Default is FileAttributes.Hidden | FileAttributes.System.
         /// </summary>
         public FileAttributes AttributesToSkip { get; set; }
 
diff --git a/src/System.IO.FileSystem/src/System/IO/Enumeration/MatchCasing.cs b/src/System.IO.FileSystem/src/System/IO/MatchCasing.cs
index 7257d3aa51..d8dfbfcc36 100644
--- a/src/System.IO.FileSystem/src/System/IO/Enumeration/MatchCasing.cs
+++ b/src/System.IO.FileSystem/src/System/IO/MatchCasing.cs
@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System.IO.Enumeration
+namespace System.IO
 {
     public enum MatchCasing
     {
diff --git a/src/System.IO.FileSystem/src/System/IO/Enumeration/MatchType.cs b/src/System.IO.FileSystem/src/System/IO/MatchType.cs
index edd35620bc..9789390d95 100644
--- a/src/System.IO.FileSystem/src/System/IO/Enumeration/MatchType.cs
+++ b/src/System.IO.FileSystem/src/System/IO/MatchType.cs
@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-namespace System.IO.Enumeration
+namespace System.IO
 {
     public enum MatchType
     {
diff --git a/src/System.IO.FileSystem/src/System/IO/PathHelpers.cs b/src/System.IO.FileSystem/src/System/IO/PathHelpers.cs
index f6563651a1..5e6a884b42 100644
--- a/src/System.IO.FileSystem/src/System/IO/PathHelpers.cs
+++ b/src/System.IO.FileSystem/src/System/IO/PathHelpers.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Diagnostics;
-using System.IO.Enumeration;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -96,21 +95,6 @@ namespace System.IO
             return CombineNoChecksInternal(first.AsReadOnlySpan(), second, third);
         }
 
-        /// <summary>
-        /// Combines two paths. Does no validation of paths, only concatenates the paths
-        /// and places a directory separator between them if needed.
-        /// </summary>
-        internal unsafe static string CombineNoChecks(string first, string second)
-        {
-            if (string.IsNullOrEmpty(first))
-                return string.IsNullOrEmpty(second) ? string.Empty : second;
-
-            if (string.IsNullOrEmpty(second))
-                return first;
-
-            return CombineNoChecksInternal(first.AsReadOnlySpan(), second.AsReadOnlySpan());
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private unsafe static string CombineNoChecksInternal(ReadOnlySpan<char> first, ReadOnlySpan<char> second)
         {
@@ -163,17 +147,6 @@ namespace System.IO
             }
         }
 
-        /// <summary>
-        /// Returns true if the file name is "." or ".."
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe bool IsDotOrDotDot(ReadOnlySpan<char> fileName)
-        {
-            return !(fileName.Length > 2
-                || fileName[0] != '.'
-                || (fileName.Length == 2 && fileName[1] != '.'));
-        }
-
         public static ReadOnlySpan<char> GetDirectoryNameNoChecks(ReadOnlySpan<char> path)
         {
             if (path.Length == 0)
diff --git a/src/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str.cs b/src/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str.cs
index 8a4175705a..84b018607e 100644
--- a/src/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str.cs
+++ b/src/System.IO.FileSystem/tests/Directory/GetFileSystemEntries_str.cs
@@ -175,6 +175,31 @@ namespace System.IO.Tests
             }
         }
 
+        [Fact]
+        public void HiddenFilesAreReturned()
+        {
+            // Note that APIs that take EnumerationOptions do NOT find hidden files by default
+
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+            FileInfo fileOne = new FileInfo(Path.Combine(testDirectory.FullName, GetTestFileName()));
+
+            // Put a period in front to make it hidden on Unix
+            FileInfo fileTwo = new FileInfo(Path.Combine(testDirectory.FullName, "." + GetTestFileName()));
+            fileOne.Create().Dispose();
+            fileTwo.Create().Dispose();
+            if (PlatformDetection.IsWindows)
+                fileTwo.Attributes = fileTwo.Attributes | FileAttributes.Hidden;
+
+            if (TestFiles)
+            {
+                FSAssert.EqualWhenOrdered(new string[] { fileOne.FullName, fileTwo.FullName }, GetEntries(testDirectory.FullName));
+            }
+            else
+            {
+                Assert.Empty(GetEntries(testDirectory.FullName));
+            }
+        }
+
         #endregion
 
         #region PlatformSpecific
diff --git a/src/System.IO.FileSystem/tests/Enumeration/IncludePredicateTests.netcoreapp.cs b/src/System.IO.FileSystem/tests/Enumeration/IncludePredicateTests.netcoreapp.cs
new file mode 100644
index 0000000000..0a6737e064
--- /dev/null
+++ b/src/System.IO.FileSystem/tests/Enumeration/IncludePredicateTests.netcoreapp.cs
@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.IO.Enumeration;
+using System.Linq;
+using Xunit;
+
+namespace System.IO.Tests.Enumeration
+{
+    public abstract class IncludePredicateTests : FileSystemTest
+    {
+        public static IEnumerable<string> GetFileFullPathsWithExtension(string directory,
+            bool recursive, params string[] extensions)
+        {
+            return new FileSystemEnumerable<string>(
+                directory,
+                (ref FileSystemEntry entry) => entry.ToFullPath(),
+                new EnumerationOptions() { RecurseSubdirectories = recursive })
+                {
+                    ShouldIncludePredicate = (ref FileSystemEntry entry) =>
+                    {
+                        if (entry.IsDirectory) return false;
+                        foreach (string extension in extensions)
+                        {
+                            if (Path.GetExtension(entry.FileName).EndsWith(extension))
+                                return true;
+                        }
+                        return false;
+                    }
+                };
+        }
+
+        [Fact]
+        public void CustomExtensionMatch()
+        {
+            DirectoryInfo testDirectory = Directory.CreateDirectory(GetTestFilePath());
+            DirectoryInfo testSubdirectory = Directory.CreateDirectory(Path.Combine(testDirectory.FullName, "Subdirectory"));
+            FileInfo fileOne = new FileInfo(Path.Combine(testDirectory.FullName, "fileone.htm"));
+            FileInfo fileTwo = new FileInfo(Path.Combine(testDirectory.FullName, "filetwo.html"));
+            FileInfo fileThree = new FileInfo(Path.Combine(testSubdirectory.FullName, "filethree.doc"));
+            FileInfo fileFour = new FileInfo(Path.Combine(testSubdirectory.FullName, "filefour.docx"));
+
+            fileOne.Create().Dispose();
+            fileTwo.Create().Dispose();
+            fileThree.Create().Dispose();
+            fileFour.Create().Dispose();
+
+            string[] paths = GetFileFullPathsWithExtension(testDirectory.FullName, true, ".htm", ".doc").ToArray();
+
+            FSAssert.EqualWhenOrdered(new string[] { fileOne.FullName, fileThree.FullName }, paths);
+        }
+    }
+}
diff --git a/src/System.IO.FileSystem/tests/Enumeration/SkipAttributeTests.netcoreapp.cs b/src/System.IO.FileSystem/tests/Enumeration/SkipAttributeTests.netcoreapp.cs
index 224e2e3404..d81766ef2d 100644
--- a/src/System.IO.FileSystem/tests/Enumeration/SkipAttributeTests.netcoreapp.cs
+++ b/src/System.IO.FileSystem/tests/Enumeration/SkipAttributeTests.netcoreapp.cs
@@ -42,10 +42,14 @@ namespace System.IO.Tests.Enumeration
             if (PlatformDetection.IsWindows)
                 fileFour.Attributes = fileTwo.Attributes | FileAttributes.Hidden;
 
-            string[] paths = GetPaths(testDirectory.FullName, new EnumerationOptions { AttributesToSkip = FileAttributes.Hidden });
+            // Default EnumerationOptions is to skip hidden
+            string[] paths = GetPaths(testDirectory.FullName, new EnumerationOptions());
             Assert.Equal(new string[] { fileOne.FullName }, paths);
 
-            paths = GetPaths(testDirectory.FullName, new EnumerationOptions { AttributesToSkip = FileAttributes.Hidden, RecurseSubdirectories = true });
+            paths = GetPaths(testDirectory.FullName, new EnumerationOptions { AttributesToSkip = 0 });
+            FSAssert.EqualWhenOrdered(new string[] { fileOne.FullName, fileTwo.FullName }, paths);
+
+            paths = GetPaths(testDirectory.FullName, new EnumerationOptions { RecurseSubdirectories = true });
             Assert.Equal(new string[] { fileOne.FullName, fileThree.FullName }, paths);
 
             if (PlatformDetection.IsWindows)
@@ -58,7 +62,7 @@ namespace System.IO.Tests.Enumeration
                 Directory.Move(testSubdirectory.FullName, Path.Combine(testDirectory.FullName, "." + testSubdirectory.Name));
             }
 
-            paths = GetPaths(testDirectory.FullName, new EnumerationOptions { AttributesToSkip = FileAttributes.Hidden, RecurseSubdirectories = true });
+            paths = GetPaths(testDirectory.FullName, new EnumerationOptions { RecurseSubdirectories = true });
             Assert.Equal(new string[] { fileOne.FullName }, paths);
         }
     }
diff --git a/src/System.IO.FileSystem/tests/Enumeration/SpecialDirectoryTests.netcoreapp.cs b/src/System.IO.FileSystem/tests/Enumeration/SpecialDirectoryTests.netcoreapp.cs
index 98f3a2098a..5043190cff 100644
--- a/src/System.IO.FileSystem/tests/Enumeration/SpecialDirectoryTests.netcoreapp.cs
+++ b/src/System.IO.FileSystem/tests/Enumeration/SpecialDirectoryTests.netcoreapp.cs
@@ -2,14 +2,52 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Generic;
 using System.IO.Enumeration;
 using System.Linq;
 using Xunit;
 
 namespace System.IO.Tests.Enumeration
 {
+
     public class SpecialDirectoryTests : FileSystemTest
     {
+        private class DirectoryRecursed : FileSystemEnumerator<string>
+        {
+            public int ShouldRecurseCalls { get; private set; }
+
+            public DirectoryRecursed(string directory, EnumerationOptions options)
+                : base(directory, options)
+            {
+            }
+
+            protected override string TransformEntry(ref FileSystemEntry entry)
+                =>new string(entry.FileName);
+
+            protected override bool ShouldRecurseIntoEntry(ref FileSystemEntry entry)
+            {
+                ShouldRecurseCalls++;
+                return base.ShouldRecurseIntoEntry(ref entry);
+            }
+        }
+
+        [Fact]
+        public void SpecialDirectoriesAreNotUpForRecursion()
+        {
+            using (var recursed = new DirectoryRecursed(TestDirectory, new EnumerationOptions { ReturnSpecialDirectories = true, RecurseSubdirectories = true, AttributesToSkip = 0 }))
+            {
+                List<string> results = new List<string>();
+                while (recursed.MoveNext())
+                    results.Add(recursed.Current);
+
+                Assert.Equal(0, recursed.ShouldRecurseCalls);
+                Assert.Contains("..", results);
+            }
+        }
+    }
+
+    public class SpecialDirectoryTests_Enumerable : FileSystemTest
+    {
         protected virtual string[] GetNames(string directory, EnumerationOptions options)
         {
             return new FileSystemEnumerable<string>(
@@ -21,13 +59,14 @@ namespace System.IO.Tests.Enumeration
         [Fact]
         public void SkippingHiddenFiles()
         {
-            string[] paths = GetNames(TestDirectory, new EnumerationOptions { ReturnSpecialDirectories = true });
+            // Files that begin with periods are considered hidden on Unix
+            string[] paths = GetNames(TestDirectory, new EnumerationOptions { ReturnSpecialDirectories = true, AttributesToSkip = 0 });
             Assert.Contains(".", paths);
             Assert.Contains("..", paths);
         }
     }
 
-    public class SpecialDirectoryTests_DirectoryInfo_GetDirectories : SpecialDirectoryTests
+    public class SpecialDirectoryTests_DirectoryInfo_GetDirectories : SpecialDirectoryTests_Enumerable
     {
         protected override string[] GetNames(string directory, EnumerationOptions options)
         {
diff --git a/src/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj b/src/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj
index 63a4b2c7cf..51e22c988f 100644
--- a/src/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj
+++ b/src/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj
@@ -60,6 +60,7 @@
     <Compile Include="Enumeration\MatchCasingTests.netcoreapp.cs" />
     <Compile Include="Enumeration\TrimmedPaths.netcoreapp.cs" />
     <Compile Include="Enumeration\ErrorHandlingTests.netcoreapp.cs" />
+    <Compile Include="Enumeration\IncludePredicateTests.netcoreapp.cs" />
   </ItemGroup>
   <ItemGroup>
     <!-- Rewritten -->