[release/2.1] Fix Granularity for copy operation on unix (#31046)

* Fix Granualarity on unix

* Maintaining the consistency of tests among master and release branch (#31164)

* Feedback Addressed

* Fixing original tests and for appContainers

* comment corrected

Author: Anipik

src/Native/Unix/System.Native/pal_io.c

@@ -1193,18 +1193,18 @@ int32_t SystemNative_CopyFile(intptr_t sourceFd, intptr_t destinationFd)
 #if HAVE_FUTIMES
         struct timeval origTimes[2];
         origTimes[0].tv_sec = sourceStat.st_atime;
-        origTimes[0].tv_usec = 0;
+        origTimes[0].tv_usec = ST_ATIME_NSEC(&sourceStat) / 1000;
         origTimes[1].tv_sec = sourceStat.st_mtime;
-        origTimes[1].tv_usec = 0;
+        origTimes[1].tv_usec = ST_MTIME_NSEC(&sourceStat) / 1000;
         while ((ret = futimes(outFd, origTimes)) < 0 && errno == EINTR);
 #elif HAVE_FUTIMENS
         // futimes is not a POSIX function, and not available on Android,
         // but futimens is
         struct timespec origTimes[2];
         origTimes[0].tv_sec = (time_t)sourceStat.st_atime;
-        origTimes[0].tv_nsec = 0;
+        origTimes[0].tv_nsec = ST_ATIME_NSEC(&sourceStat);
         origTimes[1].tv_sec = (time_t)sourceStat.st_mtime;
-        origTimes[1].tv_nsec = 0;
+        origTimes[1].tv_nsec = ST_MTIME_NSEC(&sourceStat);
         while ((ret = futimens(outFd, origTimes)) < 0 && errno == EINTR);
 #endif
     }

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

@@ -10,8 +10,14 @@ namespace System.IO.Tests
 {
     public abstract class BaseGetSetTimes<T> : FileSystemTest
     {
+        protected const string HFS = "hfs";
         public delegate void SetTime(T item, DateTime time);
         public delegate DateTime GetTime(T item);
+        // AppContainer restricts access to DriveFormat (::GetVolumeInformation)
+        private static string driveFormat = PlatformDetection.IsInAppContainer ? string.Empty : new DriveInfo(Path.GetTempPath()).DriveFormat;
+
+        protected static bool isHFS => driveFormat.Equals(HFS, StringComparison.InvariantCultureIgnoreCase);
+        protected static bool isNotHFS => !isHFS;
 
         public abstract T GetExistingItem();
         public abstract T GetMissingItem();
@@ -70,22 +76,17 @@ public void CanGetAllTimesAfterCreation()
             ValidateSetTimes(item, beforeTime, afterTime);
         }
 
-        [Fact]
-        [PlatformSpecific(TestPlatforms.Linux)] // Windows tested below, and OSX does not currently support millisec granularity
-        public void TimesIncludeMillisecondPart_Linux()
+        [ConditionalFact(nameof(isNotHFS))] // OSX HFS driver format does not support millisec granularity
+        public void TimesIncludeMillisecondPart_Unix()
         {
             T item = GetExistingItem();
-
-            string driveFormat = new DriveInfo(GetItemPath(item)).DriveFormat;
-
             Assert.All(TimeFunctions(), (function) =>
             {
                 var msec = 0;
                 for (int i = 0; i < 5; i++)
                 {
                     DateTime time = function.Getter(item);
                     msec = time.Millisecond;
-
                     if (msec != 0)
                         break;
 
@@ -107,42 +108,11 @@ public void TimesIncludeMillisecondPart_Linux()
             });
         }
 
-
-        [Fact]
-        [PlatformSpecific(TestPlatforms.Windows)] // Breaking out Windows as it passes no problem there
-        public void TimesIncludeMillisecondPart_Windows()
-        {
-            T item = GetExistingItem();
-            Assert.All(TimeFunctions(), (function) =>
-            {
-                var msec = 0;
-                for (int i = 0; i < 5; i++)
-                {
-                    DateTime time = function.Getter(item);
-                    msec = time.Millisecond;
-                    if (msec != 0)
-                        break;
-
-                    // This case should only happen 1/1000 times, unless the OS/Filesystem does
-                    // not support millisecond granularity.
-
-                    // If it's 1/1000, or low granularity, this may help:
-                    Thread.Sleep(1234);
-
-                    item = GetExistingItem(); // try a new file/directory
-                }
-
-                Assert.NotEqual(0, msec);
-            });
-        }
-
-        [Fact]
-        // OSX does not currently support millisec granularity: use this test as a canary to flag
-        // if this ever changes so we can enable the actual test
-        [PlatformSpecific(TestPlatforms.OSX)]
+        [ConditionalFact(nameof(isHFS))]
         public void TimesIncludeMillisecondPart_OSX()
         {
             T item = GetExistingItem();
+            // OSX HFS driver format does not support millisec granularity
             Assert.All(TimeFunctions(), (function) =>
             {
                 DateTime time = function.Getter(item);

src/System.IO.FileSystem/tests/FileInfo/GetSetTimes.cs

@@ -4,6 +4,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using Xunit;
 
 namespace System.IO.Tests
@@ -66,6 +67,43 @@ public override IEnumerable<TimeFunction> TimeFunctions(bool requiresRoundtrippi
                 DateTimeKind.Utc);
         }
 
+        [ConditionalFact(nameof(isNotHFS))]
+        public void CopyToMillisecondPresent()
+        {
+            FileInfo input = new FileInfo(GetTestFilePath());
+            for (int i = 0; i < 5; i++)
+            {
+                input.Create().Dispose();
+                if (input.LastWriteTime.Millisecond != 0)
+                    break;
+
+                // This case should only happen 1/1000 times, unless the OS/Filesystem does
+                // not support millisecond granularity.
+
+                // If it's 1/1000, or low granularity, this may help:
+                Thread.Sleep(1234);
+            }
+
+            FileInfo output = new FileInfo(Path.Combine(GetTestFilePath(), input.Name));
+            Assert.Equal(0, output.LastWriteTime.Millisecond);
+            output.Directory.Create();
+            output = input.CopyTo(output.FullName, true);
+            Assert.NotEqual(0, input.LastWriteTime.Millisecond);
+            Assert.NotEqual(0, output.LastWriteTime.Millisecond);
+        }
+
+        [ConditionalFact(nameof(isHFS))]
+        public void CopyToMillisecondPresent_HFS()
+        {
+            FileInfo input = new FileInfo(GetTestFilePath());
+            input.Create().Dispose();
+            FileInfo output = new FileInfo(Path.Combine(GetTestFilePath(), input.Name));
+            output.Directory.Create();
+            output = input.CopyTo(output.FullName, true);
+            Assert.Equal(0, input.LastWriteTime.Millisecond);
+            Assert.Equal(0, output.LastWriteTime.Millisecond);
+        }
+
         [Fact]
         public void DeleteAfterEnumerate_TimesStillSet()
         {