[libcxx] [test] Fix the last_write_time test to work on windows

[mstorsjo]

In this one, a lot of the issues revolve around the test itself using the ´stat()` function (which exists but is crippled and doesn't do the right thing regarding symlinks) - would it be better to simply reimplement a "proper" checker of last write time here, i.e. include a stripped down version of the stat/last_write_time from the libc++ implementation itself?

[mstorsjo]

Superseded by D101731.

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

 #include <ctime>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 #include <fcntl.h>
+#ifndef _WIN32
 #include <sys/time.h>
+#endif
 #include <sys/stat.h>
 
 using namespace fs;
 
 using TimeSpec = timespec;
 using StatT = struct stat;
 
 using Sec = std::chrono::duration<file_time_type::rep>;
 using Hours = std::chrono::hours;
 using Minutes = std::chrono::minutes;
+using MilliSec = std::chrono::duration<file_time_type::rep, std::milli>;
 using MicroSec = std::chrono::duration<file_time_type::rep, std::micro>;
 using NanoSec = std::chrono::duration<file_time_type::rep, std::nano>;
 using std::chrono::duration_cast;
 
 #if defined(__APPLE__)
 TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
 TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
+#elif defined(_WIN32)
+TimeSpec extract_mtime(StatT const& st) { return TimeSpec{st.st_mtime, 0}; }
+TimeSpec extract_atime(StatT const& st) { return TimeSpec{st.st_atime, 0}; }
 #else
 TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
 TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
 #endif
 
 bool ConvertToTimeSpec(TimeSpec& ts, file_time_type ft) {
   using SecFieldT = decltype(TimeSpec::tv_sec);
   using NSecFieldT = decltype(TimeSpec::tv_nsec);
#endif
     }
     return {extract_atime(st), extract_mtime(st)};
 }
 
 TimeSpec LastAccessTime(path const& p) { return GetTimes(p).access; }
 
 TimeSpec LastWriteTime(path const& p) { return GetTimes(p).write; }
 
+#ifndef _WIN32
+// There's no lstat() in the Windows CRTs
 Times GetSymlinkTimes(path const& p) {
   StatT st;
   if (::lstat(p.string().c_str(), &st) == -1) {
     std::error_code ec(errno, std::generic_category());
 #ifndef TEST_HAS_NO_EXCEPTIONS
         throw ec;
 #else
         std::exit(EXIT_FAILURE);
 #endif
     }
     Times res;
     res.access = extract_atime(st);
     res.write = extract_mtime(st);
     return res;
 }
+#endif
 
 namespace {
 
 // In some configurations, the comparison is tautological and the test is valid.
 // We disable the warning so that we can actually test it regardless. Also, that
 // diagnostic is pretty new, so also don't fail if old clang does not support it
 #if defined(__clang__)
 #pragma clang diagnostic push
static const bool SupportsMinRoundTrip = [] {
   if (!ConvertFromTimeSpec(min_val, ts))
     return false;
   return min_val == file_time_type::min();
 }();
 
 } // end namespace
 
 static bool CompareTime(TimeSpec t1, TimeSpec t2) {
+#ifdef _WIN32
+  // Windows does support file times with a 100 ns unit, but this test
+  // only uses the CRT stat() to inspect the tested files, and stat() only
+  // returns times with second granularity.
+  return t1.tv_sec == t2.tv_sec;
+#else
   if (SupportsNanosecondRoundTrip)
     return CompareTimeExact(t1, t2);
   if (t1.tv_sec != t2.tv_sec)
     return false;
 
   auto diff = std::abs(t1.tv_nsec - t2.tv_nsec);
   if (WorkaroundStatTruncatesToSeconds)
    return diff < duration_cast<NanoSec>(Sec(1)).count();
   return diff < duration_cast<NanoSec>(MicroSec(1)).count();
+#endif
 }
 
 static bool CompareTime(file_time_type t1, TimeSpec t2) {
   TimeSpec ts1 = {};
   if (!ConvertToTimeSpec(ts1, t1))
     return false;
   return CompareTime(ts1, t2);
 }
TEST_CASE(signature_test)
     ASSERT_NOEXCEPT(last_write_time(p, t, ec));
 }
 
 TEST_CASE(read_last_write_time_static_env_test)
 {
     static_test_env static_env;
     using C = file_time_type::clock;
     file_time_type min = file_time_type::min();
+    // Sleep a little to make sure that static_env.File created above is
+    // strictly older than C::now() even with a coarser clock granularity
+    // in C::now(). (GetSystemTimeAsFileTime on windows has a fairly coarse
+    // granularity.)
+    SleepFor(MilliSec(30));
     {
         file_time_type ret = last_write_time(static_env.File);
         TEST_CHECK(ret != min);
         TEST_CHECK(ret < C::now());
         TEST_CHECK(CompareTime(ret, LastWriteTime(static_env.File)));
 
         file_time_type ret2 = last_write_time(static_env.SymlinkToFile);
         TEST_CHECK(CompareTime(ret, ret2));
for (const auto& TC : cases) {
         if (TimeIsRepresentableByFilesystem(TC.new_time)) {
             TEST_CHECK(got_time != old_time);
             TEST_CHECK(CompareTime(got_time, TC.new_time));
             TEST_CHECK(CompareTime(LastAccessTime(TC.p), old_times.access));
         }
     }
 }
 
+#ifndef _WIN32
+// There's no lstat() in the Windows CRTs
 TEST_CASE(last_write_time_symlink_test)
 {
     using Clock = file_time_type::clock;
 
     scoped_test_env env;
 
     const path file = env.create_file("file", 42);
     const path sym = env.create_symlink("file", "sym");
if (!WorkaroundStatTruncatesToSeconds) {
       TEST_CHECK(CompareTime(got_time, new_time));
     }
 
     TEST_CHECK(CompareTime(LastWriteTime(file), new_time));
     TEST_CHECK(CompareTime(LastAccessTime(sym), old_times.access));
     Times sym_times = GetSymlinkTimes(sym);
     TEST_CHECK(CompareTime(sym_times.write, old_sym_times.write));
 }
+#endif
 
 
 TEST_CASE(test_write_min_time)
 {
     scoped_test_env env;
     const path p = env.create_file("file", 42);
     const file_time_type old_time = last_write_time(p);
     file_time_type new_time = file_time_type::min();

libcxx/test/support/filesystem_test_helper.h

 template <class... ErrcT>
 inline bool ErrorIs(const std::error_code& ec, std::errc First, ErrcT... Rest) {
   std::vector<std::errc> errors = {First, Rest...};
   return ErrorIsImp(ec, errors);
 }
 
 // Provide our own Sleep routine since std::this_thread::sleep_for is not
 // available in single-threaded mode.
-void SleepFor(std::chrono::seconds dur) {
+template <class Dur>
+void SleepFor(Dur dur) {
     using namespace std::chrono;
 #if defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
     using Clock = system_clock;
 #else
     using Clock = steady_clock;
 #endif
     const auto wake_time = Clock::now() + dur;
     while (Clock::now() < wake_time)