Implement the 'sys_time' portions of the C++20 calendaring stuff. Reviewed as D56494

20 files changed, 1052 insertions, 113 deletions

diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
new file mode 100644
index 00000000000..23513823510
--- /dev/null
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.local_days.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class weekday;
+
+//  constexpr weekday(const local_days& dp) noexcept;
+//
+//  Effects:  Constructs an object of type weekday by computing what day
+//              of the week  corresponds to the local_days dp, and representing
+//              that day of the week in wd_ 
+//
+//  Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
+//                ymd == year_month_day{sys_days{ymd}} is true.
+// 
+// [Example: 
+//  If dp represents 1970-01-01, the constructed weekday represents Thursday by storing 4 in wd_.
+// —end example]
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using local_days = std::chrono::local_days;
+    using days       = std::chrono::days;
+    using weekday    = std::chrono::weekday;
+
+    ASSERT_NOEXCEPT(weekday{std::declval<local_days>()});
+
+    {
+    constexpr local_days sd{}; // 1-Jan-1970 was a Thursday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 4, "");
+    }
+
+    {
+    constexpr local_days sd{days{10957+32}}; // 2-Feb-2000 was a Wednesday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 3, "");
+    }
+
+
+    {
+    constexpr local_days sd{days{-10957}}; // 2-Jan-1940 was a Tuesday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 2, "");
+    }
+
+    {
+    local_days sd{days{-(10957+34)}}; // 29-Nov-1939 was a Wednesday
+    weekday wd{sd};
+
+    assert( wd.ok());
+    assert(static_cast<unsigned>(wd) == 3);
+    }
+}
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
new file mode 100644
index 00000000000..c49d05d3ae5
--- /dev/null
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.sys_days.pass.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class weekday;
+
+//  constexpr weekday(const sys_days& dp) noexcept;
+//
+//  Effects:  Constructs an object of type weekday by computing what day
+//              of the week  corresponds to the sys_days dp, and representing
+//              that day of the week in wd_ 
+//
+//  Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
+//                ymd == year_month_day{sys_days{ymd}} is true.
+// 
+// [Example: 
+//  If dp represents 1970-01-01, the constructed weekday represents Thursday by storing 4 in wd_.
+// —end example]
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using sys_days  = std::chrono::sys_days;
+    using days      = std::chrono::days;
+    using weekday   = std::chrono::weekday;
+
+    ASSERT_NOEXCEPT(weekday{std::declval<sys_days>()});
+
+    {
+    constexpr sys_days sd{}; // 1-Jan-1970 was a Thursday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 4, "");
+    }
+
+    {
+    constexpr sys_days sd{days{10957+32}}; // 2-Feb-2000 was a Wednesday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 3, "");
+    }
+
+
+    {
+    constexpr sys_days sd{days{-10957}}; // 2-Jan-1940 was a Tuesday
+    constexpr weekday wd{sd};
+
+    static_assert( wd.ok(), "");
+    static_assert(static_cast<unsigned>(wd) == 2, "");
+    }
+
+    {
+    sys_days sd{days{-(10957+34)}}; // 29-Nov-1939 was a Wednesday
+    weekday wd{sd};
+
+    assert( wd.ok());
+    assert(static_cast<unsigned>(wd) == 3);
+    }
+}
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
index f3321d5085e..5c7de1418fb 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.local_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day;
@@ -34,11 +33,53 @@
 int main()
 {
     using year           = std::chrono::year;
-    using month          = std::chrono::month;
     using day            = std::chrono::day;
-//  using local_days     = std::chrono::local_days;
+    using local_days     = std::chrono::local_days;
+    using days           = std::chrono::days;
     using year_month_day = std::chrono::year_month_day;
 
-//  ASSERT_NOEXCEPT(year_month_day{std::declval<const local_days>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_day{std::declval<local_days>()});
+
+    {
+    constexpr local_days sd{};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                            "");
+    static_assert( ymd.year()  == year{1970},           "");
+    static_assert( ymd.month() == std::chrono::January, "");
+    static_assert( ymd.day()   == day{1},               "");
+    }
+
+    {
+    constexpr local_days sd{days{10957+32}};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                             "");
+    static_assert( ymd.year()  == year{2000},            "");
+    static_assert( ymd.month() == std::chrono::February, "");
+    static_assert( ymd.day()   == day{2},                "");
+    }
+
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr local_days sd{days{-10957}};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                            "");
+    static_assert( ymd.year()  == year{1940},           "");
+    static_assert( ymd.month() == std::chrono::January, "");
+    static_assert( ymd.day()   == day{2},               "");
+    }
+
+    {
+    local_days sd{days{-(10957+34)}};
+    year_month_day ymd{sd};
+
+    assert( ymd.ok());
+    assert( ymd.year()  == year{1939});
+    assert( ymd.month() == std::chrono::November);
+    assert( ymd.day()   == day{29});
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
index d2e268d7d21..36a6c7d180c 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp
@@ -7,15 +7,14 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day;
 
 //  constexpr year_month_day(const sys_days& dp) noexcept;
 //
-//  Effects:  Constructs an object of type year_month_day that corresponds
-//                to the date represented by dp
+//  Effects:  Constructs an object of type year_month_day that corresponds 
+//                to the date represented by dp.
 //
 //  Remarks: For any value ymd of type year_month_day for which ymd.ok() is true,
 //                ymd == year_month_day{sys_days{ymd}} is true.
@@ -33,12 +32,53 @@
 int main()
 {
     using year           = std::chrono::year;
-    using month          = std::chrono::month;
     using day            = std::chrono::day;
-//  using sys_days     = std::chrono::sys_days;
+    using sys_days       = std::chrono::sys_days;
+    using days           = std::chrono::days;
     using year_month_day = std::chrono::year_month_day;
 
-//  ASSERT_NOEXCEPT(year_month_day{std::declval<const sys_days>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_day{std::declval<sys_days>()});
 
+    {
+    constexpr sys_days sd{};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                            "");
+    static_assert( ymd.year()  == year{1970},           "");
+    static_assert( ymd.month() == std::chrono::January, "");
+    static_assert( ymd.day()   == day{1},               "");
+    }
+
+    {
+    constexpr sys_days sd{days{10957+32}};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                             "");
+    static_assert( ymd.year()  == year{2000},            "");
+    static_assert( ymd.month() == std::chrono::February, "");
+    static_assert( ymd.day()   == day{2},                "");
+    }
+
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr sys_days sd{days{-10957}};
+    constexpr year_month_day ymd{sd};
+
+    static_assert( ymd.ok(),                            "");
+    static_assert( ymd.year()  == year{1940},           "");
+    static_assert( ymd.month() == std::chrono::January, "");
+    static_assert( ymd.day()   == day{2},               "");
+    }
+
+    {
+    sys_days sd{days{-(10957+34)}};
+    year_month_day ymd{sd};
+
+    assert( ymd.ok());
+    assert( ymd.year()  == year{1939});
+    assert( ymd.month() == std::chrono::November);
+    assert( ymd.day()   == day{29});
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
index 2b5fbab1a01..a8d6526b328 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.year_month_day_last.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day;
@@ -33,10 +32,49 @@ int main()
     using year                = std::chrono::year;
     using month               = std::chrono::month;
     using day                 = std::chrono::day;
-//  using year_month_day_last = std::chrono::year_month_day_last;
+    using month_day_last = std::chrono::month_day_last;
+    using year_month_day_last = std::chrono::year_month_day_last;
     using year_month_day      = std::chrono::year_month_day;
 
-//  ASSERT_NOEXCEPT(year_month_day{std::declval<const year_month_day_last>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_day{std::declval<const year_month_day_last>()});
 
+    {
+    constexpr year_month_day_last ymdl{year{2019}, month_day_last{month{1}}};
+    constexpr year_month_day ymd{ymdl};
+
+    static_assert( ymd.year()  == year{2019}, "");
+    static_assert( ymd.month() == month{1},   "");
+    static_assert( ymd.day()   == day{31},    "");
+    static_assert( ymd.ok(),                  "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{1970}, month_day_last{month{4}}};
+    constexpr year_month_day ymd{ymdl};
+
+    static_assert( ymd.year()  == year{1970}, "");
+    static_assert( ymd.month() == month{4},   "");
+    static_assert( ymd.day()   == day{30},    "");
+    static_assert( ymd.ok(),                  "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{2000}, month_day_last{month{2}}};
+    constexpr year_month_day ymd{ymdl};
+
+    static_assert( ymd.year()  == year{2000}, "");
+    static_assert( ymd.month() == month{2},   "");
+    static_assert( ymd.day()   == day{29},    "");
+    static_assert( ymd.ok(),                  "");
+    }
+
+    { // Feb 1900 was NOT a leap year.
+    year_month_day_last ymdl{year{1900}, month_day_last{month{2}}};
+    year_month_day ymd{ymdl};
+
+    assert( ymd.year()  == year{1900});
+    assert( ymd.month() == month{2});
+    assert( ymd.day()   == day{28});
+    assert( ymd.ok());
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
index 529d0d76051..cab0599b9ed 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp
@@ -44,6 +44,37 @@ int main()
 
     static_assert( year_month_day{year{2019},   January, day{1}}.ok(), ""); // All OK
 
+//  Some months have a 31st
+    static_assert( year_month_day{year{2020},   month{ 1}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 2}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 3}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 4}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 5}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 6}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 7}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 8}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 9}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{10}, day{31}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{11}, day{31}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{12}, day{31}}.ok(), "");
+
+//  Everyone except FEB has a 30th
+    static_assert( year_month_day{year{2020},   month{ 1}, day{30}}.ok(), "");
+    static_assert(!year_month_day{year{2020},   month{ 2}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 3}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 4}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 5}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 6}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 7}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 8}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{ 9}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{10}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{11}, day{30}}.ok(), "");
+    static_assert( year_month_day{year{2020},   month{12}, day{30}}.ok(), "");
+
+    static_assert(!year_month_day{year{2019},   std::chrono::February, day{29}}.ok(), ""); // Not a leap year
+    static_assert( year_month_day{year{2020},   std::chrono::February, day{29}}.ok(), ""); // Ok; 2020 is a leap year
+
     for (unsigned i = 0; i <= 50; ++i)
     {
         year_month_day ym{year{2019}, January, day{i}};
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
new file mode 100644
index 00000000000..720a1c8001b
--- /dev/null
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp
@@ -0,0 +1,94 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class year_month_day;
+
+// constexpr operator local_days() const noexcept;
+//
+// Returns: If ok(), returns a local_days holding a count of days from the
+//   local_days epoch to *this (a negative value if *this represents a date
+//   prior to the sys_days epoch). Otherwise, if y_.ok() && m_.ok() is true,
+//   returns a sys_days which is offset from sys_days{y_/m_/last} by the
+//   number of days d_ is offset from sys_days{y_/m_/last}.day(). Otherwise
+//   the value returned is unspecified.
+//
+// Remarks: A local_days in the range [days{-12687428}, days{11248737}] which
+//   is converted to a year_month_day shall have the same value when
+//   converted back to a sys_days.
+//
+// [Example:
+//   static_assert(year_month_day{local_days{2017y/January/0}}  == 2016y/December/31);
+//   static_assert(year_month_day{local_days{2017y/January/31}} == 2017y/January/31);
+//   static_assert(year_month_day{local_days{2017y/January/32}} == 2017y/February/1);
+// —end example]
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+void RunTheExample()
+{
+    using namespace std::chrono;
+
+    static_assert(year_month_day{local_days{2017y/January/0}}  == 2016y/December/31);
+    static_assert(year_month_day{local_days{2017y/January/31}} == 2017y/January/31);
+    static_assert(year_month_day{local_days{2017y/January/32}} == 2017y/February/1);  
+}
+
+int main()
+{
+    using year           = std::chrono::year;
+    using month          = std::chrono::month;
+    using day            = std::chrono::day;
+    using local_days       = std::chrono::local_days;
+    using days           = std::chrono::days;
+    using year_month_day = std::chrono::year_month_day;
+
+    ASSERT_NOEXCEPT(local_days(std::declval<year_month_day>()));
+    RunTheExample();
+
+    {
+    constexpr year_month_day ymd{year{1970}, month{1}, day{1}};
+    constexpr local_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{0}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+    {
+    constexpr year_month_day ymd{year{2000}, month{2}, day{2}};
+    constexpr local_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{10957+32}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr year_month_day ymd{year{1940}, month{1}, day{2}};
+    constexpr local_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{-10957}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+    {
+    year_month_day ymd{year{1939}, month{11}, day{29}};
+    local_days sd{ymd};
+
+    assert( sd.time_since_epoch() == days{-(10957+34)});
+    assert( year_month_day{sd} == ymd); // and back
+    }
+
+}
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
new file mode 100644
index 00000000000..da9865d9c26
--- /dev/null
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp
@@ -0,0 +1,94 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class year_month_day;
+
+// constexpr operator sys_days() const noexcept;
+//
+// Returns: If ok(), returns a sys_days holding a count of days from the
+//   sys_days epoch to *this (a negative value if *this represents a date
+//   prior to the sys_days epoch). Otherwise, if y_.ok() && m_.ok() is true,
+//   returns a sys_days which is offset from sys_days{y_/m_/last} by the
+//   number of days d_ is offset from sys_days{y_/m_/last}.day(). Otherwise
+//   the value returned is unspecified.
+//
+// Remarks: A sys_days in the range [days{-12687428}, days{11248737}] which
+//   is converted to a year_month_day shall have the same value when
+//   converted back to a sys_days.
+//
+// [Example:
+//   static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
+//   static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
+//   static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);
+// —end example]
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+void RunTheExample()
+{
+    using namespace std::chrono;
+
+    static_assert(year_month_day{sys_days{2017y/January/0}}  == 2016y/December/31);
+    static_assert(year_month_day{sys_days{2017y/January/31}} == 2017y/January/31);
+    static_assert(year_month_day{sys_days{2017y/January/32}} == 2017y/February/1);  
+}
+
+int main()
+{
+    using year           = std::chrono::year;
+    using month          = std::chrono::month;
+    using day            = std::chrono::day;
+    using sys_days       = std::chrono::sys_days;
+    using days           = std::chrono::days;
+    using year_month_day = std::chrono::year_month_day;
+
+    ASSERT_NOEXCEPT(sys_days(std::declval<year_month_day>()));
+    RunTheExample();
+
+    {
+    constexpr year_month_day ymd{year{1970}, month{1}, day{1}};
+    constexpr sys_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{0}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+    {
+    constexpr year_month_day ymd{year{2000}, month{2}, day{2}};
+    constexpr sys_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{10957+32}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr year_month_day ymd{year{1940}, month{1}, day{2}};
+    constexpr sys_days sd{ymd};
+
+    static_assert( sd.time_since_epoch() == days{-10957}, "");
+    static_assert( year_month_day{sd} == ymd, ""); // and back
+    }
+
+    {
+    year_month_day ymd{year{1939}, month{11}, day{29}};
+    sys_days sd{ymd};
+
+    assert( sd.time_since_epoch() == days{-(10957+34)});
+    assert( year_month_day{sd} == ymd); // and back
+    }
+
+}
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
index f68e3239ff5..db3369c6c8a 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day_last;
@@ -29,15 +28,24 @@ int main()
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
 
-//  TODO: wait for calendar
-//     ASSERT_NOEXCEPT(               std::declval<const year_month_day_last>().day());
-//     ASSERT_SAME_TYPE(day, decltype(std::declval<const year_month_day_last>().day()));
-//
-//     static_assert( year_month_day_last{}.day() == day{}, "");
+    ASSERT_NOEXCEPT(               std::declval<const year_month_day_last>().day());
+    ASSERT_SAME_TYPE(day, decltype(std::declval<const year_month_day_last>().day()));
+
+//  Some months have a 31st
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 1}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 2}}}.day() == day{29}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 3}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 4}}}.day() == day{30}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 5}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 6}}}.day() == day{30}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 7}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 8}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{ 9}}}.day() == day{30}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{10}}}.day() == day{31}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{11}}}.day() == day{30}, "");
+    static_assert( year_month_day_last{year{2020}, month_day_last{month{12}}}.day() == day{31}, "");
 
-    for (unsigned i = 1; i <= 12; ++i)
-    {
-        year_month_day_last ymd(year{1234}, month_day_last{month{i}});
-        assert( static_cast<unsigned>(ymd.day()) == i);
-    }
+    assert((year_month_day_last{year{2019}, month_day_last{month{ 2}}}.day() == day{28}));
+    assert((year_month_day_last{year{2020}, month_day_last{month{ 2}}}.day() == day{29}));
+    assert((year_month_day_last{year{2021}, month_day_last{month{ 2}}}.day() == day{28}));
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
index 43a3ef2036d..45f1ac4ae2d 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_local_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day_last;
@@ -24,13 +23,39 @@
 int main()
 {
     using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
-//  using sys_days            = std::chrono::local_days;
+    using local_days          = std::chrono::local_days;
+    using days                = std::chrono::days;
 
-//  ASSERT_NOEXCEPT(                static_cast<local_days>(std::declval<const year_month_day_last>().year()));
-//  ASSERT_SAME_TYPE(year, decltype(static_cast<local_days>(std::declval<const year_month_day_last>().year()));
-    assert(false);
+    ASSERT_NOEXCEPT(                      static_cast<local_days>(std::declval<const year_month_day_last>()));
+    ASSERT_SAME_TYPE(local_days, decltype(static_cast<local_days>(std::declval<const year_month_day_last>())));
+
+    { // Last day in Jan 1970 was the 31st
+    constexpr year_month_day_last ymdl{year{1970}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+    
+    static_assert(sd.time_since_epoch() == days{30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{2000}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{10957+30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{1940}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{-10957+29}, "");
+    }
+
+    {
+    year_month_day_last ymdl{year{1939}, month_day_last{std::chrono::November}};
+    local_days sd{ymdl};
+
+    assert(sd.time_since_epoch() == days{-(10957+33)});
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
index 8c1b3131e31..20aff6d1db8 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/op_sys_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day_last;
@@ -24,13 +23,39 @@
 int main()
 {
     using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
-//  using sys_days            = std::chrono::sys_days;
+    using sys_days            = std::chrono::sys_days;
+    using days                = std::chrono::days;
 
-//  ASSERT_NOEXCEPT(                static_cast<sys_days>(std::declval<const year_month_day_last>().year()));
-//  ASSERT_SAME_TYPE(year, decltype(static_cast<sys_days>(std::declval<const year_month_day_last>().year()));
-    assert(false);
+    ASSERT_NOEXCEPT(                    static_cast<sys_days>(std::declval<const year_month_day_last>()));
+    ASSERT_SAME_TYPE(sys_days, decltype(static_cast<sys_days>(std::declval<const year_month_day_last>())));
+
+    { // Last day in Jan 1970 was the 31st
+    constexpr year_month_day_last ymdl{year{1970}, month_day_last{std::chrono::January}};
+    constexpr sys_days sd{ymdl};
+    
+    static_assert(sd.time_since_epoch() == days{30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{2000}, month_day_last{std::chrono::January}};
+    constexpr sys_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{10957+30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{1940}, month_day_last{std::chrono::January}};
+    constexpr sys_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{-10957+29}, "");
+    }
+
+    {
+    year_month_day_last ymdl{year{1939}, month_day_last{std::chrono::November}};
+    sys_days sd{ymdl};
+
+    assert(sd.time_since_epoch() == days{-(10957+33)});
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
index dbc3c855a5a..a0b98abb7dd 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.local_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_weekday;
@@ -33,12 +32,64 @@
 
 int main()
 {
-    using year           = std::chrono::year;
-    using month          = std::chrono::month;
-    using day            = std::chrono::day;
-//  using local_days     = std::chrono::local_days;
+    using year               = std::chrono::year;
+    using days               = std::chrono::days;
+    using local_days         = std::chrono::local_days;
+    using weekday_indexed    = std::chrono::weekday_indexed;
     using year_month_weekday = std::chrono::year_month_weekday;
 
-//  ASSERT_NOEXCEPT(year_month_weekday{std::declval<const local_days>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_weekday{std::declval<const local_days>()});
+
+    {
+    constexpr local_days sd{}; // 1-Jan-1970 was a Thursday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{1970},                                 "");
+    static_assert( ymwd.month()           == std::chrono::January,                       "");
+    static_assert( ymwd.weekday()         == std::chrono::Thursday,                      "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Thursday, 1},  "");
+    static_assert( ymwd                   == year_month_weekday{local_days{ymwd}},       ""); // round trip
+    }
+
+    {
+    constexpr local_days sd{days{10957+32}}; // 2-Feb-2000 was a Wednesday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{2000},                                 "");
+    static_assert( ymwd.month()           == std::chrono::February,                      "");
+    static_assert( ymwd.weekday()         == std::chrono::Wednesday,                     "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 1}, "");
+    static_assert( ymwd                   == year_month_weekday{local_days{ymwd}},       ""); // round trip
+    }
+
+
+    {
+    constexpr local_days sd{days{-10957}}; // 2-Jan-1940 was a Tuesday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{1940},                                 "");
+    static_assert( ymwd.month()           == std::chrono::January,                       "");
+    static_assert( ymwd.weekday()         == std::chrono::Tuesday,                       "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Tuesday, 1},   "");
+    static_assert( ymwd                   == year_month_weekday{local_days{ymwd}},       ""); // round trip
+    }
+
+    {
+    local_days sd{days{-(10957+34)}}; // 29-Nov-1939 was a Wednesday
+    year_month_weekday ymwd{sd};
+
+    assert( ymwd.ok());
+    assert( ymwd.year()            == year{1939});
+    assert( ymwd.month()           == std::chrono::November);
+    assert( ymwd.weekday()         == std::chrono::Wednesday);
+    assert( ymwd.index()           == 5);
+    assert((ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 5}));
+    assert( ymwd                   == year_month_weekday{local_days{ymwd}}); // round trip
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
index 52b3f712f37..b9d3b6c62b1 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.sys_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_weekday;
@@ -32,12 +31,64 @@
 
 int main()
 {
-    using year           = std::chrono::year;
-    using month          = std::chrono::month;
-    using day            = std::chrono::day;
-//  using sys_days     = std::chrono::sys_days;
+    using year               = std::chrono::year;
+    using days               = std::chrono::days;
+    using sys_days           = std::chrono::sys_days;
+    using weekday_indexed    = std::chrono::weekday_indexed;
     using year_month_weekday = std::chrono::year_month_weekday;
 
-//  ASSERT_NOEXCEPT(year_month_weekday{std::declval<const sys_days>()});
-    assert(false);
+    ASSERT_NOEXCEPT(year_month_weekday{std::declval<const sys_days>()});
+
+    {
+    constexpr sys_days sd{}; // 1-Jan-1970 was a Thursday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{1970},                                 "");
+    static_assert( ymwd.month()           == std::chrono::January,                       "");
+    static_assert( ymwd.weekday()         == std::chrono::Thursday,                      "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Thursday, 1},  "");
+    static_assert( ymwd                   == year_month_weekday{sys_days{ymwd}},         ""); // round trip
+    }
+
+    {
+    constexpr sys_days sd{days{10957+32}}; // 2-Feb-2000 was a Wednesday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{2000},                                 "");
+    static_assert( ymwd.month()           == std::chrono::February,                      "");
+    static_assert( ymwd.weekday()         == std::chrono::Wednesday,                     "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 1}, "");
+    static_assert( ymwd                   == year_month_weekday{sys_days{ymwd}},         ""); // round trip
+    }
+
+
+    {
+    constexpr sys_days sd{days{-10957}}; // 2-Jan-1940 was a Tuesday
+    constexpr year_month_weekday ymwd{sd};
+
+    static_assert( ymwd.ok(),                                                            "");
+    static_assert( ymwd.year()            == year{1940},                                 "");
+    static_assert( ymwd.month()           == std::chrono::January,                       "");
+    static_assert( ymwd.weekday()         == std::chrono::Tuesday,                       "");
+    static_assert( ymwd.index()           == 1,                                          "");
+    static_assert( ymwd.weekday_indexed() == weekday_indexed{std::chrono::Tuesday, 1},   "");
+    static_assert( ymwd                   == year_month_weekday{sys_days{ymwd}},         ""); // round trip
+    }
+
+    {
+    sys_days sd{days{-(10957+34)}}; // 29-Nov-1939 was a Wednesday
+    year_month_weekday ymwd{sd};
+
+    assert( ymwd.ok());
+    assert( ymwd.year()            == year{1939});
+    assert( ymwd.month()           == std::chrono::November);
+    assert( ymwd.weekday()         == std::chrono::Wednesday);
+    assert( ymwd.index()           == 5);
+    assert((ymwd.weekday_indexed() == weekday_indexed{std::chrono::Wednesday, 5}));
+    assert( ymwd                   == year_month_weekday{sys_days{ymwd}}); // round trip
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.year_month_day_last.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.year_month_day_last.pass.cpp
deleted file mode 100644
index b873a195629..00000000000
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/ctor.year_month_day_last.pass.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     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.
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class year_month_weekday;
-
-//  constexpr year_month_weekday(const year_month_weekday_last& ymdl) noexcept;
-//
-//  Effects:  Constructs an object of type year_month_weekday by initializing
-//              y_ with ymdl.year(), m_ with ymdl.month(), and d_ with ymdl.day().
-//
-//  constexpr chrono::year   year() const noexcept;
-//  constexpr chrono::month month() const noexcept;
-//  constexpr chrono::day     day() const noexcept;
-//  constexpr bool             ok() const noexcept;
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main()
-{
-    using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
-    using year_month_weekday_last = std::chrono::year_month_weekday_last;
-    using year_month_weekday      = std::chrono::year_month_weekday;
-
-    ASSERT_NOEXCEPT(year_month_weekday{std::declval<const year_month_weekday_last>()});
-
-}
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
new file mode 100644
index 00000000000..ef30ce526c6
--- /dev/null
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class year_month_weekday;
+
+// explicit constexpr operator local_days() const noexcept;
+//
+// Returns: If y_.ok() && m_.ok() && wdi_.weekday().ok(), returns a
+//    sys_days that represents the date (index() - 1) * 7 days after the first
+//    weekday() of year()/month(). If index() is 0 the returned sys_days
+//    represents the date 7 days prior to the first weekday() of
+//    year()/month(). Otherwise the returned value is unspecified.
+//
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using year               = std::chrono::year;
+    using month              = std::chrono::month;
+    using weekday_indexed    = std::chrono::weekday_indexed;
+    using local_days         = std::chrono::local_days;
+    using days               = std::chrono::days;
+    using year_month_weekday = std::chrono::year_month_weekday;
+
+    ASSERT_NOEXCEPT(local_days(std::declval<year_month_weekday>()));
+
+    {
+    constexpr year_month_weekday ymwd{year{1970}, month{1}, weekday_indexed{std::chrono::Thursday, 1}};
+    constexpr local_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{0}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+    {
+    constexpr year_month_weekday ymwd{year{2000}, month{2}, weekday_indexed{std::chrono::Wednesday, 1}};
+    constexpr local_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{10957+32}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr year_month_weekday ymwd{year{1940}, month{1},weekday_indexed{std::chrono::Tuesday, 1}};
+    constexpr local_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{-10957}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+    {
+    year_month_weekday ymwd{year{1939}, month{11}, weekday_indexed{std::chrono::Wednesday, 5}};
+    local_days sd{ymwd};
+
+    assert( sd.time_since_epoch() == days{-(10957+34)});
+    assert( year_month_weekday{sd} == ymwd); // and back
+    }
+
+}
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
new file mode 100644
index 00000000000..04986e50d3f
--- /dev/null
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+// class year_month_weekday;
+
+// constexpr operator sys_days() const noexcept;
+//
+// Returns: If y_.ok() && m_.ok() && wdi_.weekday().ok(), returns a
+//    sys_days that represents the date (index() - 1) * 7 days after the first
+//    weekday() of year()/month(). If index() is 0 the returned sys_days
+//    represents the date 7 days prior to the first weekday() of
+//    year()/month(). Otherwise the returned value is unspecified.
+//
+
+#include <chrono>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using year               = std::chrono::year;
+    using month              = std::chrono::month;
+    using weekday_indexed    = std::chrono::weekday_indexed;
+    using sys_days           = std::chrono::sys_days;
+    using days               = std::chrono::days;
+    using year_month_weekday = std::chrono::year_month_weekday;
+
+    ASSERT_NOEXCEPT(sys_days(std::declval<year_month_weekday>()));
+
+    {
+    constexpr year_month_weekday ymwd{year{1970}, month{1}, weekday_indexed{std::chrono::Thursday, 1}};
+    constexpr sys_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{0}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+    {
+    constexpr year_month_weekday ymwd{year{2000}, month{2}, weekday_indexed{std::chrono::Wednesday, 1}};
+    constexpr sys_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{10957+32}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+//  There's one more leap day between 1/1/40 and 1/1/70
+//  when compared to 1/1/70 -> 1/1/2000
+    {
+    constexpr year_month_weekday ymwd{year{1940}, month{1},weekday_indexed{std::chrono::Tuesday, 1}};
+    constexpr sys_days sd{ymwd};
+
+    static_assert( sd.time_since_epoch() == days{-10957}, "");
+    static_assert( year_month_weekday{sd} == ymwd, ""); // and back
+    }
+
+    {
+    year_month_weekday ymwd{year{1939}, month{11}, weekday_indexed{std::chrono::Wednesday, 5}};
+    sys_days sd{ymwd};
+
+    assert( sd.time_since_epoch() == days{-(10957+34)});
+    assert( year_month_weekday{sd} == ymwd); // and back
+    }
+
+}
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
index 56009c42215..45f1ac4ae2d 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_local_days.pass.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
 // class year_month_day_last;
@@ -24,12 +23,39 @@
 int main()
 {
     using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
-    using sys_days            = std::chrono::local_days;
+    using local_days          = std::chrono::local_days;
+    using days                = std::chrono::days;
 
-    ASSERT_NOEXCEPT(                static_cast<local_days>(std::declval<const year_month_day_last>().year()));
-    ASSERT_SAME_TYPE(year, decltype(static_cast<local_days>(std::declval<const year_month_day_last>().year()));
+    ASSERT_NOEXCEPT(                      static_cast<local_days>(std::declval<const year_month_day_last>()));
+    ASSERT_SAME_TYPE(local_days, decltype(static_cast<local_days>(std::declval<const year_month_day_last>())));
+
+    { // Last day in Jan 1970 was the 31st
+    constexpr year_month_day_last ymdl{year{1970}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+    
+    static_assert(sd.time_since_epoch() == days{30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{2000}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{10957+30}, "");
+    }
+
+    {
+    constexpr year_month_day_last ymdl{year{1940}, month_day_last{std::chrono::January}};
+    constexpr local_days sd{ymdl};
+
+    static_assert(sd.time_since_epoch() == days{-10957+29}, "");
+    }
+
+    {
+    year_month_day_last ymdl{year{1939}, month_day_last{std::chrono::November}};
+    local_days sd{ymdl};
+
+    assert(sd.time_since_epoch() == days{-(10957+33)});
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
index 47beca7d9d2..c5abe4ace24 100644
--- a/libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
+++ b/libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.members/op_sys_days.pass.cpp
@@ -7,13 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// XFAIL: *
 
 // <chrono>
-// class year_month_day_last;
+// class year_month_weekday_last;
 
 // constexpr operator sys_days() const noexcept;
-//  Returns: sys_days{year()/month()/day()}.
+//  Returns: If ok() == true, returns a sys_days that represents the last weekday() 
+//             of year()/month(). Otherwise the returned value is unspecified.
 
 #include <chrono>
 #include <type_traits>
@@ -21,16 +21,49 @@
 
 #include "test_macros.h"
 
+#include <iostream>
+
 int main()
 {
-    using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using day                 = std::chrono::day;
-    using month_day_last      = std::chrono::month_day_last;
-    using year_month_day_last = std::chrono::year_month_day_last;
-    using sys_days            = std::chrono::sys_days;
+    using year                    = std::chrono::year;
+    using month                   = std::chrono::month;
+    using year_month_weekday_last = std::chrono::year_month_weekday_last;
+    using sys_days                = std::chrono::sys_days;
+    using days                    = std::chrono::days;
+    using weekday                 = std::chrono::weekday;
+    using weekday_last            = std::chrono::weekday_last;
+
+    ASSERT_NOEXCEPT(                    static_cast<sys_days>(std::declval<const year_month_weekday_last>()));
+    ASSERT_SAME_TYPE(sys_days, decltype(static_cast<sys_days>(std::declval<const year_month_weekday_last>())));
+
+    constexpr month   January = std::chrono::January;
+    constexpr weekday Tuesday = std::chrono::Tuesday;
+
+    { // Last Tuesday in Jan 1970 was the 27th
+    constexpr year_month_weekday_last ymwdl{year{1970}, January, weekday_last{Tuesday}};
+    constexpr sys_days sd{ymwdl};
+    
+    static_assert(sd.time_since_epoch() == days{26}, "");
+    }
+
+    { // Last Tuesday in Jan 2000 was the 25th
+    constexpr year_month_weekday_last ymwdl{year{2000}, January, weekday_last{Tuesday}};
+    constexpr sys_days sd{ymwdl};
+    
+    static_assert(sd.time_since_epoch() == days{10957+24}, "");
+    }
+
+    { // Last Tuesday in Jan 1940 was the 30th
+    constexpr year_month_weekday_last ymwdl{year{1940}, January, weekday_last{Tuesday}};
+    constexpr sys_days sd{ymwdl};
+    
+    static_assert(sd.time_since_epoch() == days{-10958+29}, "");
+    }
 
-    ASSERT_NOEXCEPT(                static_cast<sys_days>(std::declval<const year_month_day_last>().year()));
-    ASSERT_SAME_TYPE(year, decltype(static_cast<sys_days>(std::declval<const year_month_day_last>().year()));
+    { // Last Tuesday in Nov 1939 was the 28th
+    year_month_weekday_last ymdl{year{1939}, std::chrono::November, weekday_last{Tuesday}};
+    sys_days sd{ymdl};
 
+    assert(sd.time_since_epoch() == days{-(10957+35)});
+    }
 }
diff --git a/libcxx/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp b/libcxx/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
new file mode 100644
index 00000000000..9f91ca744b7
--- /dev/null
+++ b/libcxx/test/std/utilities/time/time.clock/time.clock.system/local_time.types.pass.cpp
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+
+// struct local_t {};
+// template<class Duration>
+//   using local_time  = time_point<system_clock, Duration>;
+// using local_seconds = sys_time<seconds>;
+// using local_days    = sys_time<days>;
+
+// [Example: 
+//   sys_seconds{sys_days{1970y/January/1}}.time_since_epoch() is 0s. 
+//   sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946’684’800s, which is 10’957 * 86’400s.
+// —end example]
+
+
+#include <chrono>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using local_t = std::chrono::local_t;
+    using year    = std::chrono::year;
+
+    using seconds = std::chrono::seconds;
+    using minutes = std::chrono::minutes;
+    using days    = std::chrono::days;
+    
+    using local_seconds = std::chrono::local_seconds;
+    using local_minutes = std::chrono::local_time<minutes>;
+    using local_days    = std::chrono::local_days;
+
+    constexpr std::chrono::month January = std::chrono::January;
+
+    ASSERT_SAME_TYPE(std::chrono::local_time<seconds>, local_seconds);
+    ASSERT_SAME_TYPE(std::chrono::local_time<days>,    local_days);
+
+//  Test the long form, too
+    ASSERT_SAME_TYPE(std::chrono::time_point<local_t, seconds>, local_seconds);
+    ASSERT_SAME_TYPE(std::chrono::time_point<local_t, minutes>, local_minutes);
+    ASSERT_SAME_TYPE(std::chrono::time_point<local_t, days>,    local_days);
+    
+//  Test some well known values
+    local_days d0 = local_days{year{1970}/January/1};
+    local_days d1 = local_days{year{2000}/January/1};
+    ASSERT_SAME_TYPE(decltype(d0.time_since_epoch()), days);
+    assert( d0.time_since_epoch().count() == 0);
+    assert( d1.time_since_epoch().count() == 10957);
+
+    local_seconds s0{d0};
+    local_seconds s1{d1};
+    ASSERT_SAME_TYPE(decltype(s0.time_since_epoch()), seconds);
+    assert( s0.time_since_epoch().count() == 0);
+    assert( s1.time_since_epoch().count() == 946684800L);
+}
diff --git a/libcxx/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp b/libcxx/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
new file mode 100644
index 00000000000..299e0681813
--- /dev/null
+++ b/libcxx/test/std/utilities/time/time.clock/time.clock.system/sys.time.types.pass.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <chrono>
+
+// template<class Duration>
+//   using sys_time  = time_point<system_clock, Duration>;
+// using sys_seconds = sys_time<seconds>;
+// using sys_days    = sys_time<days>;
+
+// [Example: 
+//   sys_seconds{sys_days{1970y/January/1}}.time_since_epoch() is 0s. 
+//   sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946’684’800s, which is 10’957 * 86’400s.
+// —end example]
+
+
+#include <chrono>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main()
+{
+    using system_clock = std::chrono::system_clock;
+    using year         = std::chrono::year;
+
+    using seconds = std::chrono::seconds;
+    using minutes = std::chrono::minutes;
+    using days    = std::chrono::days;
+    
+    using sys_seconds = std::chrono::sys_seconds;
+    using sys_minutes = std::chrono::sys_time<minutes>;
+    using sys_days    = std::chrono::sys_days;
+
+    constexpr std::chrono::month January = std::chrono::January;
+
+    ASSERT_SAME_TYPE(std::chrono::sys_time<seconds>, sys_seconds);
+    ASSERT_SAME_TYPE(std::chrono::sys_time<days>,    sys_days);
+
+//  Test the long form, too
+    ASSERT_SAME_TYPE(std::chrono::time_point<system_clock, seconds>, sys_seconds);
+    ASSERT_SAME_TYPE(std::chrono::time_point<system_clock, minutes>, sys_minutes);
+    ASSERT_SAME_TYPE(std::chrono::time_point<system_clock, days>,    sys_days);
+    
+//  Test some well known values
+    sys_days d0 = sys_days{year{1970}/January/1};
+    sys_days d1 = sys_days{year{2000}/January/1};
+    ASSERT_SAME_TYPE(decltype(d0.time_since_epoch()), days);
+    assert( d0.time_since_epoch().count() == 0);
+    assert( d1.time_since_epoch().count() == 10957);
+
+    sys_seconds s0{d0};
+    sys_seconds s1{d1};
+    ASSERT_SAME_TYPE(decltype(s0.time_since_epoch()), seconds);
+    assert( s0.time_since_epoch().count() == 0);
+    assert( s1.time_since_epoch().count() == 946684800L);
+}