Fill out FileSystemInfo state when enumerating (#20716)

* Fill out FileSystemInfo state when enumerating

On Windows FileSystemInfos are filled in with state as we have
all of the state from FindFirstFileEx.

* Add more tests

Refactor Time tests and add cases for refresh state.
Fix positive attribute assertion.

* Missed one of the cases

* Tweaking the time tolerance didn't succeed.

Putting it back to -3 seconds.

* Refactor tests

Gets coverage consistent
Fixes test bug in DirectoryInfo where it was creating files for invalid attributes

* Address feedback

Author: JeremyKuhne

src/System.IO.FileSystem/src/System/IO/UnixFileSystem.cs

@@ -448,14 +448,27 @@ public override IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(string full
             {
                 case SearchTarget.Files:
                     return new FileSystemEnumerable<FileInfo>(fullPath, searchPattern, searchOption, searchTarget, (path, isDir) =>
-                        new FileInfo(path, null));
+                        {
+                            var info = new FileInfo(path, null);
+                            info.Refresh();
+                            return info;
+                        });
                 case SearchTarget.Directories:
                     return new FileSystemEnumerable<DirectoryInfo>(fullPath, searchPattern, searchOption, searchTarget, (path, isDir) =>
-                        new DirectoryInfo(path, null));
+                        {
+                            var info = new DirectoryInfo(path, null);
+                            info.Refresh();
+                            return info;
+                        });
                 default:
-                    return new FileSystemEnumerable<FileSystemInfo>(fullPath, searchPattern, searchOption, searchTarget, (path, isDir) => isDir ?
-                        (FileSystemInfo)new DirectoryInfo(path, null) :
-                        (FileSystemInfo)new FileInfo(path, null));
+                    return new FileSystemEnumerable<FileSystemInfo>(fullPath, searchPattern, searchOption, searchTarget, (path, isDir) =>
+                        {
+                            var info = isDir ?
+                                (FileSystemInfo)new DirectoryInfo(path, null) :
+                                (FileSystemInfo)new FileInfo(path, null);
+                            info.Refresh();
+                            return info;
+                        });
             }
         }
 

src/System.IO.FileSystem/tests/Base/AllGetSetAttributes.cs

@@ -0,0 +1,71 @@
+// 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 Xunit;
+
+namespace System.IO.Tests
+{
+    // Tests that are valid for File, FileInfo, and DirectoryInfo
+    public abstract class AllGetSetAttributes : BaseGetSetAttributes
+    {
+        [Fact]
+        public void NullParameters()
+        {
+            Assert.Throws<ArgumentNullException>(() => GetAttributes(null));
+            Assert.Throws<ArgumentNullException>(() => SetAttributes(null, FileAttributes.Normal));
+        }
+
+        [Fact]
+        public void InvalidParameters()
+        {
+            Assert.Throws<ArgumentException>(() => GetAttributes(string.Empty));
+            Assert.Throws<ArgumentException>(() => SetAttributes(string.Empty, FileAttributes.Normal));
+        }
+
+        [Theory, MemberData(nameof(TrailingCharacters))]
+        public void SetAttributes_MissingFile(char trailingChar)
+        {
+            Assert.Throws<FileNotFoundException>(() => SetAttributes(GetTestFilePath() + trailingChar, FileAttributes.ReadOnly));
+        }
+
+        [Theory, MemberData(nameof(TrailingCharacters))]
+        public void SetAttributes_MissingDirectory(char trailingChar)
+        {
+            Assert.Throws<DirectoryNotFoundException>(() => SetAttributes(Path.Combine(GetTestFilePath(), "file" + trailingChar), FileAttributes.ReadOnly));
+        }
+
+
+        [ConditionalFact(nameof(CanCreateSymbolicLinks))]
+        public void SymLinksAreReparsePoints()
+        {
+            string path = CreateItem();
+            string linkPath = GetTestFilePath();
+
+            Assert.True(MountHelper.CreateSymbolicLink(linkPath, path, isDirectory: IsDirectory));
+
+            Assert.NotEqual(FileAttributes.ReparsePoint, FileAttributes.ReparsePoint & GetAttributes(path));
+            Assert.Equal(FileAttributes.ReparsePoint, FileAttributes.ReparsePoint & GetAttributes(linkPath));
+        }
+
+        [ConditionalFact(nameof(CanCreateSymbolicLinks))]
+        public void SymLinksReflectSymLinkAttributes()
+        {
+            string path = CreateItem();
+            string linkPath = GetTestFilePath();
+
+            Assert.True(MountHelper.CreateSymbolicLink(linkPath, path, isDirectory: IsDirectory));
+
+            SetAttributes(path, FileAttributes.ReadOnly);
+            try
+            {
+                Assert.Equal(FileAttributes.ReadOnly, FileAttributes.ReadOnly & GetAttributes(path));
+                Assert.NotEqual(FileAttributes.ReadOnly, FileAttributes.ReadOnly & GetAttributes(linkPath));
+            }
+            finally
+            {
+                SetAttributes(path, GetAttributes(path) & ~FileAttributes.ReadOnly);
+            }
+        }
+    }
+}

src/System.IO.FileSystem/tests/Base/BaseGetSetAttributes.cs

@@ -0,0 +1,28 @@
+// 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.Runtime.CompilerServices;
+
+namespace System.IO.Tests
+{
+    public abstract class BaseGetSetAttributes : FileSystemTest
+    {
+        protected abstract FileAttributes GetAttributes(string path);
+        protected abstract void SetAttributes(string path, FileAttributes attributes);
+
+        /// <summary>
+        /// Create an appropriate filesystem object at the given path.
+        /// </summary>
+        protected virtual string CreateItem(string path = null, [CallerMemberName] string memberName = null, [CallerLineNumber] int lineNumber = 0)
+        {
+            path =  path ?? GetTestFilePath(null, memberName, lineNumber);
+            File.Create(path).Dispose();
+            return path;
+        }
+
+        protected virtual void DeleteItem(string path) => File.Delete(path);
+
+        protected virtual bool IsDirectory => false;
+    }
+}

src/System.IO.FileSystem/tests/Base/BaseGetSetTimes.cs

@@ -0,0 +1,98 @@
+// 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 Xunit;
+
+namespace System.IO.Tests
+{
+    public abstract class BaseGetSetTimes<T> : FileSystemTest
+    {
+        public delegate void SetTime(T item, DateTime time);
+        public delegate DateTime GetTime(T item);
+
+        public abstract T GetExistingItem();
+        public abstract T GetMissingItem();
+
+        public abstract IEnumerable<TimeFunction> TimeFunctions(bool requiresRoundtripping = false);
+
+        public class TimeFunction : Tuple<SetTime, GetTime, DateTimeKind>
+        {
+            public TimeFunction(SetTime setter, GetTime getter, DateTimeKind kind)
+                : base(item1: setter, item2: getter, item3: kind)
+            {
+            }
+
+            public static TimeFunction Create(SetTime setter, GetTime getter, DateTimeKind kind)
+                => new TimeFunction(setter, getter, kind);
+
+            public SetTime Setter => Item1;
+            public GetTime Getter => Item2;
+            public DateTimeKind Kind => Item3;
+        }
+
+        [Fact]
+        public void SettingUpdatesProperties()
+        {
+            T item = GetExistingItem();
+
+            Assert.All(TimeFunctions(requiresRoundtripping: true), (function) =>
+            {
+                DateTime dt = new DateTime(2014, 12, 1, 12, 0, 0, function.Kind);
+                function.Setter(item, dt);
+                DateTime result = function.Getter(item);
+                Assert.Equal(dt, result);
+                Assert.Equal(dt.ToLocalTime(), result.ToLocalTime());
+
+                // File and Directory UTC APIs treat a DateTimeKind.Unspecified as UTC whereas
+                // ToUniversalTime treats it as local.
+                if (function.Kind == DateTimeKind.Unspecified)
+                {
+                    Assert.Equal(dt, result.ToUniversalTime());
+                }
+                else
+                {
+                    Assert.Equal(dt.ToUniversalTime(), result.ToUniversalTime());
+                }
+            });
+        }
+
+        [Fact]
+        public void CanGetAllTimesAfterCreation()
+        {
+            DateTime beforeTime = DateTime.UtcNow.AddSeconds(-3);
+            T item = GetExistingItem();
+            DateTime afterTime = DateTime.UtcNow.AddSeconds(3);
+            ValidateSetTimes(item, beforeTime, afterTime);
+        }
+
+        protected void ValidateSetTimes(T item, DateTime beforeTime, DateTime afterTime)
+        {
+            Assert.All(TimeFunctions(), (function) =>
+            {
+                // We want to test all possible DateTimeKind conversions to ensure they function as expected
+                if (function.Kind == DateTimeKind.Local)
+                    Assert.InRange(function.Getter(item).Ticks, beforeTime.ToLocalTime().Ticks, afterTime.ToLocalTime().Ticks);
+                else
+                    Assert.InRange(function.Getter(item).Ticks, beforeTime.Ticks, afterTime.Ticks);
+                Assert.InRange(function.Getter(item).ToLocalTime().Ticks, beforeTime.ToLocalTime().Ticks, afterTime.ToLocalTime().Ticks);
+                Assert.InRange(function.Getter(item).ToUniversalTime().Ticks, beforeTime.Ticks, afterTime.Ticks);
+            });
+        }
+
+        public void DoesntExist_ReturnsDefaultValues()
+        {
+            T item = GetMissingItem();
+
+            Assert.All(TimeFunctions(), (function) =>
+            {
+                Assert.Equal(
+                    function.Kind == DateTimeKind.Local
+                        ? DateTime.FromFileTime(0).Ticks
+                        : DateTime.FromFileTimeUtc(0).Ticks,
+                    function.Getter(item).Ticks);
+            });
+        }
+    }
+}

src/System.IO.FileSystem/tests/Base/FileGetSetAttributes.cs

@@ -0,0 +1,69 @@
+// 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 Xunit;
+
+namespace System.IO.Tests
+{
+    // Tests that are valid for File and FileInfo
+    public abstract class FileGetSetAttributes : BaseGetSetAttributes
+    {
+        [Theory]
+        [InlineData(FileAttributes.ReadOnly)]
+        [InlineData(FileAttributes.Normal)]
+        [PlatformSpecific(TestPlatforms.AnyUnix)]  // Unix valid file attributes
+        public void UnixAttributeSetting(FileAttributes attr)
+        {
+            string path = CreateItem();
+            SetAttributes(path, attr);
+            Assert.Equal(attr, GetAttributes(path));
+            SetAttributes(path, 0);
+        }
+
+        [Theory]
+        [InlineData(FileAttributes.ReadOnly)]
+        [InlineData(FileAttributes.Hidden)]
+        [InlineData(FileAttributes.System)]
+        [InlineData(FileAttributes.Archive)]
+        [InlineData(FileAttributes.Normal)]
+        [InlineData(FileAttributes.Temporary)]
+        [InlineData(FileAttributes.ReadOnly | FileAttributes.Hidden)]
+        [PlatformSpecific(TestPlatforms.Windows)]  // Valid Windows file attribute
+        public void WindowsAttributeSetting(FileAttributes attr)
+        {
+            string path = CreateItem();
+            SetAttributes(path, attr);
+            Assert.Equal(attr, GetAttributes(path));
+            SetAttributes(path, 0);
+        }
+
+        [Theory]
+        [InlineData(FileAttributes.Temporary)]
+        [InlineData(FileAttributes.Encrypted)]
+        [InlineData(FileAttributes.SparseFile)]
+        [InlineData(FileAttributes.ReparsePoint)]
+        [InlineData(FileAttributes.Compressed)]
+        [PlatformSpecific(TestPlatforms.AnyUnix)]  // Unix invalid file attributes
+        public void UnixInvalidAttributes(FileAttributes attr)
+        {
+            string path = CreateItem();
+            SetAttributes(path, attr);
+            Assert.Equal(FileAttributes.Normal, GetAttributes(path));
+        }
+
+        [Theory]
+        [InlineData(FileAttributes.Normal)]
+        [InlineData(FileAttributes.Encrypted)]
+        [InlineData(FileAttributes.SparseFile)]
+        [InlineData(FileAttributes.ReparsePoint)]
+        [InlineData(FileAttributes.Compressed)]
+        [PlatformSpecific(TestPlatforms.Windows)]  // Invalid Windows file attributes 
+        public void WindowsInvalidAttributes(FileAttributes attr)
+        {
+            string path = CreateItem();
+            SetAttributes(path, attr);
+            Assert.Equal(FileAttributes.Normal, GetAttributes(path));
+        }
+    }
+}

src/System.IO.FileSystem/tests/Base/InfoGetSetAttributes.cs

@@ -0,0 +1,65 @@
+// 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 Xunit;
+using System.Linq;
+
+namespace System.IO.Tests
+{
+    // Tests that are valid for FileInfo and DirectoryInfo
+    public abstract class InfoGetSetAttributes<T> : AllGetSetAttributes where T : FileSystemInfo
+    {
+        protected abstract T CreateInfo(string path);
+
+        // In NetFX we ignore "not found" errors, which leaves the attributes
+        // state as invalid (0xFFFFFFFF), which makes all flags true.
+
+        [Theory, MemberData(nameof(TrailingCharacters))]
+        public void GetAttributes_MissingFile(char trailingChar)
+        {
+            Assert.Equal((FileAttributes)(-1), GetAttributes(GetTestFilePath() + trailingChar));
+        }
+
+        [Theory, MemberData(nameof(TrailingCharacters))]
+        public void GetAttributes_MissingDirectory(char trailingChar)
+        {
+            Assert.Equal((FileAttributes)(-1), GetAttributes(Path.Combine(GetTestFilePath(), "file" + trailingChar)));
+        }
+
+        [Theory, MemberData(nameof(TrailingCharacters))]
+        public void GetAttributes_CreateAfter(char trailingChar)
+        {
+            string path = GetTestFilePath();
+            T info = CreateInfo(trailingChar == 'a' ? path : path + trailingChar);
+            CreateItem(path);
+
+            // The actual value will vary depending on the OS and what is running.
+            // Archive, NotContentIndexed, etc. might be set.
+            Assert.NotEqual((FileAttributes)(-1), info.Attributes);
+        }
+
+        [Theory, MemberData(nameof(TrailingCharacters))]
+        public void GetAttributes_DeleteAfter(char trailingChar)
+        {
+            string path = CreateItem();
+            T info = CreateInfo(trailingChar == 'a' ? path : path + trailingChar);
+            DeleteItem(path);
+            Assert.Equal((FileAttributes)(-1), info.Attributes);
+        }
+
+        public void GetAttributes_DeleteAfterEnumerate()
+        {
+            // When enumerating we populate the state as we already have it.
+            string path = CreateItem();
+            FileSystemInfo info = new DirectoryInfo(TestDirectory).EnumerateFileSystemInfos().First();
+            DeleteItem(path);
+
+            // The actual value will vary depending on the OS and what is running.
+            // Archive, NotContentIndexed, etc. might be set.
+            Assert.NotEqual((FileAttributes)(-1), info.Attributes);
+            info.Refresh();
+            Assert.Equal((FileAttributes)(-1), info.Attributes);
+        }
+    }
+}