[libcxx] r337960 - [libc++] Use __int128_t to represent file_time_type.
Alex L via cfe-commits
cfe-commits at lists.llvm.org
Wed Jul 25 18:18:24 PDT 2018
I couldn't reproduce it on my machine, and I don't have access to the bot
ATM, but I will try it on an older OS to see if it's an issue with the
particular OS that's used on our bot.
Cheers,
Alex
On 25 July 2018 at 17:43, Alex L <arphaman at gmail.com> wrote:
> I'll take a look and will try to reproduce it right now.
>
> On 25 July 2018 at 17:37, Eric Fiselier <eric at efcs.ca> wrote:
>
>>
>>
>> On Wed, Jul 25, 2018 at 6:03 PM Alex L <arphaman at gmail.com> wrote:
>>
>>> Hmm, looks like the added test is failing on Darwin even after your
>>> fixes.
>>>
>>> Do you have an idea of why that could be?
>>>
>>
>> Not yet, working on it now.
>> I'm failing to reproduce it on my macbook though. If you can, any
>> information about what's going on would be helpful.
>> Like what are those actual values?
>>
>>
>>>
>>> http://lab.llvm.org:8080/green/job/libcxx_master_cmake/4784/
>>> testReport/junit/libc++/std_experimental_filesystem_fs_op_
>>> funcs_fs_op_last_write_time/last_write_time_pass_cpp/
>>>
>>> Compiled With: ['/Applications/Xcode.app/Cont
>>> ents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++',
>>> '-o', '/Users/buildslave/jenkins/sharedspace/libcxx/build/test/std
>>> /experimental/filesystem/fs.op.funcs/fs.op.last_write_time
>>> /Output/last_write_time.pass.cpp.o', '-x', 'c++',
>>> '/Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/tes
>>> t/std/experimental/filesystem/fs.op.funcs/fs.op.last_write_
>>> time/last_write_time.pass.cpp', '-c', '-v', '-arch', 'x86_64',
>>> '-mmacosx-version-min=10.13', '-D_LIBCPP_DISABLE_AVAILABILITY',
>>> '-ftemplate-depth=270', '-Werror=thread-safety', '-std=c++11', '-include',
>>> '/Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/support/nasty_macros.hpp',
>>> '-nostdinc++', '-I/Users/buildslave/jenkins/s
>>> haredspace/libcxx/libcxx.src/include', '-I/Users/buildslave/jenkins/s
>>> haredspace/libcxx/build/include/c++build', '-isysroot',
>>> '/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX
>>> .platform/Developer/SDKs/MacOSX10.13.sdk',
>>> '-I/Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test/support',
>>> '-DLIBCXX_FILESYSTEM_STATIC_TEST_ROOT="/Users/buildslave/jen
>>> kins/sharedspace/libcxx/libcxx.src/test/std/experimental/
>>> filesystem/Inputs/static_test_env"', '-DLIBCXX_FILESYSTEM_DYNAMIC_T
>>> EST_ROOT="/Users/buildslave/jenkins/sharedspace/libcxx/build
>>> /test/filesystem/Output/dynamic_env"', '-DLIBCXX_FILESYSTEM_DYNAMIC_T
>>> EST_HELPER="/usr/local/opt/python at 2/bin/python2.7
>>> /Users/buildslave/jenkins/sharedspace/libcxx/libcxx.src/test
>>> /support/filesystem_dynamic_test_helper.py"',
>>> '-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER', '-Wall', '-Wextra', '-Werror',
>>> '-Wuser-defined-warnings', '-Wshadow', '-Wno-unused-command-line-argument',
>>> '-Wno-attributes', '-Wno-pessimizing-move', '-Wno-c++11-extensions',
>>> '-Wno-user-defined-literals', '-Wno-noexcept-type',
>>> '-Wno-aligned-allocation-unavailable', '-Wsign-compare',
>>> '-Wunused-variable', '-Wunused-parameter', '-Wunreachable-code',
>>> '-Wno-conversion', '-Wno-unused-local-typedef', '-c', '&&',
>>> '/Applications/Xcode.app/Contents/Developer/Toolchains/Xcode
>>> Default.xctoolchain/usr/bin/clang++', '-o',
>>> '/Users/buildslave/jenkins/sharedspace/libcxx/build/test/std
>>> /experimental/filesystem/fs.op.funcs/fs.op.last_write_time
>>> /Output/last_write_time.pass.cpp.exe', '/Users/buildslave/jenkins/sha
>>> redspace/libcxx/build/test/std/experimental/filesystem/fs.
>>> op.funcs/fs.op.last_write_time/Output/last_write_time.pass.cpp.o',
>>> '-v', '-arch', 'x86_64', '-mmacosx-version-min=10.13',
>>> '-D_LIBCPP_DISABLE_AVAILABILITY', '-ftemplate-depth=270',
>>> '-L/Users/buildslave/jenkins/sharedspace/libcxx/build/lib',
>>> '-Wl,-rpath,/Users/buildslave/jenkins/sharedspace/libcxx/build/lib',
>>> '-nodefaultlibs', '-lc++experimental', '-lc++', '-lSystem']
>>> Command: ['/Users/buildslave/jenkins/sharedspace/libcxx/build/test/st
>>> d/experimental/filesystem/fs.op.funcs/fs.op.last_write_time
>>> /Output/last_write_time.pass.cpp.exe']
>>> Exit Code: 1
>>> Standard Error:
>>> --
>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In set_last_write_time_dynamic_env_test():451 Assertion
>>> TEST_CHECK(CompareTime(got_time, TC.new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In last_write_time_symlink_test():477 Assertion TEST_CHECK(got_time ==
>>> new_time) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> In last_write_time_symlink_test():479 Assertion
>>> TEST_CHECK(CompareTime(LastWriteTime(file), new_time)) failed.
>>> in file: /Users/buildslave/jenkins/shar
>>> edspace/libcxx/libcxx.src/test/std/experimental/filesystem/
>>> fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
>>>
>>> Summary for testsuite last_write_time_test_suite:
>>> 7 of 9 test cases passed.
>>> 78 of 88 assertions passed.
>>> 0 unsupported test cases.
>>> --
>>>
>>> Compiled test failed unexpectedly!
>>>
>>> Thanks,
>>> Alex
>>>
>>>
>>> On 25 July 2018 at 17:00, Alex L <arphaman at gmail.com> wrote:
>>>
>>>> Sure! Fixed it up in r337984.
>>>>
>>>> On 25 July 2018 at 15:03, Eric Fiselier <eric at efcs.ca> wrote:
>>>>
>>>>>
>>>>>
>>>>> On Wed, Jul 25, 2018 at 3:39 PM Alex L <arphaman at gmail.com> wrote:
>>>>>
>>>>>> Looks like this works:
>>>>>>
>>>>>> +++ b/src/experimental/filesystem/filesystem_common.h
>>>>>> @@ -393,7 +393,7 @@ bool set_file_times(const path& p,
>>>>>> std::array<TimeSpec, 2> const& TS,
>>>>>> error_code& ec) {
>>>>>> #if !defined(_LIBCPP_USE_UTIMENSAT)
>>>>>> using namespace chrono;
>>>>>> - auto Convert = [](long nsec) {
>>>>>> + auto Convert = [](long nsec) -> decltype(std::declval<::timeval>().tv_usec)
>>>>>> {
>>>>>> return duration_cast<microseconds>(nanoseconds(nsec)).count();
>>>>>> };
>>>>>> struct ::timeval ConvertedTS[2] = {{TS[0].tv_sec,
>>>>>> Convert(TS[0].tv_nsec)},
>>>>>>
>>>>>> I will commit this fix in a couple of minutes.
>>>>>>
>>>>>
>>>>> I think I would prefer an explicit cast to an implicit one since the
>>>>> narrowing is intended, and should be safe.
>>>>>
>>>>> Maybe:
>>>>>
>>>>> auto Convert [](long nsec) {
>>>>> using int_type = decltype(::timeval::tv_usec);
>>>>> auto dur = duration_cast<microseconds>(nanoseconds(nsec)).count();
>>>>> return static_cast<int_type>(dur);
>>>>> };
>>>>>
>>>>> ?
>>>>>
>>>>>>
>>>>>> On 25 July 2018 at 14:27, Eric Fiselier <eric at efcs.ca> wrote:
>>>>>>
>>>>>>> Thanks. let me know if you want me to take over
>>>>>>>
>>>>>>> On Wed, Jul 25, 2018, 3:22 PM Alex L, <arphaman at gmail.com> wrote:
>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> On 25 July 2018 at 13:51, Eric Fiselier via cfe-commits <
>>>>>>>> cfe-commits at lists.llvm.org> wrote:
>>>>>>>>
>>>>>>>>> Author: ericwf
>>>>>>>>> Date: Wed Jul 25 13:51:49 2018
>>>>>>>>> New Revision: 337960
>>>>>>>>>
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project?rev=337960&view=rev
>>>>>>>>> Log:
>>>>>>>>> [libc++] Use __int128_t to represent file_time_type.
>>>>>>>>>
>>>>>>>>> Summary:
>>>>>>>>> The ``file_time_type`` time point is used to represent the write
>>>>>>>>> times for files.
>>>>>>>>> Its job is to act as part of a C++ wrapper for less ideal system
>>>>>>>>> interfaces. The
>>>>>>>>> underlying filesystem uses the ``timespec`` struct for the same
>>>>>>>>> purpose.
>>>>>>>>>
>>>>>>>>> However, the initial implementation of ``file_time_type`` could
>>>>>>>>> not represent
>>>>>>>>> either the range or resolution of ``timespec``, making it
>>>>>>>>> unsuitable. Fixing
>>>>>>>>> this requires an implementation which uses more than 64 bits to
>>>>>>>>> store the
>>>>>>>>> time point.
>>>>>>>>>
>>>>>>>>> I primarily considered two solutions: Using ``__int128_t`` and
>>>>>>>>> using a
>>>>>>>>> arithmetic emulation of ``timespec``. Each has its pros and cons,
>>>>>>>>> and both
>>>>>>>>> come with more than one complication.
>>>>>>>>>
>>>>>>>>> However, after a lot of consideration, I decided on using
>>>>>>>>> `__int128_t`. This patch implements that change.
>>>>>>>>>
>>>>>>>>> Please see the [FileTimeType Design Document](http://libcxx.llvm.o
>>>>>>>>> rg/docs/DesignDocs/FileTimeType.html) for more information.
>>>>>>>>>
>>>>>>>>> Reviewers: mclow.lists, ldionne, joerg, arthur.j.odwyer, EricWF
>>>>>>>>>
>>>>>>>>> Reviewed By: EricWF
>>>>>>>>>
>>>>>>>>> Subscribers: christof, K-ballo, cfe-commits, BillyONeal
>>>>>>>>>
>>>>>>>>> Differential Revision: https://reviews.llvm.org/D49774
>>>>>>>>>
>>>>>>>>> Added:
>>>>>>>>> libcxx/trunk/src/include/apple_availability.h
>>>>>>>>> Modified:
>>>>>>>>> libcxx/trunk/include/experimental/filesystem
>>>>>>>>> libcxx/trunk/src/chrono.cpp
>>>>>>>>> libcxx/trunk/src/experimental/filesystem/filesystem_common.h
>>>>>>>>> libcxx/trunk/src/experimental/filesystem/operations.cpp
>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/class.direc
>>>>>>>>> tory_entry/directory_entry.mods/last_write_time.sh.cpp
>>>>>>>>> libcxx/trunk/test/libcxx/experimental/filesystem/convert_
>>>>>>>>> file_time.sh.cpp
>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.filesystem.
>>>>>>>>> synopsis/file_time_type.pass.cpp
>>>>>>>>> libcxx/trunk/test/std/experimental/filesystem/fs.op.funcs/
>>>>>>>>> fs.op.last_write_time/last_write_time.pass.cpp
>>>>>>>>>
>>>>>>>>> Modified: libcxx/trunk/include/experimental/filesystem
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/exp
>>>>>>>>> erimental/filesystem?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/include/experimental/filesystem (original)
>>>>>>>>> +++ libcxx/trunk/include/experimental/filesystem Wed Jul 25
>>>>>>>>> 13:51:49 2018
>>>>>>>>> @@ -260,7 +260,37 @@ _LIBCPP_PUSH_MACROS
>>>>>>>>>
>>>>>>>>> _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
>>>>>>>>>
>>>>>>>>> -typedef chrono::time_point<std::chrono::system_clock>
>>>>>>>>> file_time_type;
>>>>>>>>> +struct _FilesystemClock {
>>>>>>>>> +#if !defined(_LIBCPP_HAS_NO_INT128)
>>>>>>>>> + typedef __int128_t rep;
>>>>>>>>> + typedef nano period;
>>>>>>>>> +#else
>>>>>>>>> + typedef long long rep;
>>>>>>>>> + typedef nano period;
>>>>>>>>> +#endif
>>>>>>>>> +
>>>>>>>>> + typedef chrono::duration<rep, period> duration;
>>>>>>>>> + typedef chrono::time_point<_FilesystemClock> time_point;
>>>>>>>>> +
>>>>>>>>> + static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady =
>>>>>>>>> false;
>>>>>>>>> +
>>>>>>>>> + _LIBCPP_FUNC_VIS static time_point now() noexcept;
>>>>>>>>> +
>>>>>>>>> + _LIBCPP_INLINE_VISIBILITY
>>>>>>>>> + static time_t to_time_t(const time_point& __t) noexcept {
>>>>>>>>> + typedef chrono::duration<rep> __secs;
>>>>>>>>> + return time_t(
>>>>>>>>> + chrono::duration_cast<__secs>(
>>>>>>>>> __t.time_since_epoch()).count());
>>>>>>>>> + }
>>>>>>>>> +
>>>>>>>>> + _LIBCPP_INLINE_VISIBILITY
>>>>>>>>> + static time_point from_time_t(time_t __t) noexcept {
>>>>>>>>> + typedef chrono::duration<rep> __secs;
>>>>>>>>> + return time_point(__secs(__t));
>>>>>>>>> + }
>>>>>>>>> +};
>>>>>>>>> +
>>>>>>>>> +typedef chrono::time_point<_FilesystemClock> file_time_type;
>>>>>>>>>
>>>>>>>>> struct _LIBCPP_TYPE_VIS space_info
>>>>>>>>> {
>>>>>>>>>
>>>>>>>>> Modified: libcxx/trunk/src/chrono.cpp
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/chrono.
>>>>>>>>> cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/src/chrono.cpp (original)
>>>>>>>>> +++ libcxx/trunk/src/chrono.cpp Wed Jul 25 13:51:49 2018
>>>>>>>>> @@ -11,27 +11,10 @@
>>>>>>>>> #include "cerrno" // errno
>>>>>>>>> #include "system_error" // __throw_system_error
>>>>>>>>> #include <time.h> // clock_gettime, CLOCK_MONOTONIC and
>>>>>>>>> CLOCK_REALTIME
>>>>>>>>> +#include "include/apple_availability.h"
>>>>>>>>>
>>>>>>>>> -#if (__APPLE__)
>>>>>>>>> -#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
>>>>>>>>> -#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>> -#endif
>>>>>>>>> -#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> -#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000
>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>> -#endif
>>>>>>>>> -#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> -#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000
>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>> -#endif
>>>>>>>>> -#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> -#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000
>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>> -#endif
>>>>>>>>> -#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
>>>>>>>>> -#else
>>>>>>>>> -#define _LIBCXX_USE_CLOCK_GETTIME
>>>>>>>>> +#if !defined(__APPLE__)
>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>> #endif // __APPLE__
>>>>>>>>>
>>>>>>>>> #if defined(_LIBCPP_WIN32API)
>>>>>>>>> @@ -42,7 +25,7 @@
>>>>>>>>> #include <winapifamily.h>
>>>>>>>>> #endif
>>>>>>>>> #else
>>>>>>>>> -#if !defined(CLOCK_REALTIME) || !defined(_LIBCXX_USE_CLOCK_GET
>>>>>>>>> TIME)
>>>>>>>>> +#if !defined(CLOCK_REALTIME) || !defined(_LIBCPP_USE_CLOCK_GET
>>>>>>>>> TIME)
>>>>>>>>> #include <sys/time.h> // for gettimeofday and timeval
>>>>>>>>> #endif // !defined(CLOCK_REALTIME)
>>>>>>>>> #endif // defined(_LIBCPP_WIN32API)
>>>>>>>>> @@ -92,16 +75,16 @@ system_clock::now() _NOEXCEPT
>>>>>>>>> static_cast<__int64>(ft.dwLowDateTime)};
>>>>>>>>> return time_point(duration_cast<duration>(d -
>>>>>>>>> nt_to_unix_epoch));
>>>>>>>>> #else
>>>>>>>>> -#if defined(_LIBCXX_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
>>>>>>>>> - struct timespec tp;
>>>>>>>>> - if (0 != clock_gettime(CLOCK_REALTIME, &tp))
>>>>>>>>> - __throw_system_error(errno,
>>>>>>>>> "clock_gettime(CLOCK_REALTIME) failed");
>>>>>>>>> - return time_point(seconds(tp.tv_sec) +
>>>>>>>>> microseconds(tp.tv_nsec / 1000));
>>>>>>>>> +#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
>>>>>>>>> + struct timespec tp;
>>>>>>>>> + if (0 != clock_gettime(CLOCK_REALTIME, &tp))
>>>>>>>>> + __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME)
>>>>>>>>> failed");
>>>>>>>>> + return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec
>>>>>>>>> / 1000));
>>>>>>>>> #else
>>>>>>>>> timeval tv;
>>>>>>>>> gettimeofday(&tv, 0);
>>>>>>>>> return time_point(seconds(tv.tv_sec) +
>>>>>>>>> microseconds(tv.tv_usec));
>>>>>>>>> -#endif // _LIBCXX_USE_CLOCK_GETTIME && CLOCK_REALTIME
>>>>>>>>> +#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
>>>>>>>>> #endif
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> @@ -129,7 +112,7 @@ const bool steady_clock::is_steady;
>>>>>>>>> #if defined(__APPLE__)
>>>>>>>>>
>>>>>>>>> // Darwin libc versions >= 1133 provide ns precision via
>>>>>>>>> CLOCK_UPTIME_RAW
>>>>>>>>> -#if defined(_LIBCXX_USE_CLOCK_GETTIME) &&
>>>>>>>>> defined(CLOCK_UPTIME_RAW)
>>>>>>>>> +#if defined(_LIBCPP_USE_CLOCK_GETTIME) &&
>>>>>>>>> defined(CLOCK_UPTIME_RAW)
>>>>>>>>> steady_clock::time_point
>>>>>>>>> steady_clock::now() _NOEXCEPT
>>>>>>>>> {
>>>>>>>>> @@ -191,7 +174,7 @@ steady_clock::now() _NOEXCEPT
>>>>>>>>> static FP fp = init_steady_clock();
>>>>>>>>> return time_point(duration(fp()));
>>>>>>>>> }
>>>>>>>>> -#endif // defined(_LIBCXX_USE_CLOCK_GETTIME) &&
>>>>>>>>> defined(CLOCK_UPTIME_RAW)
>>>>>>>>> +#endif // defined(_LIBCPP_USE_CLOCK_GETTIME) &&
>>>>>>>>> defined(CLOCK_UPTIME_RAW)
>>>>>>>>>
>>>>>>>>> #elif defined(_LIBCPP_WIN32API)
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Modified: libcxx/trunk/src/experimental/
>>>>>>>>> filesystem/filesystem_common.h
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/experim
>>>>>>>>> ental/filesystem/filesystem_common.h?rev=337960&r1=337959&
>>>>>>>>> r2=337960&view=diff
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/src/experimental/filesystem/filesystem_common.h
>>>>>>>>> (original)
>>>>>>>>> +++ libcxx/trunk/src/experimental/filesystem/filesystem_common.h
>>>>>>>>> Wed Jul 25 13:51:49 2018
>>>>>>>>> @@ -23,33 +23,17 @@
>>>>>>>>>
>>>>>>>>> #include <experimental/filesystem>
>>>>>>>>>
>>>>>>>>> -#if (__APPLE__)
>>>>>>>>> -#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
>>>>>>>>> -#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101300
>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>> -#endif
>>>>>>>>> -#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> -#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110000
>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>> -#endif
>>>>>>>>> -#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> -#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 110000
>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>> -#endif
>>>>>>>>> -#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> -#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 40000
>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>> -#endif
>>>>>>>>> -#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
>>>>>>>>> -#else
>>>>>>>>> +#include "../../include/apple_availability.h"
>>>>>>>>> +
>>>>>>>>> +#if !defined(__APPLE__)
>>>>>>>>> // We can use the presence of UTIME_OMIT to detect platforms that
>>>>>>>>> provide
>>>>>>>>> // utimensat.
>>>>>>>>> #if defined(UTIME_OMIT)
>>>>>>>>> -#define _LIBCXX_USE_UTIMENSAT
>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>> +#endif
>>>>>>>>> #endif
>>>>>>>>> -#endif // __APPLE__
>>>>>>>>>
>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>> +#if !defined(_LIBCPP_USE_UTIMENSAT)
>>>>>>>>> #include <sys/time.h> // for ::utimes as used in __last_write_time
>>>>>>>>> #endif
>>>>>>>>>
>>>>>>>>> @@ -212,76 +196,119 @@ private:
>>>>>>>>> ErrorHandler& operator=(ErrorHandler const&) = delete;
>>>>>>>>> };
>>>>>>>>>
>>>>>>>>> -namespace time_util {
>>>>>>>>> +using chrono::duration;
>>>>>>>>> +using chrono::duration_cast;
>>>>>>>>>
>>>>>>>>> -using namespace chrono;
>>>>>>>>> +using TimeSpec = struct ::timespec;
>>>>>>>>> +using StatT = struct ::stat;
>>>>>>>>>
>>>>>>>>> -template <class FileTimeT,
>>>>>>>>> +template <class FileTimeT, class TimeT,
>>>>>>>>> bool IsFloat = is_floating_point<typename
>>>>>>>>> FileTimeT::rep>::value>
>>>>>>>>> -struct fs_time_util_base {
>>>>>>>>> - static constexpr seconds::rep max_seconds =
>>>>>>>>> - duration_cast<seconds>(FileTimeT::duration::max()).count();
>>>>>>>>> -
>>>>>>>>> - static constexpr nanoseconds::rep max_nsec =
>>>>>>>>> - duration_cast<nanoseconds>(FileTimeT::duration::max() -
>>>>>>>>> - seconds(max_seconds))
>>>>>>>>> +struct time_util_base {
>>>>>>>>> + using rep = typename FileTimeT::rep;
>>>>>>>>> + using fs_duration = typename FileTimeT::duration;
>>>>>>>>> + using fs_seconds = duration<rep>;
>>>>>>>>> + using fs_nanoseconds = duration<rep, nano>;
>>>>>>>>> + using fs_microseconds = duration<rep, micro>;
>>>>>>>>> +
>>>>>>>>> + static constexpr rep max_seconds =
>>>>>>>>> + duration_cast<fs_seconds>(File
>>>>>>>>> TimeT::duration::max()).count();
>>>>>>>>> +
>>>>>>>>> + static constexpr rep max_nsec =
>>>>>>>>> + duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
>>>>>>>>> + fs_seconds(max_seconds))
>>>>>>>>> .count();
>>>>>>>>>
>>>>>>>>> - static constexpr seconds::rep min_seconds =
>>>>>>>>> - duration_cast<seconds>(FileTimeT::duration::min()).count();
>>>>>>>>> + static constexpr rep min_seconds =
>>>>>>>>> + duration_cast<fs_seconds>(File
>>>>>>>>> TimeT::duration::min()).count();
>>>>>>>>>
>>>>>>>>> - static constexpr nanoseconds::rep min_nsec_timespec =
>>>>>>>>> - duration_cast<nanoseconds>(
>>>>>>>>> - (FileTimeT::duration::min() - seconds(min_seconds)) +
>>>>>>>>> seconds(1))
>>>>>>>>> + static constexpr rep min_nsec_timespec =
>>>>>>>>> + duration_cast<fs_nanoseconds>(
>>>>>>>>> + (FileTimeT::duration::min() - fs_seconds(min_seconds)) +
>>>>>>>>> + fs_seconds(1))
>>>>>>>>> .count();
>>>>>>>>>
>>>>>>>>> +private:
>>>>>>>>> +#if _LIBCPP_STD_VER > 11
>>>>>>>>> + static constexpr fs_duration get_min_nsecs() {
>>>>>>>>> + return duration_cast<fs_duration>(
>>>>>>>>> + fs_nanoseconds(min_nsec_timespec) -
>>>>>>>>> + duration_cast<fs_nanoseconds>(fs_seconds(1)));
>>>>>>>>> + }
>>>>>>>>> // Static assert that these values properly round trip.
>>>>>>>>> - static_assert((seconds(min_seconds) +
>>>>>>>>> - duration_cast<microseconds>(n
>>>>>>>>> anoseconds(min_nsec_timespec))) -
>>>>>>>>> - duration_cast<microseconds>(seconds(1))
>>>>>>>>> ==
>>>>>>>>> + static_assert(fs_seconds(min_seconds) + get_min_nsecs() ==
>>>>>>>>> FileTimeT::duration::min(),
>>>>>>>>> - "");
>>>>>>>>> + "value doesn't roundtrip");
>>>>>>>>> +
>>>>>>>>> + static constexpr bool check_range() {
>>>>>>>>> + // This kinda sucks, but it's what happens when we don't have
>>>>>>>>> __int128_t.
>>>>>>>>> + if (sizeof(TimeT) == sizeof(rep)) {
>>>>>>>>> + typedef duration<long long, ratio<3600 * 24 * 365> > Years;
>>>>>>>>> + return duration_cast<Years>(fs_seconds(max_seconds)) >
>>>>>>>>> Years(250) &&
>>>>>>>>> + duration_cast<Years>(fs_seconds(min_seconds)) <
>>>>>>>>> Years(-250);
>>>>>>>>> + }
>>>>>>>>> + return max_seconds >= numeric_limits<TimeT>::max() &&
>>>>>>>>> + min_seconds <= numeric_limits<TimeT>::min();
>>>>>>>>> + }
>>>>>>>>> + static_assert(check_range(), "the representable range is
>>>>>>>>> unacceptable small");
>>>>>>>>> +#endif
>>>>>>>>> };
>>>>>>>>>
>>>>>>>>> -template <class FileTimeT>
>>>>>>>>> -struct fs_time_util_base<FileTimeT, true> {
>>>>>>>>> - static const long long max_seconds;
>>>>>>>>> - static const long long max_nsec;
>>>>>>>>> - static const long long min_seconds;
>>>>>>>>> - static const long long min_nsec_timespec;
>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>> +struct time_util_base<FileTimeT, TimeT, true> {
>>>>>>>>> + using rep = typename FileTimeT::rep;
>>>>>>>>> + using fs_duration = typename FileTimeT::duration;
>>>>>>>>> + using fs_seconds = duration<rep>;
>>>>>>>>> + using fs_nanoseconds = duration<rep, nano>;
>>>>>>>>> + using fs_microseconds = duration<rep, micro>;
>>>>>>>>> +
>>>>>>>>> + static const rep max_seconds;
>>>>>>>>> + static const rep max_nsec;
>>>>>>>>> + static const rep min_seconds;
>>>>>>>>> + static const rep min_nsec_timespec;
>>>>>>>>> };
>>>>>>>>>
>>>>>>>>> -template <class FileTimeT>
>>>>>>>>> -const long long fs_time_util_base<FileTimeT, true>::max_seconds =
>>>>>>>>> - duration_cast<seconds>(FileTimeT::duration::max()).count();
>>>>>>>>> -
>>>>>>>>> -template <class FileTimeT>
>>>>>>>>> -const long long fs_time_util_base<FileTimeT, true>::max_nsec =
>>>>>>>>> - duration_cast<nanoseconds>(FileTimeT::duration::max() -
>>>>>>>>> - seconds(max_seconds))
>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>> +const typename FileTimeT::rep
>>>>>>>>> + time_util_base<FileTimeT, TimeT, true>::max_seconds =
>>>>>>>>> + duration_cast<fs_seconds>(File
>>>>>>>>> TimeT::duration::max()).count();
>>>>>>>>> +
>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>> +const typename FileTimeT::rep time_util_base<FileTimeT, TimeT,
>>>>>>>>> true>::max_nsec =
>>>>>>>>> + duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
>>>>>>>>> + fs_seconds(max_seconds))
>>>>>>>>> .count();
>>>>>>>>>
>>>>>>>>> -template <class FileTimeT>
>>>>>>>>> -const long long fs_time_util_base<FileTimeT, true>::min_seconds =
>>>>>>>>> - duration_cast<seconds>(FileTimeT::duration::min()).count();
>>>>>>>>> -
>>>>>>>>> -template <class FileTimeT>
>>>>>>>>> -const long long fs_time_util_base<FileTimeT,
>>>>>>>>> true>::min_nsec_timespec =
>>>>>>>>> - duration_cast<nanoseconds>(
>>>>>>>>> - (FileTimeT::duration::min() - seconds(min_seconds)) +
>>>>>>>>> seconds(1))
>>>>>>>>> - .count();
>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>> +const typename FileTimeT::rep
>>>>>>>>> + time_util_base<FileTimeT, TimeT, true>::min_seconds =
>>>>>>>>> + duration_cast<fs_seconds>(File
>>>>>>>>> TimeT::duration::min()).count();
>>>>>>>>> +
>>>>>>>>> +template <class FileTimeT, class TimeT>
>>>>>>>>> +const typename FileTimeT::rep
>>>>>>>>> + time_util_base<FileTimeT, TimeT, true>::min_nsec_timespec =
>>>>>>>>> + duration_cast<fs_nanoseconds>((FileTimeT::duration::min()
>>>>>>>>> -
>>>>>>>>> + fs_seconds(min_seconds)) +
>>>>>>>>> + fs_seconds(1))
>>>>>>>>> + .count();
>>>>>>>>>
>>>>>>>>> template <class FileTimeT, class TimeT, class TimeSpecT>
>>>>>>>>> -struct fs_time_util : fs_time_util_base<FileTimeT> {
>>>>>>>>> - using Base = fs_time_util_base<FileTimeT>;
>>>>>>>>> +struct time_util : time_util_base<FileTimeT, TimeT> {
>>>>>>>>> + using Base = time_util_base<FileTimeT, TimeT>;
>>>>>>>>> using Base::max_nsec;
>>>>>>>>> using Base::max_seconds;
>>>>>>>>> using Base::min_nsec_timespec;
>>>>>>>>> using Base::min_seconds;
>>>>>>>>>
>>>>>>>>> + using typename Base::fs_duration;
>>>>>>>>> + using typename Base::fs_microseconds;
>>>>>>>>> + using typename Base::fs_nanoseconds;
>>>>>>>>> + using typename Base::fs_seconds;
>>>>>>>>> +
>>>>>>>>> public:
>>>>>>>>> template <class CType, class ChronoType>
>>>>>>>>> - static bool checked_set(CType* out, ChronoType time) {
>>>>>>>>> + static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool checked_set(CType*
>>>>>>>>> out,
>>>>>>>>> +
>>>>>>>>> ChronoType time) {
>>>>>>>>> using Lim = numeric_limits<CType>;
>>>>>>>>> if (time > Lim::max() || time < Lim::min())
>>>>>>>>> return false;
>>>>>>>>> @@ -291,21 +318,21 @@ public:
>>>>>>>>>
>>>>>>>>> static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>> is_representable(TimeSpecT tm) {
>>>>>>>>> if (tm.tv_sec >= 0) {
>>>>>>>>> - return (tm.tv_sec < max_seconds) ||
>>>>>>>>> + return tm.tv_sec < max_seconds ||
>>>>>>>>> (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
>>>>>>>>> } else if (tm.tv_sec == (min_seconds - 1)) {
>>>>>>>>> return tm.tv_nsec >= min_nsec_timespec;
>>>>>>>>> } else {
>>>>>>>>> - return (tm.tv_sec >= min_seconds);
>>>>>>>>> + return tm.tv_sec >= min_seconds;
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>> is_representable(FileTimeT tm) {
>>>>>>>>> - auto secs = duration_cast<seconds>(tm.time_since_epoch());
>>>>>>>>> - auto nsecs = duration_cast<nanoseconds>(tm.time_since_epoch()
>>>>>>>>> - secs);
>>>>>>>>> + auto secs = duration_cast<fs_seconds>(tm.time_since_epoch());
>>>>>>>>> + auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch()
>>>>>>>>> - secs);
>>>>>>>>> if (nsecs.count() < 0) {
>>>>>>>>> - secs = secs + seconds(1);
>>>>>>>>> - nsecs = nsecs + seconds(1);
>>>>>>>>> + secs = secs + fs_seconds(1);
>>>>>>>>> + nsecs = nsecs + fs_seconds(1);
>>>>>>>>> }
>>>>>>>>> using TLim = numeric_limits<TimeT>;
>>>>>>>>> if (secs.count() >= 0)
>>>>>>>>> @@ -314,49 +341,45 @@ public:
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> static _LIBCPP_CONSTEXPR_AFTER_CXX11 FileTimeT
>>>>>>>>> - convert_timespec(TimeSpecT tm) {
>>>>>>>>> - auto adj_msec = duration_cast<microseconds>(na
>>>>>>>>> noseconds(tm.tv_nsec));
>>>>>>>>> - if (tm.tv_sec >= 0) {
>>>>>>>>> - auto Dur = seconds(tm.tv_sec) + microseconds(adj_msec);
>>>>>>>>> - return FileTimeT(Dur);
>>>>>>>>> - } else if (duration_cast<microseconds>(n
>>>>>>>>> anoseconds(tm.tv_nsec)).count() ==
>>>>>>>>> - 0) {
>>>>>>>>> - return FileTimeT(seconds(tm.tv_sec));
>>>>>>>>> + convert_from_timespec(TimeSpecT tm) {
>>>>>>>>> + if (tm.tv_sec >= 0 || tm.tv_nsec == 0) {
>>>>>>>>> + return FileTimeT(fs_seconds(tm.tv_sec) +
>>>>>>>>> + duration_cast<fs_duration>(fs
>>>>>>>>> _nanoseconds(tm.tv_nsec)));
>>>>>>>>> } else { // tm.tv_sec < 0
>>>>>>>>> - auto adj_subsec =
>>>>>>>>> - duration_cast<microseconds>(seconds(1) -
>>>>>>>>> nanoseconds(tm.tv_nsec));
>>>>>>>>> - auto Dur = seconds(tm.tv_sec + 1) - adj_subsec;
>>>>>>>>> + auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1)
>>>>>>>>> -
>>>>>>>>> +
>>>>>>>>> fs_nanoseconds(tm.tv_nsec));
>>>>>>>>> + auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec;
>>>>>>>>> return FileTimeT(Dur);
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> - template <class SubSecDurT, class SubSecT>
>>>>>>>>> - static bool set_times_checked(TimeT* sec_out, SubSecT*
>>>>>>>>> subsec_out,
>>>>>>>>> - FileTimeT tp) {
>>>>>>>>> + template <class SubSecT>
>>>>>>>>> + static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>> + set_times_checked(TimeT* sec_out, SubSecT* subsec_out,
>>>>>>>>> FileTimeT tp) {
>>>>>>>>> auto dur = tp.time_since_epoch();
>>>>>>>>> - auto sec_dur = duration_cast<seconds>(dur);
>>>>>>>>> - auto subsec_dur = duration_cast<SubSecDurT>(dur - sec_dur);
>>>>>>>>> + auto sec_dur = duration_cast<fs_seconds>(dur);
>>>>>>>>> + auto subsec_dur = duration_cast<fs_nanoseconds>(dur -
>>>>>>>>> sec_dur);
>>>>>>>>> // The tv_nsec and tv_usec fields must not be negative so
>>>>>>>>> adjust accordingly
>>>>>>>>> if (subsec_dur.count() < 0) {
>>>>>>>>> if (sec_dur.count() > min_seconds) {
>>>>>>>>> - sec_dur -= seconds(1);
>>>>>>>>> - subsec_dur += seconds(1);
>>>>>>>>> + sec_dur -= fs_seconds(1);
>>>>>>>>> + subsec_dur += fs_seconds(1);
>>>>>>>>> } else {
>>>>>>>>> - subsec_dur = SubSecDurT::zero();
>>>>>>>>> + subsec_dur = fs_nanoseconds::zero();
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> return checked_set(sec_out, sec_dur.count()) &&
>>>>>>>>> checked_set(subsec_out, subsec_dur.count());
>>>>>>>>> }
>>>>>>>>> + static _LIBCPP_CONSTEXPR_AFTER_CXX11 bool
>>>>>>>>> convert_to_timespec(TimeSpecT& dest,
>>>>>>>>> +
>>>>>>>>> FileTimeT tp) {
>>>>>>>>> + if (!is_representable(tp))
>>>>>>>>> + return false;
>>>>>>>>> + return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp);
>>>>>>>>> + }
>>>>>>>>> };
>>>>>>>>>
>>>>>>>>> -} // namespace time_util
>>>>>>>>> -
>>>>>>>>> -
>>>>>>>>> -using TimeSpec = struct ::timespec;
>>>>>>>>> -using StatT = struct ::stat;
>>>>>>>>> -
>>>>>>>>> -using FSTime = time_util::fs_time_util<file_time_type, time_t,
>>>>>>>>> struct timespec>;
>>>>>>>>> +using fs_time = time_util<file_time_type, time_t, TimeSpec>;
>>>>>>>>>
>>>>>>>>> #if defined(__APPLE__)
>>>>>>>>> TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec;
>>>>>>>>> }
>>>>>>>>> @@ -366,20 +389,18 @@ TimeSpec extract_mtime(StatT const& st)
>>>>>>>>> TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
>>>>>>>>> #endif
>>>>>>>>>
>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>> -using TimeStruct = struct ::timeval;
>>>>>>>>> -using TimeStructArray = TimeStruct[2];
>>>>>>>>> -#else
>>>>>>>>> -using TimeStruct = TimeSpec;
>>>>>>>>> -using TimeStructArray = TimeStruct[2];
>>>>>>>>> -#endif
>>>>>>>>> -
>>>>>>>>> -bool SetFileTimes(const path& p, TimeStructArray const& TS,
>>>>>>>>> - error_code& ec) {
>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>> - if (::utimes(p.c_str(), TS) == -1)
>>>>>>>>> +bool set_file_times(const path& p, std::array<TimeSpec, 2> const&
>>>>>>>>> TS,
>>>>>>>>> + error_code& ec) {
>>>>>>>>> +#if !defined(_LIBCPP_USE_UTIMENSAT)
>>>>>>>>> + using namespace chrono;
>>>>>>>>> + auto Convert = [](long nsec) {
>>>>>>>>> + return duration_cast<microseconds>(na
>>>>>>>>> noseconds(nsec)).count();
>>>>>>>>> + };
>>>>>>>>> + struct ::timeval ConvertedTS[2] = {{TS[0].tv_sec,
>>>>>>>>> Convert(TS[0].tv_nsec)},
>>>>>>>>> + {TS[1].tv_sec,
>>>>>>>>> Convert(TS[1].tv_nsec)}};
>>>>>>>>>
>>>>>>>>
>>>>>>>> This causes the '-Wc++11-narrowing' warning on Darwin:
>>>>>>>>
>>>>>>>> filesystem_common.h:399:53: error: non-constant-expression cannot
>>>>>>>> be narrowed from type 'long long' to '__darwin_suseconds_t' (aka 'int') in
>>>>>>>> initializer list [-Wc++11-narrowing] struct ::timeval ConvertedTS[2] =
>>>>>>>> {{TS[0].tv_sec, Convert(TS[0].tv_nsec)}, ^~~~~~~~~~~~~~~~~~~~~~
>>>>>>>> I'll work on a fix commit.
>>>>>>>>
>>>>>>>>
>>>>>>>>> + if (::utimes(p.c_str(), ConvertedTS) == -1)
>>>>>>>>> #else
>>>>>>>>> - if (::utimensat(AT_FDCWD, p.c_str(), TS, 0) == -1)
>>>>>>>>> + if (::utimensat(AT_FDCWD, p.c_str(), TS.data(), 0) == -1)
>>>>>>>>> #endif
>>>>>>>>> {
>>>>>>>>> ec = capture_errno();
>>>>>>>>> @@ -388,25 +409,9 @@ bool SetFileTimes(const path& p, TimeStr
>>>>>>>>> return false;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> -void SetTimeStructTo(TimeStruct& TS, TimeSpec ToTS) {
>>>>>>>>> - using namespace chrono;
>>>>>>>>> - TS.tv_sec = ToTS.tv_sec;
>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>> - TS.tv_usec = duration_cast<microseconds>(na
>>>>>>>>> noseconds(ToTS.tv_nsec)).count();
>>>>>>>>> -#else
>>>>>>>>> - TS.tv_nsec = ToTS.tv_nsec;
>>>>>>>>> -#endif
>>>>>>>>> -}
>>>>>>>>> -
>>>>>>>>> -bool SetTimeStructTo(TimeStruct& TS, file_time_type NewTime) {
>>>>>>>>> - using namespace chrono;
>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>> - return !FSTime::set_times_checked<microseconds>(&TS.tv_sec,
>>>>>>>>> &TS.tv_usec,
>>>>>>>>> - NewTime);
>>>>>>>>> -#else
>>>>>>>>> - return !FSTime::set_times_checked<nanoseconds>(&TS.tv_sec,
>>>>>>>>> &TS.tv_nsec,
>>>>>>>>> - NewTime);
>>>>>>>>> -#endif
>>>>>>>>> +bool set_time_spec_to(TimeSpec& TS, file_time_type NewTime) {
>>>>>>>>> + return !fs_time::set_times_checked(
>>>>>>>>> + &TS.tv_sec, &TS.tv_nsec, NewTime);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> } // namespace
>>>>>>>>>
>>>>>>>>> Modified: libcxx/trunk/src/experimental/filesystem/operations.cpp
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/experim
>>>>>>>>> ental/filesystem/operations.cpp?rev=337960&r1=337959&r2=
>>>>>>>>> 337960&view=diff
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/src/experimental/filesystem/operations.cpp
>>>>>>>>> (original)
>>>>>>>>> +++ libcxx/trunk/src/experimental/filesystem/operations.cpp Wed
>>>>>>>>> Jul 25 13:51:49 2018
>>>>>>>>> @@ -23,6 +23,7 @@
>>>>>>>>> #include <unistd.h>
>>>>>>>>> #include <sys/stat.h>
>>>>>>>>> #include <sys/statvfs.h>
>>>>>>>>> +#include <time.h>
>>>>>>>>> #include <fcntl.h> /* values for fchmodat */
>>>>>>>>>
>>>>>>>>> #if defined(__linux__)
>>>>>>>>> @@ -36,6 +37,14 @@
>>>>>>>>> # define _LIBCPP_USE_COPYFILE
>>>>>>>>> #endif
>>>>>>>>>
>>>>>>>>> +#if !defined(__APPLE__)
>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>> +#endif
>>>>>>>>> +
>>>>>>>>> +#if !defined(CLOCK_REALTIME) || !defined(_LIBCPP_USE_CLOCK_GET
>>>>>>>>> TIME)
>>>>>>>>> +#include <sys/time.h> // for gettimeofday and timeval
>>>>>>>>> +#endif // !defined(CLOCK_REALTIME)
>>>>>>>>> +
>>>>>>>>> #if defined(_LIBCPP_COMPILER_GCC)
>>>>>>>>> #if _GNUC_VER < 500
>>>>>>>>> #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
>>>>>>>>> @@ -44,9 +53,6 @@
>>>>>>>>>
>>>>>>>>> _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
>>>>>>>>>
>>>>>>>>> -filesystem_error::~filesystem_error() {}
>>>>>>>>> -
>>>>>>>>> -
>>>>>>>>> namespace { namespace parser
>>>>>>>>> {
>>>>>>>>>
>>>>>>>>> @@ -355,7 +361,7 @@ private:
>>>>>>>>> explicit FileDescriptor(const path* p, int fd = -1) : name(*p),
>>>>>>>>> fd(fd) {}
>>>>>>>>> };
>>>>>>>>>
>>>>>>>>> -perms posix_get_perms(const struct ::stat& st) noexcept {
>>>>>>>>> +perms posix_get_perms(const StatT& st) noexcept {
>>>>>>>>> return static_cast<perms>(st.st_mode) & perms::mask;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> @@ -364,8 +370,7 @@ perms posix_get_perms(const struct ::sta
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> file_status create_file_status(error_code& m_ec, path const& p,
>>>>>>>>> - const struct ::stat& path_stat,
>>>>>>>>> - error_code* ec) {
>>>>>>>>> + const StatT& path_stat,
>>>>>>>>> error_code* ec) {
>>>>>>>>> if (ec)
>>>>>>>>> *ec = m_ec;
>>>>>>>>> if (m_ec && (m_ec.value() == ENOENT || m_ec.value() ==
>>>>>>>>> ENOTDIR)) {
>>>>>>>>> @@ -400,8 +405,7 @@ file_status create_file_status(error_cod
>>>>>>>>> return fs_tmp;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> -file_status posix_stat(path const& p, struct ::stat& path_stat,
>>>>>>>>> - error_code* ec) {
>>>>>>>>> +file_status posix_stat(path const& p, StatT& path_stat,
>>>>>>>>> error_code* ec) {
>>>>>>>>> error_code m_ec;
>>>>>>>>> if (::stat(p.c_str(), &path_stat) == -1)
>>>>>>>>> m_ec = detail::capture_errno();
>>>>>>>>> @@ -409,12 +413,11 @@ file_status posix_stat(path const& p, st
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> file_status posix_stat(path const& p, error_code* ec) {
>>>>>>>>> - struct ::stat path_stat;
>>>>>>>>> + StatT path_stat;
>>>>>>>>> return posix_stat(p, path_stat, ec);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> -file_status posix_lstat(path const& p, struct ::stat& path_stat,
>>>>>>>>> - error_code* ec) {
>>>>>>>>> +file_status posix_lstat(path const& p, StatT& path_stat,
>>>>>>>>> error_code* ec) {
>>>>>>>>> error_code m_ec;
>>>>>>>>> if (::lstat(p.c_str(), &path_stat) == -1)
>>>>>>>>> m_ec = detail::capture_errno();
>>>>>>>>> @@ -422,7 +425,7 @@ file_status posix_lstat(path const& p, s
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> file_status posix_lstat(path const& p, error_code* ec) {
>>>>>>>>> - struct ::stat path_stat;
>>>>>>>>> + StatT path_stat;
>>>>>>>>> return posix_lstat(p, path_stat, ec);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> @@ -464,10 +467,32 @@ file_status FileDescriptor::refresh_stat
>>>>>>>>> using detail::capture_errno;
>>>>>>>>> using detail::ErrorHandler;
>>>>>>>>> using detail::StatT;
>>>>>>>>> +using detail::TimeSpec;
>>>>>>>>> using parser::createView;
>>>>>>>>> using parser::PathParser;
>>>>>>>>> using parser::string_view_t;
>>>>>>>>>
>>>>>>>>> +const bool _FilesystemClock::is_steady;
>>>>>>>>> +
>>>>>>>>> +_FilesystemClock::time_point _FilesystemClock::now() noexcept {
>>>>>>>>> + typedef chrono::duration<rep> __secs;
>>>>>>>>> +#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
>>>>>>>>> + typedef chrono::duration<rep, nano> __nsecs;
>>>>>>>>> + struct timespec tp;
>>>>>>>>> + if (0 != clock_gettime(CLOCK_REALTIME, &tp))
>>>>>>>>> + __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME)
>>>>>>>>> failed");
>>>>>>>>> + return time_point(__secs(tp.tv_sec) +
>>>>>>>>> + chrono::duration_cast<duration
>>>>>>>>> >(__nsecs(tp.tv_nsec)));
>>>>>>>>> +#else
>>>>>>>>> + typedef chrono::duration<rep, micro> __microsecs;
>>>>>>>>> + timeval tv;
>>>>>>>>> + gettimeofday(&tv, 0);
>>>>>>>>> + return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
>>>>>>>>> +#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +filesystem_error::~filesystem_error() {}
>>>>>>>>> +
>>>>>>>>> void filesystem_error::__create_what(int __num_paths) {
>>>>>>>>> const char* derived_what = system_error::what();
>>>>>>>>> __storage_->__what_ = [&]() -> string {
>>>>>>>>> @@ -525,14 +550,14 @@ void __copy(const path& from, const path
>>>>>>>>> const bool sym_status2 = bool(options &
>>>>>>>>> copy_options::copy_symlinks);
>>>>>>>>>
>>>>>>>>> error_code m_ec1;
>>>>>>>>> - struct ::stat f_st = {};
>>>>>>>>> + StatT f_st = {};
>>>>>>>>> const file_status f = sym_status || sym_status2
>>>>>>>>> ? detail::posix_lstat(from, f_st,
>>>>>>>>> &m_ec1)
>>>>>>>>> : detail::posix_stat(from, f_st,
>>>>>>>>> &m_ec1);
>>>>>>>>> if (m_ec1)
>>>>>>>>> return err.report(m_ec1);
>>>>>>>>>
>>>>>>>>> - struct ::stat t_st = {};
>>>>>>>>> + StatT t_st = {};
>>>>>>>>> const file_status t = sym_status ? detail::posix_lstat(to,
>>>>>>>>> t_st, &m_ec1)
>>>>>>>>> : detail::posix_stat(to, t_st,
>>>>>>>>> &m_ec1);
>>>>>>>>>
>>>>>>>>> @@ -916,7 +941,7 @@ uintmax_t __file_size(const path& p, err
>>>>>>>>> ErrorHandler<uintmax_t> err("file_size", ec, &p);
>>>>>>>>>
>>>>>>>>> error_code m_ec;
>>>>>>>>> - struct ::stat st;
>>>>>>>>> + StatT st;
>>>>>>>>> file_status fst = detail::posix_stat(p, st, &m_ec);
>>>>>>>>> if (!exists(fst) || !is_regular_file(fst)) {
>>>>>>>>> errc error_kind =
>>>>>>>>> @@ -966,14 +991,14 @@ bool __fs_is_empty(const path& p, error_
>>>>>>>>>
>>>>>>>>> static file_time_type __extract_last_write_time(const path& p,
>>>>>>>>> const StatT& st,
>>>>>>>>> error_code* ec) {
>>>>>>>>> - using detail::FSTime;
>>>>>>>>> + using detail::fs_time;
>>>>>>>>> ErrorHandler<file_time_type> err("last_write_time", ec, &p);
>>>>>>>>>
>>>>>>>>> auto ts = detail::extract_mtime(st);
>>>>>>>>> - if (!FSTime::is_representable(ts))
>>>>>>>>> + if (!fs_time::is_representable(ts))
>>>>>>>>> return err.report(errc::value_too_large);
>>>>>>>>>
>>>>>>>>> - return FSTime::convert_timespec(ts);
>>>>>>>>> + return fs_time::convert_from_timespec(ts);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> file_time_type __last_write_time(const path& p, error_code *ec)
>>>>>>>>> @@ -992,30 +1017,27 @@ file_time_type __last_write_time(const p
>>>>>>>>> void __last_write_time(const path& p, file_time_type new_time,
>>>>>>>>> error_code *ec)
>>>>>>>>> {
>>>>>>>>> - using namespace chrono;
>>>>>>>>> - using namespace detail;
>>>>>>>>> -
>>>>>>>>> ErrorHandler<void> err("last_write_time", ec, &p);
>>>>>>>>>
>>>>>>>>> error_code m_ec;
>>>>>>>>> - TimeStructArray tbuf;
>>>>>>>>> -#if !defined(_LIBCXX_USE_UTIMENSAT)
>>>>>>>>> + array<TimeSpec, 2> tbuf;
>>>>>>>>> +#if !defined(_LIBCPP_USE_UTIMENSAT)
>>>>>>>>> // This implementation has a race condition between
>>>>>>>>> determining the
>>>>>>>>> // last access time and attempting to set it to the same
>>>>>>>>> value using
>>>>>>>>> // ::utimes
>>>>>>>>> - struct ::stat st;
>>>>>>>>> + StatT st;
>>>>>>>>> file_status fst = detail::posix_stat(p, st, &m_ec);
>>>>>>>>> - if (m_ec && !status_known(fst))
>>>>>>>>> + if (m_ec)
>>>>>>>>> return err.report(m_ec);
>>>>>>>>> - SetTimeStructTo(tbuf[0], detail::extract_atime(st));
>>>>>>>>> + tbuf[0] = detail::extract_atime(st);
>>>>>>>>> #else
>>>>>>>>> tbuf[0].tv_sec = 0;
>>>>>>>>> tbuf[0].tv_nsec = UTIME_OMIT;
>>>>>>>>> #endif
>>>>>>>>> - if (SetTimeStructTo(tbuf[1], new_time))
>>>>>>>>> - return err.report(errc::invalid_argument);
>>>>>>>>> + if (detail::set_time_spec_to(tbuf[1], new_time))
>>>>>>>>> + return err.report(errc::value_too_large);
>>>>>>>>>
>>>>>>>>> - SetFileTimes(p, tbuf, m_ec);
>>>>>>>>> + detail::set_file_times(p, tbuf, m_ec);
>>>>>>>>> if (m_ec)
>>>>>>>>> return err.report(m_ec);
>>>>>>>>> }
>>>>>>>>> @@ -1591,7 +1613,7 @@ error_code directory_entry::__do_refresh
>>>>>>>>> __data_.__reset();
>>>>>>>>> error_code failure_ec;
>>>>>>>>>
>>>>>>>>> - struct ::stat full_st;
>>>>>>>>> + StatT full_st;
>>>>>>>>> file_status st = detail::posix_lstat(__p_, full_st,
>>>>>>>>> &failure_ec);
>>>>>>>>> if (!status_known(st)) {
>>>>>>>>> __data_.__reset();
>>>>>>>>>
>>>>>>>>> Added: libcxx/trunk/src/include/apple_availability.h
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/include
>>>>>>>>> /apple_availability.h?rev=337960&view=auto
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/src/include/apple_availability.h (added)
>>>>>>>>> +++ libcxx/trunk/src/include/apple_availability.h Wed Jul 25
>>>>>>>>> 13:51:49 2018
>>>>>>>>> @@ -0,0 +1,52 @@
>>>>>>>>> +//===------------------------ apple_availability.h
>>>>>>>>> ------------------------===//
>>>>>>>>> +//
>>>>>>>>> +// The LLVM Compiler Infrastructure
>>>>>>>>> +//
>>>>>>>>> +// This file is dual licensed under the MIT and the University of
>>>>>>>>> Illinois Open
>>>>>>>>> +// Source Licenses. See LICENSE.TXT for details.
>>>>>>>>> +//
>>>>>>>>> +//===------------------------------------------------------
>>>>>>>>> ----------------===//
>>>>>>>>> +#ifndef _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
>>>>>>>>> +#define _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
>>>>>>>>> +
>>>>>>>>> +#if defined(__APPLE__)
>>>>>>>>> +
>>>>>>>>> +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
>>>>>>>>> +#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101300
>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>> +#endif
>>>>>>>>> +#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> +#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110000
>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>> +#endif
>>>>>>>>> +#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> +#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 110000
>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>> +#endif
>>>>>>>>> +#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> +#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 40000
>>>>>>>>> +#define _LIBCPP_USE_UTIMENSAT
>>>>>>>>> +#endif
>>>>>>>>> +#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
>>>>>>>>> +
>>>>>>>>> +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
>>>>>>>>> +#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>> +#endif
>>>>>>>>> +#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> +#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 100000
>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>> +#endif
>>>>>>>>> +#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> +#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 100000
>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>> +#endif
>>>>>>>>> +#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
>>>>>>>>> +#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 30000
>>>>>>>>> +#define _LIBCPP_USE_CLOCK_GETTIME
>>>>>>>>> +#endif
>>>>>>>>> +#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
>>>>>>>>> +
>>>>>>>>> +#endif // __APPLE__
>>>>>>>>> +
>>>>>>>>> +#endif // _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
>>>>>>>>>
>>>>>>>>> Modified: libcxx/trunk/test/libcxx/exper
>>>>>>>>> imental/filesystem/class.directory_entry/directory_entry.
>>>>>>>>> mods/last_write_time.sh.cpp
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx
>>>>>>>>> /experimental/filesystem/class.directory_entry/
>>>>>>>>> directory_entry.mods/last_write_time.sh.cpp?rev=337960&
>>>>>>>>> r1=337959&r2=337960&view=diff
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/test/libcxx/experimental/filesystem/class.direc
>>>>>>>>> tory_entry/directory_entry.mods/last_write_time.sh.cpp (original)
>>>>>>>>> +++ libcxx/trunk/test/libcxx/experimental/filesystem/class.direc
>>>>>>>>> tory_entry/directory_entry.mods/last_write_time.sh.cpp Wed Jul 25
>>>>>>>>> 13:51:49 2018
>>>>>>>>> @@ -41,9 +41,7 @@ TEST_CASE(last_write_time_not_representa
>>>>>>>>> ToTime.tv_sec = std::numeric_limits<decltype(T
>>>>>>>>> oTime.tv_sec)>::max();
>>>>>>>>> ToTime.tv_nsec = duration_cast<nanoseconds>(seconds(1)).count()
>>>>>>>>> - 1;
>>>>>>>>>
>>>>>>>>> - TimeStructArray TS;
>>>>>>>>> - SetTimeStructTo(TS[0], ToTime);
>>>>>>>>> - SetTimeStructTo(TS[1], ToTime);
>>>>>>>>> + std::array<TimeSpec, 2> TS = {ToTime, ToTime};
>>>>>>>>>
>>>>>>>>> file_time_type old_time = last_write_time(file);
>>>>>>>>> directory_entry ent(file);
>>>>>>>>> @@ -57,9 +55,7 @@ TEST_CASE(last_write_time_not_representa
>>>>>>>>> file_time_type rep_value;
>>>>>>>>> {
>>>>>>>>> std::error_code ec;
>>>>>>>>> - if (SetFileTimes(file, TS, ec)) {
>>>>>>>>> - TEST_REQUIRE(false && "unsupported");
>>>>>>>>> - }
>>>>>>>>> + TEST_REQUIRE(!set_file_times(file, TS, ec));
>>>>>>>>> ec.clear();
>>>>>>>>> rep_value = last_write_time(file, ec);
>>>>>>>>> IsRepresentable = !bool(ec);
>>>>>>>>> @@ -82,7 +78,7 @@ TEST_CASE(last_write_time_not_representa
>>>>>>>>>
>>>>>>>>> ExceptionChecker CheckExcept(file, expected_err,
>>>>>>>>> "directory_entry::last_write_t
>>>>>>>>> ime");
>>>>>>>>> - TEST_CHECK_THROW_RESULT(fs::filesystem_error, CheckExcept,
>>>>>>>>> + TEST_CHECK_THROW_RESULT(filesystem_error, CheckExcept,
>>>>>>>>> ent.last_write_time());
>>>>>>>>>
>>>>>>>>> } else {
>>>>>>>>>
>>>>>>>>> Modified: libcxx/trunk/test/libcxx/exper
>>>>>>>>> imental/filesystem/convert_file_time.sh.cpp
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx
>>>>>>>>> /experimental/filesystem/convert_file_time.sh.cpp?rev=
>>>>>>>>> 337960&r1=337959&r2=337960&view=diff
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
>>>>>>>>> (original)
>>>>>>>>> +++ libcxx/trunk/test/libcxx/experimental/filesystem/convert_file_time.sh.cpp
>>>>>>>>> Wed Jul 25 13:51:49 2018
>>>>>>>>> @@ -25,15 +25,23 @@
>>>>>>>>>
>>>>>>>>> #include "filesystem_common.h"
>>>>>>>>>
>>>>>>>>> +#ifndef __SIZEOF_INT128__
>>>>>>>>> +#define TEST_HAS_NO_INT128_T
>>>>>>>>> +#endif
>>>>>>>>> +
>>>>>>>>> using namespace std::chrono;
>>>>>>>>> namespace fs = std::experimental::filesystem;
>>>>>>>>> using fs::file_time_type;
>>>>>>>>> -using fs::detail::time_util::fs_time_util;
>>>>>>>>> +using fs::detail::time_util;
>>>>>>>>> +
>>>>>>>>> +#ifdef TEST_HAS_NO_INT128_T
>>>>>>>>> +static_assert(sizeof(fs::file_time_type::rep) <= 8, "");
>>>>>>>>> +#endif
>>>>>>>>>
>>>>>>>>> -enum TestKind { TK_64Bit, TK_32Bit, TK_FloatingPoint };
>>>>>>>>> +enum TestKind { TK_128Bit, TK_64Bit, TK_32Bit, TK_FloatingPoint };
>>>>>>>>>
>>>>>>>>> -template <class FileTimeT, class TimeT, class TimeSpec>
>>>>>>>>> -constexpr TestKind getTestKind() {
>>>>>>>>> +template <class TimeT>
>>>>>>>>> +constexpr TestKind getTimeTTestKind() {
>>>>>>>>> if (sizeof(TimeT) == 8 && !std::is_floating_point<TimeT>
>>>>>>>>> ::value)
>>>>>>>>> return TK_64Bit;
>>>>>>>>> else if (sizeof(TimeT) == 4 && !std::is_floating_point<TimeT>
>>>>>>>>> ::value)
>>>>>>>>> @@ -43,17 +51,99 @@ constexpr TestKind getTestKind() {
>>>>>>>>> else
>>>>>>>>> assert(false && "test kind not supported");
>>>>>>>>> }
>>>>>>>>> +template <class FileTimeT>
>>>>>>>>> +constexpr TestKind getFileTimeTestKind() {
>>>>>>>>> + using Rep = typename FileTimeT::rep;
>>>>>>>>> + if (std::is_floating_point<Rep>::value)
>>>>>>>>> + return TK_FloatingPoint;
>>>>>>>>> + if (sizeof(Rep) == 16)
>>>>>>>>> + return TK_128Bit;
>>>>>>>>> + if (sizeof(Rep) == 8)
>>>>>>>>> + return TK_64Bit;
>>>>>>>>> + assert(false && "test kind not supported");
>>>>>>>>> +}
>>>>>>>>>
>>>>>>>>> template <class FileTimeT, class TimeT, class TimeSpecT,
>>>>>>>>> - class Base = fs_time_util<FileTimeT, TimeT, TimeSpecT>,
>>>>>>>>> - TestKind = getTestKind<FileTimeT, TimeT, TimeSpecT>()>
>>>>>>>>> -struct check_is_representable;
>>>>>>>>> + class Base = time_util<FileTimeT, TimeT, TimeSpecT>,
>>>>>>>>> + TestKind = getTimeTTestKind<TimeT>(),
>>>>>>>>> + TestKind = getFileTimeTestKind<FileTimeT>()>
>>>>>>>>> +struct test_case;
>>>>>>>>>
>>>>>>>>> template <class FileTimeT, class TimeT, class TimeSpecT, class
>>>>>>>>> Base>
>>>>>>>>> -struct check_is_representable<FileTimeT, TimeT, TimeSpecT, Base,
>>>>>>>>> TK_64Bit>
>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpecT, Base, TK_64Bit,
>>>>>>>>> TK_128Bit>
>>>>>>>>> : public Base {
>>>>>>>>>
>>>>>>>>> - using Base::convert_timespec;
>>>>>>>>> + using Base::convert_from_timespec;
>>>>>>>>> + using Base::convert_to_timespec;
>>>>>>>>> + using Base::is_representable;
>>>>>>>>> + using Base::max_nsec;
>>>>>>>>> + using Base::max_seconds;
>>>>>>>>> + using Base::min_nsec_timespec;
>>>>>>>>> + using Base::min_seconds;
>>>>>>>>> +
>>>>>>>>> + static constexpr auto max_time_t =
>>>>>>>>> std::numeric_limits<TimeT>::max();
>>>>>>>>> + static constexpr auto min_time_t =
>>>>>>>>> std::numeric_limits<TimeT>::min();
>>>>>>>>> +
>>>>>>>>> + static constexpr bool test_timespec() {
>>>>>>>>> + static_assert(is_representable(TimeSpecT{max_time_t, 0}),
>>>>>>>>> "");
>>>>>>>>> + static_assert(is_representable(TimeSpecT{max_time_t,
>>>>>>>>> 999999999}), "");
>>>>>>>>> + static_assert(is_representable(TimeSpecT{max_time_t,
>>>>>>>>> 1000000000}), "");
>>>>>>>>> + static_assert(is_representable(TimeSpecT{max_time_t,
>>>>>>>>> max_nsec}), "");
>>>>>>>>> +
>>>>>>>>> + static_assert(is_representable(TimeSpecT{min_time_t, 0}),
>>>>>>>>> "");
>>>>>>>>> + static_assert(is_representable(TimeSpecT{min_time_t,
>>>>>>>>> 999999999}), "");
>>>>>>>>> + static_assert(is_representable(TimeSpecT{min_time_t,
>>>>>>>>> 1000000000}), "");
>>>>>>>>> + static_assert(is_representable(TimeSpecT{min_time_t,
>>>>>>>>> min_nsec_timespec}),
>>>>>>>>> + "");
>>>>>>>>> +
>>>>>>>>> + return true;
>>>>>>>>> + }
>>>>>>>>> +
>>>>>>>>> + static constexpr bool test_file_time_type() {
>>>>>>>>> + // This kinda sucks. Oh well.
>>>>>>>>> + static_assert(!Base::is_representable(FileTimeT::max()), "");
>>>>>>>>> + static_assert(!Base::is_representable(FileTimeT::min()), "");
>>>>>>>>> + return true;
>>>>>>>>> + }
>>>>>>>>> +
>>>>>>>>> + static constexpr bool check_round_trip(TimeSpecT orig) {
>>>>>>>>> + TimeSpecT new_ts = {};
>>>>>>>>> + FileTimeT out = convert_from_timespec(orig);
>>>>>>>>> + assert(convert_to_timespec(new_ts, out));
>>>>>>>>> + return new_ts.tv_sec == orig.tv_sec && new_ts.tv_nsec ==
>>>>>>>>> orig.tv_nsec;
>>>>>>>>> + }
>>>>>>>>> +
>>>>>>>>> + static constexpr bool test_convert_timespec() {
>>>>>>>>> + static_assert(check_round_trip({0, 0}), "");
>>>>>>>>> + static_assert(check_round_trip({0, 1}), "");
>>>>>>>>> + static_assert(check_round_trip({1, 1}), "");
>>>>>>>>> + static_assert(check_round_trip({-1, 1}), "");
>>>>>>>>> + static_assert(check_round_trip({max_time_t, max_nsec}), "");
>>>>>>>>> + static_assert(check_round_trip({max_time_t, 123}), "");
>>>>>>>>> + static_assert(check_round_trip({min_time_t,
>>>>>>>>> min_nsec_timespec}), "");
>>>>>>>>> + static_assert(check_round_trip({min_time_t, 123}), "");
>>>>>>>>> + return true;
>>>>>>>>> + }
>>>>>>>>> +
>>>>>>>>> + static bool test() {
>>>>>>>>> + static_assert(test_timespec(), "");
>>>>>>>>> + static_assert(test_file_time_type(), "");
>>>>>>>>> + static_assert(test_convert_timespec(), "");
>>>>>>>>> + return true;
>>>>>>>>> + }
>>>>>>>>> +};
>>>>>>>>> +
>>>>>>>>> +template <class FileTimeT, class TimeT, class TimeSpecT, class
>>>>>>>>> Base>
>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpecT, Base, TK_32Bit,
>>>>>>>>> TK_128Bit>
>>>>>>>>> + : public test_case<FileTimeT, TimeT, TimeSpecT, Base,
>>>>>>>>> TK_64Bit, TK_128Bit> {
>>>>>>>>> +
>>>>>>>>> +};
>>>>>>>>> +
>>>>>>>>> +template <class FileTimeT, class TimeT, class TimeSpecT, class
>>>>>>>>> Base>
>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpecT, Base, TK_64Bit,
>>>>>>>>> TK_64Bit>
>>>>>>>>> + : public Base {
>>>>>>>>> +
>>>>>>>>> + using Base::convert_from_timespec;
>>>>>>>>> using Base::is_representable;
>>>>>>>>> using Base::max_nsec;
>>>>>>>>> using Base::max_seconds;
>>>>>>>>> @@ -88,24 +178,25 @@ struct check_is_representable<FileTimeT,
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> static constexpr bool test_convert_timespec() {
>>>>>>>>> - static_assert(convert_timespec(TimeSpecT{max_seconds,
>>>>>>>>> max_nsec}) ==
>>>>>>>>> + static_assert(convert_from_timespec(TimeSpecT{max_seconds,
>>>>>>>>> max_nsec}) ==
>>>>>>>>> FileTimeT::max(),
>>>>>>>>> "");
>>>>>>>>> - static_assert(convert_timespec(TimeSpecT{max_seconds,
>>>>>>>>> max_nsec - 1}) <
>>>>>>>>> + static_assert(convert_from_timespec(TimeSpecT{max_seconds,
>>>>>>>>> max_nsec - 1}) <
>>>>>>>>> FileTimeT::max(),
>>>>>>>>> "");
>>>>>>>>> - static_assert(convert_timespec(TimeSpecT{max_seconds - 1,
>>>>>>>>> 999999999}) <
>>>>>>>>> + static_assert(convert_from_timespec(TimeSpecT{max_seconds -
>>>>>>>>> 1, 999999999}) <
>>>>>>>>> FileTimeT::max(),
>>>>>>>>> "");
>>>>>>>>> - static_assert(convert_timespec(TimeSpecT{
>>>>>>>>> + static_assert(convert_from_timespec(TimeSpecT{
>>>>>>>>> min_seconds - 1, min_nsec_timespec}) ==
>>>>>>>>> FileTimeT::min(),
>>>>>>>>> "");
>>>>>>>>> - static_assert(
>>>>>>>>> - convert_timespec(TimeSpecT{min_seconds - 1,
>>>>>>>>> min_nsec_timespec + 1}) >
>>>>>>>>> - FileTimeT::min(),
>>>>>>>>> - "");
>>>>>>>>> - static_assert(
>>>>>>>>> - convert_timespec(TimeSpecT{min_seconds, 0}) >
>>>>>>>>> FileTimeT::min(), "");
>>>>>>>>> + static_assert(convert_from_timespec(
>>>>>>>>> + TimeSpecT{min_seconds - 1,
>>>>>>>>> min_nsec_timespec + 1}) >
>>>>>>>>> + FileTimeT::min(),
>>>>>>>>> + "");
>>>>>>>>> + static_assert(convert_from_timespec(TimeSpecT{min_seconds,
>>>>>>>>> 0}) >
>>>>>>>>> + FileTimeT::min(),
>>>>>>>>> + "");
>>>>>>>>> return true;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> @@ -118,12 +209,12 @@ struct check_is_representable<FileTimeT,
>>>>>>>>> };
>>>>>>>>>
>>>>>>>>> template <class FileTimeT, class TimeT, class TimeSpecT, class
>>>>>>>>> Base>
>>>>>>>>> -struct check_is_representable<FileTimeT, TimeT, TimeSpecT, Base,
>>>>>>>>> TK_32Bit>
>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpecT, Base, TK_32Bit,
>>>>>>>>> TK_64Bit>
>>>>>>>>> : public Base {
>>>>>>>>> static constexpr auto max_time_t =
>>>>>>>>> std::numeric_limits<TimeT>::max();
>>>>>>>>> static constexpr auto min_time_t =
>>>>>>>>> std::numeric_limits<TimeT>::min();
>>>>>>>>>
>>>>>>>>> - using Base::convert_timespec;
>>>>>>>>> + using Base::convert_from_timespec;
>>>>>>>>> using Base::is_representable;
>>>>>>>>> using Base::max_nsec;
>>>>>>>>> using Base::max_seconds;
>>>>>>>>> @@ -158,9 +249,10 @@ struct check_is_representable<FileTimeT,
>>>>>>>>> }
>>>>>>>>> };
>>>>>>>>>
>>>>>>>>> -template <class FileTimeT, class TimeT, class TimeSpec, class
>>>>>>>>> Base>
>>>>>>>>> -struct check_is_representable<FileTimeT, TimeT, TimeSpec, Base,
>>>>>>>>> - TK_FloatingPoint> : public Base {
>>>>>>>>> +template <class FileTimeT, class TimeT, class TimeSpec, class
>>>>>>>>> Base,
>>>>>>>>> + TestKind FileTimeTKind>
>>>>>>>>> +struct test_case<FileTimeT, TimeT, TimeSpec, Base,
>>>>>>>>> TK_FloatingPoint,
>>>>>>>>> + FileTimeTKind> : public Base {
>>>>>>>>>
>>>>>>>>> static bool test() { return true; }
>>>>>>>>> };
>>>>>>>>> @@ -182,19 +274,33 @@ struct TestClock {
>>>>>>>>> static time_point now() noexcept { return {}; }
>>>>>>>>> };
>>>>>>>>>
>>>>>>>>> -template <class IntType, class Dur = duration<IntType,
>>>>>>>>> std::micro> >
>>>>>>>>> -using TestFileTimeT = time_point<TestClock<Dur> >;
>>>>>>>>> +template <class IntType, class Period = std::micro>
>>>>>>>>> +using TestFileTimeT = time_point<TestClock<duration<IntType,
>>>>>>>>> Period> > >;
>>>>>>>>>
>>>>>>>>> int main() {
>>>>>>>>> - assert((
>>>>>>>>> - check_is_representable<file_time_type, time_t, struct
>>>>>>>>> timespec>::test()));
>>>>>>>>> - assert((check_is_representable<TestFileTimeT<int64_t>, int64_t,
>>>>>>>>> - TestTimeSpec<int64_t, long>
>>>>>>>>> >::test()));
>>>>>>>>> - assert((check_is_representable<TestFileTimeT<long long>,
>>>>>>>>> int32_t,
>>>>>>>>> - TestTimeSpec<int32_t, int32_t>
>>>>>>>>> >::test()));
>>>>>>>>> -
>>>>>>>>> - // Test that insane platforms like ppc64 linux, which use long
>>>>>>>>> double as time_t,
>>>>>>>>> - // at least compile.
>>>>>>>>> - assert((check_is_representable<TestFileTimeT<long double>,
>>>>>>>>> double,
>>>>>>>>> - TestTimeSpec<long double, long>
>>>>>>>>> >::test()));
>>>>>>>>> + { assert((test_case<file_time_type, time_t, struct
>>>>>>>>> timespec>::test())); }
>>>>>>>>> + {
>>>>>>>>> + assert((test_case<TestFileTimeT<int64_t>, int64_t,
>>>>>>>>> + TestTimeSpec<int64_t, long> >::test()));
>>>>>>>>> + }
>>>>>>>>> + {
>>>>>>>>> + assert((test_case<TestFileTimeT<long long>, int32_t,
>>>>>>>>> + TestTimeSpec<int32_t, int32_t> >::test()));
>>>>>>>>> + }
>>>>>>>>> + {
>>>>>>>>> + // Test that insane platforms like ppc64 linux, which use
>>>>>>>>> long double as time_t,
>>>>>>>>> + // at least compile.
>>>>>>>>> + assert((test_case<TestFileTimeT<long double>, double,
>>>>>>>>> + TestTimeSpec<long double, long> >::test()));
>>>>>>>>> + }
>>>>>>>>> +#ifndef TEST_HAS_NO_INT128_T
>>>>>>>>> + {
>>>>>>>>> + assert((test_case<TestFileTimeT<__int128_t, std::nano>,
>>>>>>>>> int64_t,
>>>>>>>>> + TestTimeSpec<int64_t, long> >::test()));
>>>>>>>>> + }
>>>>>>>>> + {
>>>>>>>>> + assert((test_case<TestFileTimeT<__int128_t, std::nano>,
>>>>>>>>> int32_t,
>>>>>>>>> + TestTimeSpec<int32_t, int32_t> >::test()));
>>>>>>>>> + }
>>>>>>>>> +#endif
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Modified: libcxx/trunk/test/std/experime
>>>>>>>>> ntal/filesystem/fs.filesystem.synopsis/file_time_type.pass.cpp
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/ex
>>>>>>>>> perimental/filesystem/fs.filesystem.synopsis/file_time_type.
>>>>>>>>> pass.cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/test/std/experimental/filesystem/fs.filesystem.
>>>>>>>>> synopsis/file_time_type.pass.cpp (original)
>>>>>>>>> +++ libcxx/trunk/test/std/experimental/filesystem/fs.filesystem.
>>>>>>>>> synopsis/file_time_type.pass.cpp Wed Jul 25 13:51:49 2018
>>>>>>>>> @@ -17,15 +17,30 @@
>>>>>>>>> #include <chrono>
>>>>>>>>> #include <type_traits>
>>>>>>>>>
>>>>>>>>> +#include "test_macros.h"
>>>>>>>>> +
>>>>>>>>> // system_clock is used because it meets the requirements of
>>>>>>>>> TrivialClock,
>>>>>>>>> // and the resolution and range of system_clock should match the
>>>>>>>>> operating
>>>>>>>>> // system's file time type.
>>>>>>>>> -typedef std::chrono::system_clock ExpectedClock;
>>>>>>>>> -typedef std::chrono::time_point<ExpectedClock> ExpectedTimePoint;
>>>>>>>>> +
>>>>>>>>> +void test_trivial_clock() {
>>>>>>>>> + using namespace fs;
>>>>>>>>> + using Clock = file_time_type::clock;
>>>>>>>>> + ASSERT_NOEXCEPT(Clock::now());
>>>>>>>>> + ASSERT_SAME_TYPE(decltype(Clock::now()), file_time_type);
>>>>>>>>> + ASSERT_SAME_TYPE(Clock::time_point, file_time_type);
>>>>>>>>> + volatile auto* odr_use = &Clock::is_steady;
>>>>>>>>> + ((void)odr_use);
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +void test_time_point_resolution_and_range() {
>>>>>>>>> + using namespace fs;
>>>>>>>>> + using Dur = file_time_type::duration;
>>>>>>>>> + using Period = Dur::period;
>>>>>>>>> + ASSERT_SAME_TYPE(Period, std::nano);
>>>>>>>>> +}
>>>>>>>>>
>>>>>>>>> int main() {
>>>>>>>>> - static_assert(std::is_same<
>>>>>>>>> - fs::file_time_type,
>>>>>>>>> - ExpectedTimePoint
>>>>>>>>> - >::value, "");
>>>>>>>>> + test_trivial_clock();
>>>>>>>>> + test_time_point_resolution_and_range();
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Modified: libcxx/trunk/test/std/experime
>>>>>>>>> ntal/filesystem/fs.op.funcs/fs.op.last_write_time/last_
>>>>>>>>> write_time.pass.cpp
>>>>>>>>> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/ex
>>>>>>>>> perimental/filesystem/fs.op.funcs/fs.op.last_write_time/last
>>>>>>>>> _write_time.pass.cpp?rev=337960&r1=337959&r2=337960&view=diff
>>>>>>>>> ============================================================
>>>>>>>>> ==================
>>>>>>>>> --- libcxx/trunk/test/std/experimental/filesystem/fs.op.funcs/
>>>>>>>>> fs.op.last_write_time/last_write_time.pass.cpp (original)
>>>>>>>>> +++ libcxx/trunk/test/std/experimental/filesystem/fs.op.funcs/
>>>>>>>>> fs.op.last_write_time/last_write_time.pass.cpp Wed Jul 25
>>>>>>>>> 13:51:49 2018
>>>>>>>>> @@ -30,13 +30,86 @@
>>>>>>>>> #include <sys/stat.h>
>>>>>>>>> #include <iostream>
>>>>>>>>>
>>>>>>>>> +#include <fcntl.h>
>>>>>>>>> +#include <sys/time.h>
>>>>>>>>> +
>>>>>>>>> using namespace fs;
>>>>>>>>>
>>>>>>>>> -struct Times { std::time_t access, write; };
>>>>>>>>> +using TimeSpec = struct ::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 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;
>>>>>>>>> }
>>>>>>>>> +#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);
>>>>>>>>> + using SecLim = std::numeric_limits<SecFieldT>;
>>>>>>>>> + using NSecLim = std::numeric_limits<NSecFieldT>;
>>>>>>>>> +
>>>>>>>>> + auto secs = duration_cast<Sec>(ft.time_since_epoch());
>>>>>>>>> + auto nsecs = duration_cast<NanoSec>(ft.time_since_epoch() -
>>>>>>>>> secs);
>>>>>>>>> + if (nsecs.count() < 0) {
>>>>>>>>> + if (Sec::min().count() > SecLim::min()) {
>>>>>>>>> + secs += Sec(1);
>>>>>>>>> + nsecs -= Sec(1);
>>>>>>>>> + } else {
>>>>>>>>> + nsecs = NanoSec(0);
>>>>>>>>> + }
>>>>>>>>> + }
>>>>>>>>> + if (SecLim::max() < secs.count() || SecLim::min() >
>>>>>>>>> secs.count())
>>>>>>>>> + return false;
>>>>>>>>> + if (NSecLim::max() < nsecs.count() || NSecLim::min() >
>>>>>>>>> nsecs.count())
>>>>>>>>> + return false;
>>>>>>>>> + ts.tv_sec = secs.count();
>>>>>>>>> + ts.tv_nsec = nsecs.count();
>>>>>>>>> + return true;
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +bool ConvertFromTimeSpec(file_time_type& ft, TimeSpec ts) {
>>>>>>>>> + auto secs_part = duration_cast<file_time_type::
>>>>>>>>> duration>(Sec(ts.tv_sec));
>>>>>>>>> + if (duration_cast<Sec>(secs_part).count() != ts.tv_sec)
>>>>>>>>> + return false;
>>>>>>>>> + auto subsecs = duration_cast<file_time_type::
>>>>>>>>> duration>(NanoSec(ts.tv_nsec));
>>>>>>>>> + auto dur = secs_part + subsecs;
>>>>>>>>> + if (dur < secs_part && subsecs.count() >= 0)
>>>>>>>>> + return false;
>>>>>>>>> + ft = file_time_type(dur);
>>>>>>>>> + return true;
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +bool CompareTimeExact(TimeSpec ts, TimeSpec ts2) {
>>>>>>>>> + return ts2.tv_sec == ts.tv_sec && ts2.tv_nsec == ts.tv_nsec;
>>>>>>>>> +}
>>>>>>>>> +bool CompareTimeExact(file_time_type ft, TimeSpec ts) {
>>>>>>>>> + TimeSpec ts2 = {};
>>>>>>>>> + if (!ConvertToTimeSpec(ts2, ft))
>>>>>>>>> + return false;
>>>>>>>>> + return CompareTimeExact(ts, ts2);
>>>>>>>>> +}
>>>>>>>>> +bool CompareTimeExact(TimeSpec ts, file_time_type ft) {
>>>>>>>>> + return CompareTimeExact(ft, ts);
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +struct Times {
>>>>>>>>> + TimeSpec access, write;
>>>>>>>>> +};
>>>>>>>>>
>>>>>>>>> Times GetTimes(path const& p) {
>>>>>>>>> using Clock = file_time_type::clock;
>>>>>>>>> - struct ::stat st;
>>>>>>>>> + StatT st;
>>>>>>>>> if (::stat(p.c_str(), &st) == -1) {
>>>>>>>>> std::error_code ec(errno, std::generic_category());
>>>>>>>>> #ifndef TEST_HAS_NO_EXCEPTIONS
>>>>>>>>> @@ -46,22 +119,18 @@ Times GetTimes(path const& p) {
>>>>>>>>> std::exit(EXIT_FAILURE);
>>>>>>>>> #endif
>>>>>>>>> }
>>>>>>>>> - return {st.st_atime, st.st_mtime};
>>>>>>>>> + return {extract_atime(st), extract_mtime(st)};
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> -std::time_t LastAccessTime(path const& p) {
>>>>>>>>> - return GetTimes(p).access;
>>>>>>>>> -}
>>>>>>>>> +TimeSpec LastAccessTime(path const& p) { return
>>>>>>>>> GetTimes(p).access; }
>>>>>>>>>
>>>>>>>>> -std::time_t LastWriteTime(path const& p) {
>>>>>>>>> - return GetTimes(p).write;
>>>>>>>>> -}
>>>>>>>>> +TimeSpec LastWriteTime(path const& p) { return GetTimes(p).write;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> -std::pair<std::time_t, std::time_t> GetSymlinkTimes(path const&
>>>>>>>>> p) {
>>>>>>>>> - using Clock = file_time_type::clock;
>>>>>>>>> - struct ::stat st;
>>>>>>>>> - if (::lstat(p.c_str(), &st) == -1) {
>>>>>>>>> - std::error_code ec(errno, std::generic_category());
>>>>>>>>> +std::pair<TimeSpec, TimeSpec> GetSymlinkTimes(path const& p) {
>>>>>>>>> + using Clock = file_time_type::clock;
>>>>>>>>> + StatT st;
>>>>>>>>> + if (::lstat(p.c_str(), &st) == -1) {
>>>>>>>>> + std::error_code ec(errno, std::generic_category());
>>>>>>>>> #ifndef TEST_HAS_NO_EXCEPTIONS
>>>>>>>>> throw ec;
>>>>>>>>> #else
>>>>>>>>> @@ -69,24 +138,10 @@ std::pair<std::time_t, std::time_t> GetS
>>>>>>>>> std::exit(EXIT_FAILURE);
>>>>>>>>> #endif
>>>>>>>>> }
>>>>>>>>> - return {st.st_atime, st.st_mtime};
>>>>>>>>> + return {extract_atime(st), extract_mtime(st)};
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> namespace {
>>>>>>>>> -bool TestSupportsNegativeTimes() {
>>>>>>>>> - using namespace std::chrono;
>>>>>>>>> - std::error_code ec;
>>>>>>>>> - std::time_t old_write_time, new_write_time;
>>>>>>>>> - { // WARNING: Do not assert in this scope.
>>>>>>>>> - scoped_test_env env;
>>>>>>>>> - const path file = env.create_file("file", 42);
>>>>>>>>> - old_write_time = LastWriteTime(file);
>>>>>>>>> - file_time_type tp(seconds(-5));
>>>>>>>>> - fs::last_write_time(file, tp, ec);
>>>>>>>>> - new_write_time = LastWriteTime(file);
>>>>>>>>> - }
>>>>>>>>> - return !ec && new_write_time <= -5;
>>>>>>>>> -}
>>>>>>>>>
>>>>>>>>> // 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
>>>>>>>>> @@ -98,61 +153,131 @@ bool TestSupportsNegativeTimes() {
>>>>>>>>> #pragma clang diagnostic ignored "-Wtautological-constant-compa
>>>>>>>>> re"
>>>>>>>>> #endif
>>>>>>>>>
>>>>>>>>> -bool TestSupportsMaxTime() {
>>>>>>>>> - using namespace std::chrono;
>>>>>>>>> - using Lim = std::numeric_limits<std::time_t>;
>>>>>>>>> - auto max_sec = duration_cast<seconds>(file_ti
>>>>>>>>> me_type::max().time_since_epoch()).count();
>>>>>>>>> - if (max_sec > Lim::max()) return false;
>>>>>>>>> - std::error_code ec;
>>>>>>>>> - std::time_t old_write_time, new_write_time;
>>>>>>>>> - { // WARNING: Do not assert in this scope.
>>>>>>>>> - scoped_test_env env;
>>>>>>>>> - const path file = env.create_file("file", 42);
>>>>>>>>> - old_write_time = LastWriteTime(file);
>>>>>>>>> - file_time_type tp = file_time_type::max();
>>>>>>>>> - fs::last_write_time(file, tp, ec);
>>>>>>>>> - new_write_time = LastWriteTime(file);
>>>>>>>>> - }
>>>>>>>>> - return !ec && new_write_time > max_sec - 1;
>>>>>>>>> -}
>>>>>>>>> -
>>>>>>>>> -bool TestSupportsMinTime() {
>>>>>>>>> - using namespace std::chrono;
>>>>>>>>> - using Lim = std::numeric_limits<std::time_t>;
>>>>>>>>> - auto min_sec = duration_cast<seconds>(file_ti
>>>>>>>>> me_type::min().time_since_epoch()).count();
>>>>>>>>> - if (min_sec < Lim::min()) return false;
>>>>>>>>> - std::error_code ec;
>>>>>>>>> - std::time_t old_write_time, new_write_time;
>>>>>>>>> - { // WARNING: Do not assert in this scope.
>>>>>>>>> - scoped_test_env env;
>>>>>>>>> - const path file = env.create_file("file", 42);
>>>>>>>>> - old_write_time = LastWriteTime(file);
>>>>>>>>> - file_time_type tp = file_time_type::min();
>>>>>>>>> - fs::last_write_time(file, tp, ec);
>>>>>>>>> - new_write_time = LastWriteTime(file);
>>>>>>>>> - }
>>>>>>>>> - return !ec && new_write_time < min_sec + 1;
>>>>>>>>> -}
>>>>>>>>> -
>>>>>>>>> -#if defined(__clang__)
>>>>>>>>> -#pragma clang diagnostic pop
>>>>>>>>> -#endif
>>>>>>>>> -
>>>>>>>>> -static const bool SupportsNegativeTimes =
>>>>>>>>> TestSupportsNegativeTimes();
>>>>>>>>> -static const bool SupportsMaxTime = TestSupportsMaxTime();
>>>>>>>>> -static const bool SupportsMinTime = TestSupportsMinTime();
>>>>>>>>> +static const bool SupportsNegativeTimes = [] {
>>>>>>>>> + using namespace std::chrono;
>>>>>>>>> + std::error_code ec;
>>>>>>>>> + TimeSpec old_write_time, new_write_time;
>>>>>>>>> + { // WARNING: Do not assert in this scope.
>>>>>>>>> + scoped_test_env env;
>>>>>>>>> + const path file = env.create_file("file", 42);
>>>>>>>>> + old_write_time = LastWriteTime(file);
>>>>>>>>> + file_time_type tp(seconds(-5));
>>>>>>>>> + fs::last_write_time(file, tp, ec);
>>>>>>>>> + new_write_time = LastWriteTime(file);
>>>>>>>>> + }
>>>>>>>>> +
>>>>>>>>> + return !ec && new_write_time.tv_sec < 0;
>>>>>>>>> +}();
>>>>>>>>> +
>>>>>>>>> +static const bool SupportsMaxTime = [] {
>>>>>>>>> + using namespace std::chrono;
>>>>>>>>> + TimeSpec max_ts = {};
>>>>>>>>> + if (!ConvertToTimeSpec(max_ts, file_time_type::max()))
>>>>>>>>> + return false;
>>>>>>>>> +
>>>>>>>>> + std::error_code ec;
>>>>>>>>> + TimeSpec old_write_time, new_write_time;
>>>>>>>>> + { // WARNING: Do not assert in this scope.
>>>>>>>>> + scoped_test_env env;
>>>>>>>>> + const path file = env.create_file("file", 42);
>>>>>>>>> + old_write_time = LastWriteTime(file);
>>>>>>>>> + file_time_type tp = file_time_type::max();
>>>>>>>>> + fs::last_write_time(file, tp, ec);
>>>>>>>>> + new_write_time = LastWriteTime(file);
>>>>>>>>> + }
>>>>>>>>> + return !ec && new_write_time.tv_sec > max_ts.tv_sec - 1;
>>>>>>>>> +}();
>>>>>>>>> +
>>>>>>>>> +static const bool SupportsMinTime = [] {
>>>>>>>>> + using namespace std::chrono;
>>>>>>>>> + TimeSpec min_ts = {};
>>>>>>>>> + if (!ConvertToTimeSpec(min_ts, file_time_type::min()))
>>>>>>>>> + return false;
>>>>>>>>> + std::error_code ec;
>>>>>>>>> + TimeSpec old_write_time, new_write_time;
>>>>>>>>> + { // WARNING: Do not assert in this scope.
>>>>>>>>> + scoped_test_env env;
>>>>>>>>> + const path file = env.create_file("file", 42);
>>>>>>>>> + old_write_time = LastWriteTime(file);
>>>>>>>>> + file_time_type tp = file_time_type::min();
>>>>>>>>> + fs::last_write_time(file, tp, ec);
>>>>>>>>> + new_write_time = LastWriteTime(file);
>>>>>>>>> + }
>>>>>>>>> + return !ec && new_write_time.tv_sec < min_ts.tv_sec + 1;
>>>>>>>>> +}();
>>>>>>>>> +
>>>>>>>>> +static const bool SupportsNanosecondRoundTrip = [] {
>>>>>>>>> + NanoSec ns(3);
>>>>>>>>> +
>>>>>>>>> + // Test if the file_time_type period is less than that of
>>>>>>>>> nanoseconds.
>>>>>>>>> + auto ft_dur = duration_cast<file_time_type::duration>(ns);
>>>>>>>>> + if (duration_cast<NanoSec>(ft_dur) != ns)
>>>>>>>>> + return false;
>>>>>>>>> +
>>>>>>>>> + // Test that the system call we use to set the times also
>>>>>>>>> supports nanosecond
>>>>>>>>> + // resolution. (utimes does not)
>>>>>>>>> + file_time_type ft(ft_dur);
>>>>>>>>> + {
>>>>>>>>> + scoped_test_env env;
>>>>>>>>> + const path p = env.create_file("file", 42);
>>>>>>>>> + last_write_time(p, ft);
>>>>>>>>> + return last_write_time(p) == ft;
>>>>>>>>> + }
>>>>>>>>> +}();
>>>>>>>>> +
>>>>>>>>> +static const bool SupportsMinRoundTrip = [] {
>>>>>>>>> + TimeSpec ts = {};
>>>>>>>>> + if (!ConvertToTimeSpec(ts, file_time_type::min()))
>>>>>>>>> + return false;
>>>>>>>>> + file_time_type min_val = {};
>>>>>>>>> + if (!ConvertFromTimeSpec(min_val, ts))
>>>>>>>>> + return false;
>>>>>>>>> + return min_val == file_time_type::min();
>>>>>>>>> +}();
>>>>>>>>>
>>>>>>>>> } // end 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
>>>>>>>>> -#pragma clang diagnostic ignored "-Wunknown-warning-option"
>>>>>>>>> -#pragma clang diagnostic ignored "-Wunknown-pragmas"
>>>>>>>>> -#pragma clang diagnostic ignored "-Wtautological-constant-compa
>>>>>>>>> re"
>>>>>>>>> -#endif
>>>>>>>>> +static bool CompareTime(TimeSpec t1, TimeSpec t2) {
>>>>>>>>> + 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);
>>>>>>>>> +
>>>>>>>>> + return diff < duration_cast<NanoSec>(MicroSec(1)).count();
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +static bool CompareTime(file_time_type t1, TimeSpec t2) {
>>>>>>>>> + TimeSpec ts1 = {};
>>>>>>>>> + if (!ConvertToTimeSpec(ts1, t1))
>>>>>>>>> + return false;
>>>>>>>>> + return CompareTime(ts1, t2);
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +static bool CompareTime(TimeSpec t1, file_time_type t2) {
>>>>>>>>> + return CompareTime(t2, t1);
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +static bool CompareTime(file_time_type t1, file_time_type t2) {
>>>>>>>>> + auto min_secs = duration_cast<Sec>(file_time_t
>>>>>>>>> ype::min().time_since_epoch());
>>>>>>>>> + bool IsMin =
>>>>>>>>> + t1.time_since_epoch() < min_secs || t2.time_since_epoch() <
>>>>>>>>> min_secs;
>>>>>>>>> +
>>>>>>>>> + if (SupportsNanosecondRoundTrip && (!IsMin ||
>>>>>>>>> SupportsMinRoundTrip))
>>>>>>>>> + return t1 == t2;
>>>>>>>>> + if (IsMin) {
>>>>>>>>> + return duration_cast<Sec>(t1.time_since_epoch()) ==
>>>>>>>>> + duration_cast<Sec>(t2.time_since_epoch());
>>>>>>>>> + }
>>>>>>>>> + file_time_type::duration dur;
>>>>>>>>> + if (t1 > t2)
>>>>>>>>> + dur = t1 - t2;
>>>>>>>>> + else
>>>>>>>>> + dur = t2 - t1;
>>>>>>>>> +
>>>>>>>>> + return duration_cast<MicroSec>(dur).count() < 1;
>>>>>>>>> +}
>>>>>>>>>
>>>>>>>>> // Check if a time point is representable on a given filesystem.
>>>>>>>>> Check that:
>>>>>>>>> // (A) 'tp' is representable as a time_t
>>>>>>>>> @@ -162,22 +287,33 @@ static const bool SupportsMinTime = Test
>>>>>>>>> // (D) 'tp' is not 'file_time_type::min()' or the filesystem
>>>>>>>>> supports the min
>>>>>>>>> // value.
>>>>>>>>> inline bool TimeIsRepresentableByFilesystem(file_time_type tp) {
>>>>>>>>> - using namespace std::chrono;
>>>>>>>>> - using Lim = std::numeric_limits<std::time_t>;
>>>>>>>>> - auto sec = duration_cast<seconds>(tp.time
>>>>>>>>> _since_epoch()).count();
>>>>>>>>> - auto microsec = duration_cast<microseconds>(tp
>>>>>>>>> .time_since_epoch()).count();
>>>>>>>>> - if (sec < Lim::min() || sec > Lim::max()) return false;
>>>>>>>>> - else if (microsec < 0 && !SupportsNegativeTimes) return false;
>>>>>>>>> - else if (tp == file_time_type::max() && !SupportsMaxTime)
>>>>>>>>> return false;
>>>>>>>>> - else if (tp == file_time_type::min() && !SupportsMinTime)
>>>>>>>>> return false;
>>>>>>>>> - return true;
>>>>>>>>> + TimeSpec ts = {};
>>>>>>>>> + if (!ConvertToTimeSpec(ts, tp))
>>>>>>>>> + return false;
>>>>>>>>> + else if (tp.time_since_epoch().count() < 0 &&
>>>>>>>>> !SupportsNegativeTimes)
>>>>>>>>> + return false;
>>>>>>>>> + else if (tp == file_time_type::max() && !SupportsMaxTime)
>>>>>>>>> + return false;
>>>>>>>>> + else if (tp == file_time_type::min() && !SupportsMinTime)
>>>>>>>>> + return false;
>>>>>>>>> + return true;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> #if defined(__clang__)
>>>>>>>>> #pragma clang diagnostic pop
>>>>>>>>> #endif
>>>>>>>>>
>>>>>>>>> -TEST_SUITE(exists_test_suite)
>>>>>>>>> +// Create a sub-second duration using the smallest period the
>>>>>>>>> filesystem supports.
>>>>>>>>> +file_time_type::duration SubSec(long long val) {
>>>>>>>>> + using SubSecT = file_time_type::duration;
>>>>>>>>> + if (SupportsNanosecondRoundTrip) {
>>>>>>>>> + return duration_cast<SubSecT>(NanoSec(val));
>>>>>>>>> + } else {
>>>>>>>>> + return duration_cast<SubSecT>(MicroSec(val));
>>>>>>>>> + }
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +TEST_SUITE(last_write_time_test_suite)
>>>>>>>>>
>>>>>>>>> TEST_CASE(signature_test)
>>>>>>>>> {
>>>>>>>>> @@ -202,21 +338,21 @@ TEST_CASE(read_last_write_time_static_en
>>>>>>>>> file_time_type ret = last_write_time(StaticEnv::File);
>>>>>>>>> TEST_CHECK(ret != min);
>>>>>>>>> TEST_CHECK(ret < C::now());
>>>>>>>>> - TEST_CHECK(C::to_time_t(ret) ==
>>>>>>>>> LastWriteTime(StaticEnv::File));
>>>>>>>>> + TEST_CHECK(CompareTime(ret, LastWriteTime(StaticEnv::File)
>>>>>>>>> ));
>>>>>>>>>
>>>>>>>>> file_time_type ret2 = last_write_time(StaticEnv::Sym
>>>>>>>>> linkToFile);
>>>>>>>>> - TEST_CHECK(ret == ret2);
>>>>>>>>> - TEST_CHECK(C::to_time_t(ret2) ==
>>>>>>>>> LastWriteTime(StaticEnv::SymlinkToFile));
>>>>>>>>> + TEST_CHECK(CompareTime(ret, ret2));
>>>>>>>>> + TEST_CHECK(CompareTime(ret2,
>>>>>>>>> LastWriteTime(StaticEnv::SymlinkToFile)));
>>>>>>>>> }
>>>>>>>>> {
>>>>>>>>> file_time_type ret = last_write_time(StaticEnv::Dir);
>>>>>>>>> TEST_CHECK(ret != min);
>>>>>>>>> TEST_CHECK(ret < C::now());
>>>>>>>>> - TEST_CHECK(C::to_time_t(ret) ==
>>>>>>>>> LastWriteTime(StaticEnv::Dir));
>>>>>>>>> + TEST_CHECK(CompareTime(ret, LastWriteTime(StaticEnv::Dir))
>>>>>>>>> );
>>>>>>>>>
>>>>>>>>> file_time_type ret2 = last_write_time(StaticEnv::Sym
>>>>>>>>> linkToDir);
>>>>>>>>> - TEST_CHECK(ret == ret2);
>>>>>>>>> - TEST_CHECK(C::to_time_t(ret2) ==
>>>>>>>>> LastWriteTime(StaticEnv::SymlinkToDir));
>>>>>>>>> + TEST_CHECK(CompareTime(ret, ret2));
>>>>>>>>> + TEST_CHECK(CompareTime(ret2,
>>>>>>>>> LastWriteTime(StaticEnv::SymlinkToDir)));
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> @@ -230,15 +366,17 @@ TEST_CASE(get_last_write_time_dynamic_en
>>>>>>>>> const path dir = env.create_dir("dir");
>>>>>>>>>
>>>>>>>>> const auto file_times = GetTimes(file);
>>>>>>>>> - const std::time_t file_write_time = file_times.write;
>>>>>>>>> + const TimeSpec file_write_time = file_times.write;
>>>>>>>>> const auto dir_times = GetTimes(dir);
>>>>>>>>> - const std::time_t dir_write_time = dir_times.write;
>>>>>>>>> + const TimeSpec dir_write_time = dir_times.write;
>>>>>>>>>
>>>>>>>>> file_time_type ftime = last_write_time(file);
>>>>>>>>> - TEST_CHECK(Clock::to_time_t(ftime) == file_write_time);
>>>>>>>>> + TEST_CHECK(Clock::to_time_t(ftime) ==
>>>>>>>>> file_write_time.tv_sec);
>>>>>>>>> + TEST_CHECK(CompareTime(ftime, file_write_time));
>>>>>>>>>
>>>>>>>>> file_time_type dtime = last_write_time(dir);
>>>>>>>>> - TEST_CHECK(Clock::to_time_t(dtime) == dir_write_time);
>>>>>>>>> + TEST_CHECK(Clock::to_time_t(dtime) == dir_write_time.tv_sec);
>>>>>>>>> + TEST_CHECK(CompareTime(dtime, dir_write_time));
>>>>>>>>>
>>>>>>>>> SleepFor(Sec(2));
>>>>>>>>>
>>>>>>>>> @@ -253,18 +391,15 @@ TEST_CASE(get_last_write_time_dynamic_en
>>>>>>>>>
>>>>>>>>> TEST_CHECK(ftime2 > ftime);
>>>>>>>>> TEST_CHECK(dtime2 > dtime);
>>>>>>>>> - TEST_CHECK(LastWriteTime(file) == Clock::to_time_t(ftime2));
>>>>>>>>> - TEST_CHECK(LastWriteTime(dir) == Clock::to_time_t(dtime2));
>>>>>>>>> + TEST_CHECK(CompareTime(LastWriteTime(file), ftime2));
>>>>>>>>> + TEST_CHECK(CompareTime(LastWriteTime(dir), dtime2));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> TEST_CASE(set_last_write_time_dynamic_env_test)
>>>>>>>>> {
>>>>>>>>> using Clock = file_time_type::clock;
>>>>>>>>> - using Sec = std::chrono::seconds;
>>>>>>>>> - using Hours = std::chrono::hours;
>>>>>>>>> - using Minutes = std::chrono::minutes;
>>>>>>>>> - using MicroSec = std::chrono::microseconds;
>>>>>>>>> + using SubSecT = file_time_type::duration;
>>>>>>>>> scoped_test_env env;
>>>>>>>>>
>>>>>>>>> const path file = env.create_file("file", 42);
>>>>>>>>> @@ -272,15 +407,17 @@ TEST_CASE(set_last_write_time_dynamic_en
>>>>>>>>> const auto now = Clock::now();
>>>>>>>>> const file_time_type epoch_time = now -
>>>>>>>>> now.time_since_epoch();
>>>>>>>>>
>>>>>>>>> - const file_time_type future_time = now + Hours(3) + Sec(42) +
>>>>>>>>> MicroSec(17);
>>>>>>>>> - const file_time_type past_time = now - Minutes(3) - Sec(42) -
>>>>>>>>> MicroSec(17);
>>>>>>>>> - const file_time_type before_epoch_time = epoch_time -
>>>>>>>>> Minutes(3) - Sec(42) - MicroSec(17);
>>>>>>>>> + const file_time_type future_time = now + Hours(3) + Sec(42) +
>>>>>>>>> SubSec(17);
>>>>>>>>> + const file_time_type past_time = now - Minutes(3) - Sec(42) -
>>>>>>>>> SubSec(17);
>>>>>>>>> + const file_time_type before_epoch_time =
>>>>>>>>> + epoch_time - Minutes(3) - Sec(42) - SubSec(17);
>>>>>>>>> // FreeBSD has a bug in their utimes implementation where the
>>>>>>>>> time is not update
>>>>>>>>> // when the number of seconds is '-1'.
>>>>>>>>> #if defined(__FreeBSD__)
>>>>>>>>> - const file_time_type just_before_epoch_time = epoch_time -
>>>>>>>>> Sec(2) - MicroSec(17);
>>>>>>>>> + const file_time_type just_before_epoch_time =
>>>>>>>>> + epoch_time - Sec(2) - SubSec(17);
>>>>>>>>> #else
>>>>>>>>> - const file_time_type just_before_epoch_time = epoch_time -
>>>>>>>>> MicroSec(17);
>>>>>>>>> + const file_time_type just_before_epoch_time = epoch_time -
>>>>>>>>> SubSec(17);
>>>>>>>>> #endif
>>>>>>>>>
>>>>>>>>> struct TestCase {
>>>>>>>>> @@ -300,7 +437,8 @@ TEST_CASE(set_last_write_time_dynamic_en
>>>>>>>>> };
>>>>>>>>> for (const auto& TC : cases) {
>>>>>>>>> const auto old_times = GetTimes(TC.p);
>>>>>>>>> - file_time_type old_time(Sec(old_times.write));
>>>>>>>>> + file_time_type old_time;
>>>>>>>>> + TEST_REQUIRE(ConvertFromTimeSpec(old_time,
>>>>>>>>> old_times.write));
>>>>>>>>>
>>>>>>>>> std::error_code ec = GetTestEC();
>>>>>>>>> last_write_time(TC.p, TC.new_time, ec);
>>>>>>>>> @@ -310,14 +448,8 @@ TEST_CASE(set_last_write_time_dynamic_en
>>>>>>>>>
>>>>>>>>> if (TimeIsRepresentableByFilesystem(TC.new_time)) {
>>>>>>>>> TEST_CHECK(got_time != old_time);
>>>>>>>>> - if (TC.new_time < epoch_time) {
>>>>>>>>> - TEST_CHECK(got_time <= TC.new_time);
>>>>>>>>> - TEST_CHECK(got_time > TC.new_time - Sec(1));
>>>>>>>>> - } else {
>>>>>>>>> - TEST_CHECK(got_time <= TC.new_time + Sec(1));
>>>>>>>>> - TEST_CHECK(got_time >= TC.new_time - Sec(1));
>>>>>>>>> - }
>>>>>>>>> - TEST_CHECK(LastAccessTime(TC.p) == old_times.access);
>>>>>>>>> + TEST_CHECK(CompareTime(got_time, TC.new_time));
>>>>>>>>> + TEST_CHECK(CompareTime(LastAccessTime(TC.p),
>>>>>>>>> old_times.access));
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>> @@ -325,9 +457,6 @@ TEST_CASE(set_last_write_time_dynamic_en
>>>>>>>>> TEST_CASE(last_write_time_symlink_test)
>>>>>>>>> {
>>>>>>>>> using Clock = file_time_type::clock;
>>>>>>>>> - using Sec = std::chrono::seconds;
>>>>>>>>> - using Hours = std::chrono::hours;
>>>>>>>>> - using Minutes = std::chrono::minutes;
>>>>>>>>>
>>>>>>>>> scoped_test_env env;
>>>>>>>>>
>>>>>>>>> @@ -343,77 +472,75 @@ TEST_CASE(last_write_time_symlink_test)
>>>>>>>>> last_write_time(sym, new_time, ec);
>>>>>>>>> TEST_CHECK(!ec);
>>>>>>>>>
>>>>>>>>> - const std::time_t new_time_t = Clock::to_time_t(new_time);
>>>>>>>>> file_time_type got_time = last_write_time(sym);
>>>>>>>>> - std::time_t got_time_t = Clock::to_time_t(got_time);
>>>>>>>>> + TEST_CHECK(!CompareTime(got_time, old_times.write));
>>>>>>>>> + TEST_CHECK(got_time == new_time);
>>>>>>>>>
>>>>>>>>> - TEST_CHECK(got_time_t != old_times.write);
>>>>>>>>> - TEST_CHECK(got_time_t == new_time_t);
>>>>>>>>> - TEST_CHECK(LastWriteTime(file) == new_time_t);
>>>>>>>>> - TEST_CHECK(LastAccessTime(sym) == old_times.access);
>>>>>>>>> - TEST_CHECK(GetSymlinkTimes(sym) == old_sym_times);
>>>>>>>>> + TEST_CHECK(CompareTime(LastWriteTime(file), new_time));
>>>>>>>>> + TEST_CHECK(CompareTime(LastAccessTime(sym),
>>>>>>>>> old_times.access));
>>>>>>>>> + std::pair<TimeSpec, TimeSpec> sym_times =
>>>>>>>>> GetSymlinkTimes(sym);
>>>>>>>>> + TEST_CHECK(CompareTime(sym_times.first,
>>>>>>>>> old_sym_times.first));
>>>>>>>>> + TEST_CHECK(CompareTime(sym_times.second,
>>>>>>>>> old_sym_times.second));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> TEST_CASE(test_write_min_time)
>>>>>>>>> {
>>>>>>>>> using Clock = file_time_type::clock;
>>>>>>>>> - using Sec = std::chrono::seconds;
>>>>>>>>> - using MicroSec = std::chrono::microseconds;
>>>>>>>>> - using Lim = std::numeric_limits<std::time_t>;
>>>>>>>>> scoped_test_env env;
>>>>>>>>> const path p = env.create_file("file", 42);
>>>>>>>>> -
>>>>>>>>> - std::error_code ec = GetTestEC();
>>>>>>>>> + const file_time_type old_time = last_write_time(p);
>>>>>>>>> file_time_type new_time = file_time_type::min();
>>>>>>>>>
>>>>>>>>> + std::error_code ec = GetTestEC();
>>>>>>>>> last_write_time(p, new_time, ec);
>>>>>>>>> file_time_type tt = last_write_time(p);
>>>>>>>>>
>>>>>>>>> if (TimeIsRepresentableByFilesystem(new_time)) {
>>>>>>>>> TEST_CHECK(!ec);
>>>>>>>>> - TEST_CHECK(tt >= new_time);
>>>>>>>>> - TEST_CHECK(tt < new_time + Sec(1));
>>>>>>>>> -
>>>>>>>>> - ec = GetTestEC();
>>>>>>>>> - last_write_time(p, Clock::now());
>>>>>>>>> + TEST_CHECK(CompareTime(tt, new_time));
>>>>>>>>>
>>>>>>>>> - new_time = file_time_type::min() + MicroSec(1);
>>>>>>>>> + last_write_time(p, old_time);
>>>>>>>>> + new_time = file_time_type::min() + SubSec(1);
>>>>>>>>>
>>>>>>>>> + ec = GetTestEC();
>>>>>>>>> last_write_time(p, new_time, ec);
>>>>>>>>> tt = last_write_time(p);
>>>>>>>>>
>>>>>>>>> if (TimeIsRepresentableByFilesystem(new_time)) {
>>>>>>>>> TEST_CHECK(!ec);
>>>>>>>>> - TEST_CHECK(tt >= new_time);
>>>>>>>>> - TEST_CHECK(tt < new_time + Sec(1));
>>>>>>>>> + TEST_CHECK(CompareTime(tt, new_time));
>>>>>>>>> + } else {
>>>>>>>>> + TEST_CHECK(ErrorIs(ec, std::errc::value_too_large));
>>>>>>>>> + TEST_CHECK(tt == old_time);
>>>>>>>>> }
>>>>>>>>> + } else {
>>>>>>>>> + TEST_CHECK(ErrorIs(ec, std::errc::value_too_large));
>>>>>>>>> + TEST_CHECK(tt == old_time);
>>>>>>>>> }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> +TEST_CASE(test_write_max_time) {
>>>>>>>>> + using Clock = file_time_type::clock;
>>>>>>>>> + using Sec = std::chrono::seconds;
>>>>>>>>> + using Hours = std::chrono::hours;
>>>>>>>>> +
>>>>>>>>> + 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::max();
>>>>>>>>> +
>>>>>>>>> + std::error_code ec = GetTestEC();
>>>>>>>>> + last_write_time(p, new_time, ec);
>>>>>>>>> + file_time_type tt = last_write_time(p);
>>>>>>>>>
>>>>>>>>> -
>>>>>>>>> -TEST_CASE(test_write_min_max_time)
>>>>>>>>> -{
>>>>>>>>> - using Clock = file_time_type::clock;
>>>>>>>>> - using Sec = std::chrono::seconds;
>>>>>>>>> - using Hours = std::chrono::hours;
>>>>>>>>> - using Lim = std::numeric_limits<std::time_t>;
>>>>>>>>> - scoped_test_env env;
>>>>>>>>> - const path p = env.create_file("file", 42);
>>>>>>>>> -
>>>>>>>>> - std::error_code ec = GetTestEC();
>>>>>>>>> - file_time_type new_time = file_time_type::max();
>>>>>>>>> -
>>>>>>>>> - ec = GetTestEC();
>>>>>>>>> - last_write_time(p, new_time, ec);
>>>>>>>>> - file_time_type tt = last_write_time(p);
>>>>>>>>> -
>>>>>>>>> - if (TimeIsRepresentableByFilesystem(new_time)) {
>>>>>>>>> - TEST_CHECK(!ec);
>>>>>>>>> - TEST_CHECK(tt > new_time - Sec(1));
>>>>>>>>> - TEST_CHECK(tt <= new_time);
>>>>>>>>> - }
>>>>>>>>> + if (TimeIsRepresentableByFilesystem(new_time)) {
>>>>>>>>> + TEST_CHECK(!ec);
>>>>>>>>> + TEST_CHECK(CompareTime(tt, new_time));
>>>>>>>>> + } else {
>>>>>>>>> + TEST_CHECK(ErrorIs(ec, std::errc::value_too_large));
>>>>>>>>> + TEST_CHECK(tt == old_time);
>>>>>>>>> + }
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> TEST_CASE(test_value_on_failure)
>>>>>>>>> @@ -421,8 +548,7 @@ TEST_CASE(test_value_on_failure)
>>>>>>>>> const path p = StaticEnv::DNE;
>>>>>>>>> std::error_code ec = GetTestEC();
>>>>>>>>> TEST_CHECK(last_write_time(p, ec) == file_time_type::min());
>>>>>>>>> - TEST_CHECK(ec);
>>>>>>>>> - TEST_CHECK(ec != GetTestEC());
>>>>>>>>> + TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_dir
>>>>>>>>> ectory));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> TEST_CASE(test_exists_fails)
>>>>>>>>> @@ -434,10 +560,30 @@ TEST_CASE(test_exists_fails)
>>>>>>>>>
>>>>>>>>> std::error_code ec = GetTestEC();
>>>>>>>>> TEST_CHECK(last_write_time(file, ec) ==
>>>>>>>>> file_time_type::min());
>>>>>>>>> - TEST_CHECK(ec);
>>>>>>>>> - TEST_CHECK(ec != GetTestEC());
>>>>>>>>> + TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
>>>>>>>>>
>>>>>>>>> - TEST_CHECK_THROW(filesystem_error, last_write_time(file));
>>>>>>>>> + ExceptionChecker Checker(file, std::errc::permission_denied,
>>>>>>>>> + "last_write_time");
>>>>>>>>> + TEST_CHECK_THROW_RESULT(filesystem_error, Checker,
>>>>>>>>> last_write_time(file));
>>>>>>>>> +}
>>>>>>>>> +
>>>>>>>>> +TEST_CASE(my_test) {
>>>>>>>>> + scoped_test_env env;
>>>>>>>>> + const path p = env.create_file("file", 42);
>>>>>>>>> + using namespace std::chrono;
>>>>>>>>> + using TimeSpec = struct ::timespec;
>>>>>>>>> + TimeSpec ts[2];
>>>>>>>>> + ts[0].tv_sec = 0;
>>>>>>>>> + ts[0].tv_nsec = UTIME_OMIT;
>>>>>>>>> + ts[1].tv_sec = -1;
>>>>>>>>> + ts[1].tv_nsec =
>>>>>>>>> + duration_cast<nanoseconds>(seconds(1) -
>>>>>>>>> nanoseconds(13)).count();
>>>>>>>>> + if (::utimensat(AT_FDCWD, p.c_str(), ts, 0) == -1) {
>>>>>>>>> + TEST_CHECK(false);
>>>>>>>>> + }
>>>>>>>>> + TimeSpec new_ts = LastWriteTime(p);
>>>>>>>>> + TEST_CHECK(ts[1].tv_sec == new_ts.tv_sec);
>>>>>>>>> + TEST_CHECK(ts[1].tv_nsec == new_ts.tv_nsec);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> TEST_SUITE_END()
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> _______________________________________________
>>>>>>>>> cfe-commits mailing list
>>>>>>>>> cfe-commits at lists.llvm.org
>>>>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>
>>>>
>>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20180725/e5f711c8/attachment-0001.html>
More information about the cfe-commits
mailing list