[libcxx] [test] Fix fs.op.last_write_time for Windows

[mstorsjo]

Summary

Don't use stat and lstat on Windows; lstat is missing, stat only provides
the modification times with second granularity (and does the wrong thing
regarding symlinks). Instead do a minimal reimplementation using the
native windows APIs.

This is an alternative to D98641. This one contains more compat churn
at the top of the file (reimplememtations of stat and lstat), but
requires much less modifications to the rest of the test. Therefore
I'd kind of prefer this one out of the two.

[mstorsjo]

Ping

[Mordante]

In general looks good. It would be great if we can get this working without the compat namespace. This would make maintenance slightly easier. Not a blocker since the CI will fail when making a mistake.

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

39–40

Is the stat header required on Windows? If not would it be possible to include this header conditional and remove the compat namespace?

92

Please move this line outside the #if section

99

Please remove this line.

[mstorsjo]

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

39–40

Ok, that seems to work. I'd generally consider that (trying to avoid that a specific gets included) a bit more brittle, but as long as we have CI, I guess it's fine.

The actual implementation uses a namespace like this though, but as long as we can do without one here, the test remains simpler.

92

If we'd keep the namespace, I wouldn't want to move the ending brace of the namespace outside of the ifdef as long as the starting brace is within the ifdef, that'd be awfully imbalanced. But we can get rid of it altogether.

[mstorsjo]

Removed the compat namespace, simplifying the patch.

[Mordante]

It seems the build failed since the patch couldn't be applied. Does this patch depend on other patches?
LGTM, but please make sure it passes CI before committing.

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

92

I thought the namespace started before the initial #if. Maybe I misread. But with this version of the patch the comment no longer applies.

[mstorsjo]

In D101731#2748135, @Mordante wrote:

It seems the build failed since the patch couldn't be applied. Does this patch depend on other patches?

No, but there's other lines changed closeby by another recently applied patch, regarding the XFAIL lines - rebasing past that and reposting for CI.

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

92

No, it started within the #if. But the question is moot in this revision anyway.

[mstorsjo]

Rebased, rerunning CI.

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

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // The string reported on errors changed, which makes those tests fail when run
 // against already-released libc++'s.
 // XFAIL: use_system_cxx_lib && x86_64-apple-macosx10.15
 
 // <filesystem>
 
 // file_time_type last_write_time(const path& p);
 // file_time_type last_write_time(const path& p, std::error_code& ec) noexcept;
 // void last_write_time(const path& p, file_time_type new_time);
 // void last_write_time(const path& p, file_time_type new_type,
 //                      std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <chrono>
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 #include <fcntl.h>
+#ifdef _WIN32
+#include <windows.h>
+#else
 #include <sys/time.h>
 #include <sys/stat.h>
+#endif
 
 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;
 
+#ifdef _WIN32
+struct TimeSpec {
+  int64_t tv_sec;
+  int64_t tv_nsec;
+};
+struct StatT {
+  TimeSpec st_atim;
+  TimeSpec st_mtim;
+};
+// There were 369 years and 89 leap days from the Windows epoch
+// (1601) to the Unix epoch (1970).
+#define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
+static TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
+  TimeSpec ret;
+  ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
+  ret.tv_nsec = (li.QuadPart % 10000000) * 100;
+  return ret;
+}
+static int stat_file(const char *path, StatT *buf, int flags) {
+  HANDLE h = CreateFileA(path, FILE_READ_ATTRIBUTES,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                         nullptr, OPEN_EXISTING,
+                         FILE_FLAG_BACKUP_SEMANTICS | flags, nullptr);
+  if (h == INVALID_HANDLE_VALUE)
+    return -1;
+  int ret = -1;
+  FILE_BASIC_INFO basic;
+  if (GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic))) {
+    buf->st_mtim = filetime_to_timespec(basic.LastWriteTime);
+    buf->st_atim = filetime_to_timespec(basic.LastAccessTime);
+    ret = 0;
+  }
+  CloseHandle(h);
+  return ret;
+}
+static int stat(const char *path, StatT *buf) {
+  return stat_file(path, buf, 0);
+}
+static int lstat(const char *path, StatT *buf) {
+  return stat_file(path, buf, FILE_FLAG_OPEN_REPARSE_POINT);
+}
+#else
+using TimeSpec = timespec;
+using StatT = struct stat;
+#endif
+
 #if defined(__APPLE__)
 TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
 TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
 #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);
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));

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)