[libcxx] chrono::month_weekday should not be default constructible

[CaseyCarter]

Summary

It was not in P0355R7, nor has it ever been so in a working draft.

Drive-by:

• tests should test something: fix loop bounds so initial value is not >= final value
• calender type streaming tests are nearly useless - let's remove them
• don't declare printf, especially if you don't intend to use it

[• Quuxplusone]

libcxx/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp

42–45

For test coverage this should say

for (int i=1; i <= 12; ++i)
    for (int j=1; j <= 12; ++j)
        assert(testComparisons6Values<month>(i, j));

(I wildly speculate that it originally ran from 1 to 10 in both loops, but that that didn't pass because all this stuff was broken, so someone changed j=1 to j=10 to nerf the test and then shipped it.)

libcxx/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp

0

You missed this XFAIL: *.
But, looking at these XFAIL'ed tests, I'm noticing that none of them are good. They just print something to std::cout (!) and then exit without asserting anything (!!). Do we want to just delete them, and ask whoever eventually implements <chrono> to write their own tests?

libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp

32–42

[Mordante]

Thanks for working on this!

libcxx/include/__chrono/calendar.h

543

I think this should be mentioned in the release notes. libcxx/docs/ReleaseNotes.rst

libcxx/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp

0

I think that makes sense. These tests only give a false impression we've implemented these parts of chrono.

[CaseyCarter]

Address review comments.

[CaseyCarter]

libcxx/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp

42–45

Ah, I incorrectly assumed from the fact that the ranges of i and j were disjoint that testComparisons6Values expected its first argument to be less than the second. Fixing, but I'll write < 13 to be consistent with every other loop in these tests.

libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp

32–42

Missed this comment. Fix incoming.

[CaseyCarter]

Address missed review comment.

[• Quuxplusone]

libcxx/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp

42–45

but I'll write < 13

Well, any choice can hardly make this test worse, so whatever. ;)
But for the record, I'm confident in my preference for numbering the calendar months 1<=x<=12 instead of 1<=x<13. ;) (Unless this loop is flat-out wrong and it should run 0<=x<12? That's not the case, right? I'm like 75% sure that months are 1-indexed and month 0 is UB or something like that.)

[CaseyCarter]

Use [1, 12] uniformly for months.

[Mordante]

LGTM, with one request.

libcxx/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp

61

Please fix this indention before landing, same applies to the tests below.

[CaseyCarter]

libcxx/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp

61

Done - I audited everything under test/std/utilities/time.cal.

libcxx/docs/ReleaseNotes.rst

- ``std::filesystem::path::iterator``, which (in our implementation) stashes
   so that it is a conforming input iterator in C++17 and a conforming
   ``std::bidirectional_iterator`` in C++20. Before this release, it had set its
   ``reference`` type to ``const path&`` and its ``iterator_category`` to
   ``bidirectional_iterator_tag``, making it a non-conforming bidirectional iterator.
   After this change, ``for`` loops of the form ``for (auto& c : path)`` must be rewritten
   as either ``for (auto&& c : path)`` or ``for (const auto& c : path)``.
   ``std::reverse_iterator<path::iterator>`` is no longer rejected.
 
+- Removed the nonstandard default constructor from ``std::chrono::month_weekday``.
+  You must now explicitly initialize with a ``chrono::month`` and
+  ``chrono::weekday_indexed`` instead of "meh, whenever".
 
 ABI Changes
 -----------
 
 - The C++17 variable templates ``is_error_code_enum_v`` and
   ``is_error_condition_enum_v`` are now of type ``bool`` instead of ``size_t``.
 
 - The C++03 emulation type for ``std::nullptr_t`` has been removed in favor of

libcxx/include/__chrono/calendar.h

 { return month_day_last{month(__rhs)}; }
 
 
 class month_weekday {
 private:
     chrono::month __m;
     chrono::weekday_indexed __wdi;
 public:
-    month_weekday() = default;
     constexpr month_weekday(const chrono::month& __mval, const chrono::weekday_indexed& __wdival) noexcept
         : __m{__mval}, __wdi{__wdival} {}
     inline constexpr chrono::month                     month() const noexcept { return __m; }
     inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi; }
     inline constexpr bool                                 ok() const noexcept { return __m.ok() && __wdi.ok(); }
 };
 
 inline constexpr

libcxx/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/comparisons.pass.cpp

int main(int, char**)
     using day = std::chrono::day;
 
     AssertComparisons6AreNoexcept<day>();
     AssertComparisons6ReturnBool<day>();
 
     static_assert(testComparisons6Values<day>(0U, 0U), "");
     static_assert(testComparisons6Values<day>(0U, 1U), "");
 
     //  Some 'ok' values as well
     static_assert(testComparisons6Values<day>( 5U,  5U), "");
     static_assert(testComparisons6Values<day>( 5U, 10U), "");
 
     for (unsigned i = 1; i < 10; ++i)
         for (unsigned j = 1; j < 10; ++j)
             assert(testComparisons6Values<day>(i, j));
 
   return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-has-no-localization
-// XFAIL: *
-
-// <chrono>
-// class day;
-
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   operator<<(basic_ostream<charT, traits>& os, const day& d);
-//
-//   Effects: Inserts format(fmt, d) where fmt is "%d" widened to charT.
-//                If !d.ok(), appends with " is not a valid day".
-//
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const day& d);
-//
-//   Effects: Streams d into os using the format specified by the NTCTS fmt.
-//              fmt encoding follows the rules specified in 25.11.
-//
-// template<class charT, class traits, class Alloc = allocator<charT>>
-//   basic_istream<charT, traits>&
-//   from_stream(basic_istream<charT, traits>& is, const charT* fmt,
-//             day& d, basic_string<charT, traits, Alloc>* abbrev = nullptr,
-//             minutes* offset = nullptr);
-//
-//   Effects: Attempts to parse the input stream is into the day d using the format flags
-//             given in the NTCTS fmt as specified in 25.12.
-//             If the parse fails to decode a valid day, is.setstate(ios_base::failbit)
-//             shall be called and d shall not be modified.
-//             If %Z is used and successfully parsed, that value will be assigned to *abbrev
-//             if abbrev is non-null. If %z (or a modified variant) is used and
-//             successfully parsed, that value will be assigned to *offset if offset is non-null.
-//
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-   using day = std::chrono::day;
-   std::cout << day{1};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.members/ok.pass.cpp

for (unsigned i = 1; i <= 12; ++i)
         assert( (month_day{month{i}, day{ 1}}.ok()));
         assert( (month_day{month{i}, day{10}}.ok()));
         assert( (month_day{month{i}, day{29}}.ok()));
         assert( (month_day{month{i}, day{30}}.ok()) == (i != 2));
         assert( (month_day{month{i}, day{31}}.ok()) == is31);
         assert(!(month_day{month{i}, day{32}}.ok()));
     }
 
     //  If the month is not ok, all the days are bad
     for (unsigned i = 1; i <= 35; ++i)
         assert(!(month_day{month{13}, day{i}}.ok()));
 
   return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.pass.cpp

static_assert( testComparisons6(
         month_day{std::chrono::January, day{2}},
         false, true), "");
 
     static_assert( testComparisons6(
         month_day{std::chrono::January,  day{1}},
         month_day{std::chrono::February, day{1}},
         false, true), "");
 
     //  same day, different months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons6(
                 month_day{month{i}, day{1}},
                 month_day{month{j}, day{1}},
                 i == j, i < j )));
 
     //  same month, different days
     for (unsigned i = 1; i < 31; ++i)
         for (unsigned j = 1; j < 31; ++j)
             assert((testComparisons6(
                 month_day{month{2}, day{i}},
                 month_day{month{2}, day{j}},
                 i == j, i < j )));
 
 
   return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.md/time.cal.md.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class month_day;
-
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const month_day& md);
-//
-//     Returns: os << md.month() << '/' << md.day().
-//
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const month_day& md);
-//
-// Effects: Streams md into os using the format specified by the NTCTS fmt.
-//          fmt encoding follows the rules specified in 25.11.
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using month_day = std::chrono::month_day;
-    using month     = std::chrono::month;
-    using day       = std::chrono::day;
-    std::cout << month_day{month{1}, day{1}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.mdlast/comparisons.pass.cpp

int main(int, char**)
     using month_day_last = std::chrono::month_day_last;
 
     AssertComparisons6AreNoexcept<month_day_last>();
     AssertComparisons6ReturnBool<month_day_last>();
 
     static_assert( testComparisons6Values<month_day_last>(month{1}, month{1}), "");
     static_assert( testComparisons6Values<month_day_last>(month{1}, month{2}), "");
 
-//  same day, different months
-    for (unsigned i = 1; i < 12; ++i)
-        for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons6Values<month_day_last>(month{i}, month{j})));
+    // same day, different months
+    for (unsigned i = 1; i <= 12; ++i)
+        for (unsigned j = 1; j <= 12; ++j)
+            assert(testComparisons6Values<month_day_last>(month{i}, month{j}));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.mdlast/ok.pass.cpp

int main(int, char**)
     static_assert( month_day_last{std::chrono::May}.ok(), "");
 
     for (unsigned i = 1; i <= 12; ++i)
     {
         month_day_last mdl{month{i}};
         assert( mdl.ok());
     }
 
     //  If the month is not ok, all the days are bad
     for (unsigned i = 13; i <= 50; ++i)
     {
         month_day_last mdl{month{i}};
         assert(!mdl.ok());
     }
 
   return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.mdlast/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class month_day_last;
-//
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);
-//
-//     Returns: os << mdl.month() << "/last".
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using month_day_last = std::chrono::month_day_last;
-    using month          = std::chrono::month;
-    std::cout << month_day_last{month{1}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.pass.cpp

int main(int, char**)
     using month = std::chrono::month;
 
     AssertComparisons6AreNoexcept<month>();
     AssertComparisons6ReturnBool<month>();
 
     static_assert(testComparisons6Values<month>(0U ,0U), "");
     static_assert(testComparisons6Values<month>(0U, 1U), "");
 
     //  Some 'ok' values as well
     static_assert(testComparisons6Values<month>( 5U,  5U), "");
     static_assert(testComparisons6Values<month>( 5U, 10U), "");
 
-    for (unsigned i = 1; i < 10; ++i)
-        for (unsigned j = 10; j < 10; ++j)
+    for (unsigned i = 1; i <= 12; ++i)
+        for (unsigned j = 1; j <= 12; ++j)
             assert(testComparisons6Values<month>(i, j));
 
   return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/minus.pass.cpp

 #include "test_macros.h"
 
 template <typename M, typename Ms>
 constexpr bool testConstexpr()
 {
     {
     M m{5};
     Ms offset{3};
-    if (m - offset != M{2}) return false;
-    if (m - M{2} != offset) return false;
+    assert(m - offset == M{2});
+    assert(m - M{2} == offset);
     }
 
     //  Check the example
-    if (M{1} - M{2} != Ms{11}) return false;
+    assert(M{1} - M{2} == Ms{11});
+
     return true;
 }
 
 int main(int, char**)
 {
     using month  = std::chrono::month;
     using months = std::chrono::months;
 
     ASSERT_NOEXCEPT(std::declval<month>() - std::declval<months>());
     ASSERT_NOEXCEPT(std::declval<month>() - std::declval<month>());
 
     ASSERT_SAME_TYPE(month , decltype(std::declval<month>() - std::declval<months>()));
     ASSERT_SAME_TYPE(months, decltype(std::declval<month>() - std::declval<month> ()));
 
     static_assert(testConstexpr<month, months>(), "");
 
     month m{6};
     for (unsigned i = 1; i <= 12; ++i)
     {
         month m1   = m - months{i};
-//      months off = m - month {i};
+        // months off = m - month {i};
         int exp = 6 - i;
         if (exp < 1)
             exp += 12;
         assert(static_cast<unsigned>(m1) == static_cast<unsigned>(exp));
-//          assert(off.count()               == static_cast<unsigned>(exp));
+        // assert(off.count()            == static_cast<unsigned>(exp));
     }
 
   return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/plus.pass.cpp

 
 #include "test_macros.h"
 
 template <typename M, typename Ms>
 constexpr bool testConstexpr()
 {
     M m{1};
     Ms offset{4};
-    if (m + offset != M{5}) return false;
-    if (offset + m != M{5}) return false;
+    assert(m + offset == M{5});
+    assert(offset + m == M{5});
     //  Check the example
-    if (M{2} + Ms{11} != M{1}) return false;
+    assert(M{2} + Ms{11} == M{1});
     return true;
 }
 
 int main(int, char**)
 {
     using month  = std::chrono::month;
     using months = std::chrono::months;
 
for (unsigned i = 0; i <= 15; ++i)
         assert(m1 == m2);
         unsigned exp = i + 2;
         while (exp > 12)
             exp -= 12;
         assert(static_cast<unsigned>(m1) == exp);
         assert(static_cast<unsigned>(m2) == exp);
     }
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.month/time.cal.month.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class month;
-
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   operator<<(basic_ostream<charT, traits>& os, const month& m);
-//
-//   Effects: If m.ok() == true inserts format(os.getloc(), fmt, m) where fmt is "%b" widened to charT.
-//   Otherwise inserts int{m} << " is not a valid month".
-//
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const month& m);
-//
-//   Effects: Streams m into os using the format specified by the NTCTS fmt.
-//   fmt encoding follows the rules specified in 25.11.
-//
-// template<class charT, class traits, class Alloc = allocator<charT>>
-//   basic_istream<charT, traits>&
-//   from_stream(basic_istream<charT, traits>& is, const charT* fmt,
-//             month& m, basic_string<charT, traits, Alloc>* abbrev = nullptr,
-//             minutes* offset = nullptr);
-//
-//   Effects: Attempts to parse the input stream is into the month m using the format flags
-//   given in the NTCTS fmt as specified in 25.12. If the parse fails to decode a valid month,
-//   is.setstate(ios_- base::failbit) shall be called and m shall not be modified.
-//   If %Z is used and successfully parsed, that value will be assigned to *abbrev if
-//   abbrev is non-null. If %z (or a modified variant) is used and successfully parsed,
-//   that value will be assigned to *offset if offset is non-null.
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-   using month = std::chrono::month;
-   std::cout << month{1};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/month.pass.cpp

int main(int, char**)
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
 
     constexpr weekday Sunday = std::chrono::Sunday;
 
     ASSERT_NOEXCEPT(                 std::declval<const month_weekday>().month());
     ASSERT_SAME_TYPE(month, decltype(std::declval<const month_weekday>().month()));
 
-    static_assert( month_weekday{}.month() == month{}, "");
-
     for (unsigned i = 1; i <= 50; ++i)
     {
         month_weekday md(month{i}, weekday_indexed{Sunday, 1});
         assert( static_cast<unsigned>(md.month()) == i);
     }
 
   return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.members/ok.pass.cpp

int main(int, char**)
 
     for (unsigned i = 1; i <= 12; ++i)
         for (unsigned j = 0; j <= 6; ++j)
         {
             month_weekday mwd{month{i}, weekday_indexed{Sunday, j}};
             assert(mwd.ok() == (j >= 1 && j <= 5));
         }
 
     //  If the month is not ok, all the weekday_indexed are bad
     for (unsigned i = 1; i <= 10; ++i)
         assert(!(month_weekday{month{13}, weekday_indexed{Sunday, i}}.ok()));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.mwd/time.cal.mwd.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class month_weekday;
-
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
-//
-//     Returns: os << mwd.month() << '/' << mwd.weekday_indexed().
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using month_weekday   = std::chrono::month_weekday;
-    using month           = std::chrono::month;
-    using weekday_indexed = std::chrono::weekday_indexed;
-    using weekday         = std::chrono::weekday;
-
-    std::cout << month_weekday{month{1}, weekday_indexed{weekday{3}, 3}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.members/ctor.pass.cpp

int main(int, char**)
     using weekday_last       = std::chrono::weekday_last;
     using month_weekday_last = std::chrono::month_weekday_last;
 
     constexpr month January = std::chrono::January;
     constexpr weekday Tuesday = std::chrono::Tuesday;
 
     ASSERT_NOEXCEPT(month_weekday_last{January, weekday_last{Tuesday}});
 
     //  bad month
     constexpr month_weekday_last mwdl1{month{}, weekday_last{Tuesday}};
     static_assert( mwdl1.month() == month{},                      "");
     static_assert( mwdl1.weekday_last() == weekday_last{Tuesday}, "");
     static_assert(!mwdl1.ok(),                                    "");
 
     //  bad weekday_last
     constexpr month_weekday_last mwdl2{January, weekday_last{weekday{16}}};
     static_assert( mwdl2.month() == January,                          "");
     static_assert( mwdl2.weekday_last() == weekday_last{weekday{16}}, "");
     static_assert(!mwdl2.ok(),                                        "");
 
     //  Good month and weekday_last
     constexpr month_weekday_last mwdl3{January, weekday_last{weekday{4}}};
     static_assert( mwdl3.month() == January,                         "");
     static_assert( mwdl3.weekday_last() == weekday_last{weekday{4}}, "");
     static_assert( mwdl3.ok(),                                       "");
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/comparisons.pass.cpp

static_assert( testComparisons2(
         month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
         true), "");
 
     static_assert( testComparisons2(
         month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
         month_weekday_last{std::chrono::January, weekday_last{Wednesday}},
         false), "");
 
     //  vary the months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons2(
                 month_weekday_last{month{i}, weekday_last{Tuesday}},
                 month_weekday_last{month{j}, weekday_last{Tuesday}},
             i == j)));
 
     //  vary the weekday
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
             assert((testComparisons2(
                 month_weekday_last{January, weekday_last{weekday{i}}},
                 month_weekday_last{January, weekday_last{weekday{j}}},
             i == j)));
 
     //  both different
-        assert((testComparisons2(
-            month_weekday_last{month{1}, weekday_last{weekday{1}}},
-            month_weekday_last{month{2}, weekday_last{weekday{2}}},
-        false)));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.mwdlast/time.cal.mwdlast.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class month_weekday_last;
-//
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const month_weekday_last& mdl);
-//
-//     Returns: os << mdl.month() << "/last".
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using month_weekday_last = std::chrono::month_weekday_last;
-    using month              = std::chrono::month;
-    using weekday            = std::chrono::weekday;
-    using weekday_last       = std::chrono::weekday_last;
-
-    std::cout << month_weekday_last{month{1}, weekday_last{weekday{3}}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.operators/month_day_last.pass.cpp

 //
 // [Note: A month_day_last object can be constructed using the expression m/last or last/m,
 //     where m is an expression of type month. — end note]
 // [Example:
 //     constexpr auto mdl = February/last; // mdl is the last day of February of an as yet unspecified year
 //     static_assert(mdl.month() == February);
 // --end example]
 
-
-
-
-
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
 int main(int, char**)
 {
     using month          = std::chrono::month;
     using month_day_last = std::chrono::month_day_last;
 
     constexpr month February = std::chrono::February;
     constexpr std::chrono::last_spec last = std::chrono::last;
 
     ASSERT_SAME_TYPE(month_day_last, decltype(last/February));
     ASSERT_SAME_TYPE(month_day_last, decltype(February/last));
 
     //  Run the example
     {
     constexpr auto mdl = February/std::chrono::last;
     static_assert(mdl.month() == February, "");
     }
 
     { // operator/(const month& m, last_spec) and switched
         ASSERT_NOEXCEPT (                         last/February);
         ASSERT_SAME_TYPE(month_day_last, decltype(last/February));
static_assert(mdl.month() == February, "");
             month_day_last mdl2 = i/last;
             assert(mdl1.month() == m);
             assert(mdl2.month() == m);
             assert(mdl1 == mdl2);
         }
     }
 
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.members/ok.pass.cpp

int main(int, char**)
     }
 
     for (unsigned i = 6; i <= 20; ++i)
     {
         weekday_indexed wdi(std::chrono::Tuesday, i);
         assert(!wdi.ok());
     }
 
     //  Not a valid weekday
     assert(!(weekday_indexed(weekday{9U}, 1).ok()));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/comparisons.pass.cpp

int main(int, char**)
     AssertComparisons2ReturnBool<weekday_indexed>();
 
     static_assert( (weekday_indexed{} == weekday_indexed{}), "");
     static_assert(!(weekday_indexed{} != weekday_indexed{}), "");
 
     static_assert(!(weekday_indexed{} == weekday_indexed{std::chrono::Tuesday, 1}), "");
     static_assert( (weekday_indexed{} != weekday_indexed{std::chrono::Tuesday, 1}), "");
 
     //  Some 'ok' values as well
     static_assert( (weekday_indexed{weekday{1}, 2} == weekday_indexed{weekday{1}, 2}), "");
     static_assert(!(weekday_indexed{weekday{1}, 2} != weekday_indexed{weekday{1}, 2}), "");
 
     static_assert(!(weekday_indexed{weekday{1}, 2} == weekday_indexed{weekday{1}, 1}), "");
     static_assert( (weekday_indexed{weekday{1}, 2} != weekday_indexed{weekday{1}, 1}), "");
     static_assert(!(weekday_indexed{weekday{1}, 2} == weekday_indexed{weekday{2}, 2}),  "");
     static_assert( (weekday_indexed{weekday{1}, 2} != weekday_indexed{weekday{2}, 2}),  "");
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.wdidx/time.cal.wdidx.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class weekday_indexed;
-
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
-//
-//   Effects: os << wdi.weekday() << '[' << wdi.index().
-//     If wdi.index() is in the range [1, 5], appends with ']',
-//       otherwise appends with " is not a valid index]".
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using weekday_indexed = std::chrono::weekday_indexed;
-    using weekday         = std::chrono::weekday;
-
-    std::cout << weekday_indexed{weekday{3}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/comparisons.pass.cpp

int main(int, char**)
     using weekday_last = std::chrono::weekday_last;
 
     AssertComparisons2AreNoexcept<weekday_last>();
     AssertComparisons2ReturnBool<weekday_last>();
 
     static_assert(testComparisons2Values<weekday_last>(weekday{0}, weekday{0}), "");
     static_assert(testComparisons2Values<weekday_last>(weekday{0}, weekday{1}), "");
 
     //  Some 'ok' values as well
     static_assert(testComparisons2Values<weekday_last>(weekday{2}, weekday{2}), "");
     static_assert(testComparisons2Values<weekday_last>(weekday{2}, weekday{3}), "");
 
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
             assert(testComparisons2Values<weekday_last>(weekday{i}, weekday{j}));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.wdlast/time.cal.wdlast.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class weekday_last;
-
-//   template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
-//
-//   Returns: os << wdl.weekday() << "[last]".
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-   using weekday_last = std::chrono::weekday_last;
-   using weekday      = std::chrono::weekday;
-
-   std::cout << weekday_last{weekday{3}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/ctor.pass.cpp

int main(int, char**)
     static_assert(m1.c_encoding() == 1, "");
 
     for (unsigned i = 0; i <= 255; ++i)
     {
         weekday m(i);
         assert(m.c_encoding() == (i == 7 ? 0 : i));
     }
 
     // TODO - sys_days and local_days ctor tests
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.members/iso_encoding.pass.cpp

 {
     using weekday = std::chrono::weekday;
 
     ASSERT_NOEXCEPT(                    std::declval<weekday&>().iso_encoding());
     ASSERT_SAME_TYPE(unsigned, decltype(std::declval<weekday&>().iso_encoding()));
 
     static_assert(testConstexpr<weekday>(), "");
 
     //  This is different than all the other tests, because the '7' gets converted to
     //  a zero in the constructor, but then back to '7' by iso_encoding().
     for (unsigned i = 0; i <= 10; ++i)
     {
         weekday wd(i);
         assert(wd.iso_encoding() == (i == 0 ? 7 : i));
     }
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/comparisons.pass.cpp

int main(int, char**)
     using weekday = std::chrono::weekday;
 
     AssertComparisons2AreNoexcept<weekday>();
     AssertComparisons2ReturnBool<weekday>();
 
     static_assert(testComparisons2Values<weekday>(0U ,0U), "");
     static_assert(testComparisons2Values<weekday>(0U, 1U), "");
 
     //  Some 'ok' values as well
     static_assert(testComparisons2Values<weekday>(5U, 5U), "");
     static_assert(testComparisons2Values<weekday>(5U, 2U), "");
 
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
             assert(testComparisons2Values<weekday>(i, j));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/minus.pass.cpp

 //   Returns: x + -y.
 //
 // constexpr days operator-(const weekday& x, const weekday& y) noexcept;
 // Returns: If x.ok() == true and y.ok() == true, returns a value d in the range
 //    [days{0}, days{6}] satisfying y + d == x.
 // Otherwise the value returned is unspecified.
 // [Example: Sunday - Monday == days{6}. —end example]
 
-
-extern "C" int printf(const char *, ...);
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "../../euclidian.h"
 
 template <typename WD, typename Ds>
 constexpr bool testConstexpr()
 {
     {
     WD wd{5};
     Ds offset{3};
-    if (wd - offset != WD{2}) return false;
-    if (wd - WD{2} != offset) return false;
+    assert(wd - offset == WD{2});
+    assert(wd - WD{2} == offset);
     }
 
     //  Check the example
-    if (WD{0} - WD{1} != Ds{6}) return false;
+    assert(WD{0} - WD{1} == Ds{6});
+
     return true;
 }
 
 int main(int, char**)
 {
     using weekday  = std::chrono::weekday;
     using days     = std::chrono::days;
 
     ASSERT_NOEXCEPT(                   std::declval<weekday>() - std::declval<days>());

libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/plus.pass.cpp

 #include "test_macros.h"
 #include "../../euclidian.h"
 
 template <typename M, typename Ms>
 constexpr bool testConstexpr()
 {
     M m{1};
     Ms offset{4};
-    if (m + offset != M{5}) return false;
-    if (offset + m != M{5}) return false;
+    assert(m + offset == M{5});
+    assert(offset + m == M{5});
     //  Check the example
-    if (M{1} + Ms{6} != M{0}) return false;
+    assert(M{1} + Ms{6} == M{0});
     return true;
 }
 
 int main(int, char**)
 {
     using weekday = std::chrono::weekday;
     using days    = std::chrono::days;
 
for (unsigned i = 0; i <= 6; ++i)
         {
             weekday wd1 = weekday{i} + days{j};
             weekday wd2 = days{j} + weekday{i};
             assert(wd1 == wd2);
             assert((wd1.c_encoding() == euclidian_addition<unsigned, 0, 6>(i, j)));
             assert((wd2.c_encoding() == euclidian_addition<unsigned, 0, 6>(i, j)));
         }
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.weekday/time.cal.weekday.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class weekday;
-
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
-//
-//   Effects: If wd.ok() == true inserts format(os.getloc(), fmt, wd) where fmt is "%a" widened to charT.
-//     Otherwise inserts unsigned{wd} << " is not a valid weekday".
-//
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const weekday& wd);
-//
-//   Effects: Streams wd into os using the format specified by the NTCTS fmt.
-//   fmt encoding follows the rules specified in 25.11.
-//
-// template<class charT, class traits, class Alloc = allocator<charT>>
-//   basic_istream<charT, traits>&
-//   from_stream(basic_istream<charT, traits>& is, const charT* fmt,
-//             weekday& wd, basic_string<charT, traits, Alloc>* abbrev = nullptr,
-//             minutes* offset = nullptr);
-//
-//   Effects: Attempts to parse the input stream is into the weekday wd using
-//       the format flags given in the NTCTS fmt as specified in 25.12.
-//     If the parse fails to decode a valid weekday, is.setstate(ios_- base::failbit)
-//       shall be called and wd shall not be modified.
-//     If %Z is used and successfully parsed, that value will be assigned
-//       to *abbrev if abbrev is non-null.
-//     If %z (or a modified variant) is used and successfully parsed,
-//       that value will be assigned to *offset if offset is non-null.
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-   using weekday = std::chrono::weekday;
-
-   std::cout << weekday{3};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.pass.cpp

int main(int, char**)
     using year = std::chrono::year;
 
     AssertComparisons6AreNoexcept<year>();
     AssertComparisons6ReturnBool<year>();
 
     static_assert(testComparisons6Values<year>(0,0), "");
     static_assert(testComparisons6Values<year>(0,1), "");
 
     //  Some 'ok' values as well
     static_assert(testComparisons6Values<year>( 5, 5), "");
     static_assert(testComparisons6Values<year>( 5,10), "");
 
     for (int i = 1; i < 10; ++i)
         for (int j = 1; j < 10; ++j)
             assert(testComparisons6Values<year>(i, j));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/minus.pass.cpp

 //   Returns: x + -y.
 //
 // constexpr years operator-(const year& x, const year& y) noexcept;
 //   Returns: If x.ok() == true and y.ok() == true, returns a value m in the range
 //   [years{0}, years{11}] satisfying y + m == x.
 //   Otherwise the value returned is unspecified.
 //   [Example: January - February == years{11}. —end example]
 
-extern "C" int printf(const char *, ...);
-
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename Y, typename Ys>
 constexpr bool testConstexpr()

libcxx/test/std/utilities/time/time.cal/time.cal.year/time.cal.year.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class year;
-
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   operator<<(basic_ostream<charT, traits>& os, const year& y);
-//
-//   Effects: Inserts format(fmt, y) where fmt is "%Y" widened to charT.
-//   If !y.ok(), appends with " is not a valid year".
-//
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year& y);
-//
-//   Effects: Streams y into os using the format specified by the NTCTS fmt.
-//     fmt encoding follows the rules specified in 25.11.
-//
-// template<class charT, class traits, class Alloc = allocator<charT>>
-//   basic_istream<charT, traits>&
-//   from_stream(basic_istream<charT, traits>& is, const charT* fmt,
-//               year& y, basic_string<charT, traits, Alloc>* abbrev = nullptr,
-//               minutes* offset = nullptr);
-//
-//   Effects: Attempts to parse the input stream is into the year y using the format flags
-//     given in the NTCTS fmt as specified in 25.12. If the parse fails to decode a valid year,
-//     is.setstate(ios_base::failbit) shall be called and y shall not be modified. If %Z is used
-//     and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
-//     If %z (or a modified variant) is used and successfully parsed, that value will be
-//     assigned to *offset if offset is non-null.
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-   using year = std::chrono::year;
-
-   std::cout << year{2018};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.pass.cpp

static_assert( testComparisons6(
         year_month{year{1234}, std::chrono::February},
         false, true), "");
 
     static_assert( testComparisons6(
         year_month{year{1234}, std::chrono::January},
         year_month{year{1235}, std::chrono::January},
         false, true), "");
 
     //  same year, different months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons6(
                 year_month{year{1234}, month{i}},
                 year_month{year{1234}, month{j}},
                 i == j, i < j )));
 
     //  same month, different years
-    for (int i = 1000; i < 20; ++i)
-        for (int j = 1000; j < 20; ++j)
+    for (int i = 1000; i < 2000; ++i)
+        for (int j = 1000; j < 2000; ++j)
         assert((testComparisons6(
             year_month{year{i}, std::chrono::January},
             year_month{year{j}, std::chrono::January},
             i == j, i < j )));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/minus.pass.cpp

int main(int, char**)
     using month      = std::chrono::month;
     using months     = std::chrono::months;
     using year_month = std::chrono::year_month;
 
     {   // year_month - years
     ASSERT_NOEXCEPT(                      std::declval<year_month>() - std::declval<years>());
     ASSERT_SAME_TYPE(year_month, decltype(std::declval<year_month>() - std::declval<years>()));
 
-//  static_assert(testConstexprYears (year_month{year{1}, month{1}}), "");
+    // static_assert(testConstexprYears (year_month{year{1}, month{1}}), "");
 
     year_month ym{year{1234}, std::chrono::January};
     for (int i = 0; i <= 10; ++i)
     {
         year_month ym1 = ym - years{i};
         assert(static_cast<int>(ym1.year()) == 1234 - i);
         assert(ym1.month() == std::chrono::January);
     }
     }
 
     {   // year_month - months
     ASSERT_NOEXCEPT(                      std::declval<year_month>() - std::declval<months>());
     ASSERT_SAME_TYPE(year_month, decltype(std::declval<year_month>() - std::declval<months>()));
 
-//  static_assert(testConstexprMonths(year_month{year{1}, month{1}}), "");
+    // static_assert(testConstexprMonths(year_month{year{1}, month{1}}), "");
 
     year_month ym{year{1234}, std::chrono::November};
     for (int i = 0; i <= 10; ++i)  // TODO test wrap-around
     {
         year_month ym1 = ym - months{i};
         assert(static_cast<int>(ym1.year()) == 1234);
         assert(ym1.month() == month(11 - i));
     }
     }
 
     {   // year_month - year_month
     ASSERT_NOEXCEPT(                  std::declval<year_month>() - std::declval<year_month>());
     ASSERT_SAME_TYPE(months, decltype(std::declval<year_month>() - std::declval<year_month>()));
 
-//  static_assert(testConstexprMonths(year_month{year{1}, month{1}}), "");
+    // static_assert(testConstexprMonths(year_month{year{1}, month{1}}), "");
 
     //  Same year
     year y{2345};
     for (int i = 1; i <= 12; ++i)
         for (int j = 1; j <= 12; ++j)
     {
         months diff = year_month{y, month(i)} - year_month{y, month(j)};
         assert(diff.count() == i - j);
     }
 
-//  TODO: different year
+    // TODO: different year
 
     }
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class year_month;
-
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
-//
-// Returns: os << ym.year() << '/' << ym.month().
-//
-//
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year_month& ym);
-//
-// Effects: Streams ym into os using the format specified by the NTCTS fmt. fmt encoding follows the rules specified in 25.11.
-//
-// template<class charT, class traits, class Alloc = allocator<charT>>
-//     basic_istream<charT, traits>&
-//   from_stream(basic_istream<charT, traits>& is, const charT* fmt,
-//               year_month& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr,
-//               minutes* offset = nullptr);
-//
-// Effects: Attempts to parse the input stream is into the year_month ym using the format
-//         flags given in the NTCTS fmt as specified in 25.12. If the parse fails to decode
-//         a valid year_month, is.setstate(ios_- base::failbit) shall be called and ym shall
-//         not be modified. If %Z is used and successfully parsed, that value will be assigned
-//         to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
-//         successfully parsed, that value will be assigned to *offset if offset is non-null.
-
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using year_month = std::chrono::year_month;
-    using year       = std::chrono::year;
-    using month      = std::chrono::month;
-
-    std::cout << year_month{year{2018}, month{3}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ctor.sys_days.pass.cpp

int main(int, char**)
 
     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});
     }
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/ok.pass.cpp

int main(int, char**)
     static_assert(!year_month_day{year{2019},   January, day{} }.ok(), ""); // Bad day
 
     static_assert(!year_month_day{year{-32768}, month{}, day{1}}.ok(), ""); // Bad year & month
     static_assert(!year_month_day{year{2019},   month{}, day{} }.ok(), ""); // Bad month & day
     static_assert(!year_month_day{year{-32768}, January, day{} }.ok(), ""); // Bad year & day
 
     static_assert( year_month_day{year{2019},   January, day{1}}.ok(), ""); // All OK
 
-//  Some months have a 31st
+    // 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
+    // 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(), "");
int main(int, char**)
 
     const int ymax = static_cast<int>(year::max());
     for (int i = ymax - 100; i <= ymax + 100; ++i)
     {
         year_month_day ym{year{i}, January, day{12}};
         assert( ym.ok() == year{i}.ok());
     }
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.local_days.pass.cpp

int main(int, char**)
     {
     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
+    // 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
     }
 

libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.members/op.sys_days.pass.cpp

int main(int, char**)
     {
     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
+    // 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
     }
 
-//  These two tests check the wording for LWG 3206
+    // These two tests check the wording for LWG 3206
     {
     constexpr year_month_day ymd{year{1971}, month{1}, day{0}}; // bad day
     static_assert(!ymd.ok(),         "");
     static_assert( ymd.year().ok(),  "");
     static_assert( ymd.month().ok(), "");
     static_assert(!ymd.day().ok(),   "");
     constexpr sys_days sd{ymd};
     static_assert(sd.time_since_epoch() == days{364}, "");

libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.pass.cpp

int main(int, char**)
     constexpr month January = std::chrono::January;
     constexpr month February = std::chrono::February;
 
     static_assert( testComparisons6(
         year_month_day{year{1234}, January, day{1}},
         year_month_day{year{1234}, January, day{1}},
         true, false), "");
 
-//  different day
+    // different day
     static_assert( testComparisons6(
         year_month_day{year{1234}, January, day{1}},
         year_month_day{year{1234}, January, day{2}},
         false, true), "");
 
-//  different month
+    // different month
     static_assert( testComparisons6(
         year_month_day{year{1234}, January, day{1}},
         year_month_day{year{1234}, February, day{1}},
         false, true), "");
 
-//  different year
+    // different year
     static_assert( testComparisons6(
         year_month_day{year{1234}, January, day{1}},
         year_month_day{year{1235}, January, day{1}},
         false, true), "");
 
 
-//  different month and day
+    // different month and day
     static_assert( testComparisons6(
         year_month_day{year{1234}, January, day{2}},
         year_month_day{year{1234}, February, day{1}},
         false, true), "");
 
-//  different year and month
+    // different year and month
     static_assert( testComparisons6(
         year_month_day{year{1234}, February, day{1}},
         year_month_day{year{1235}, January, day{1}},
         false, true), "");
 
-//  different year and day
+    // different year and day
     static_assert( testComparisons6(
         year_month_day{year{1234}, January, day{2}},
         year_month_day{year{1235}, January, day{1}},
         false, true), "");
 
-//  different year, month and day
+    // different year, month and day
     static_assert( testComparisons6(
         year_month_day{year{1234}, February, day{2}},
         year_month_day{year{1235}, January, day{1}},
         false, true), "");
 
 
-//  same year, different days
+    // same year, different days
     for (unsigned i = 1; i < 28; ++i)
         for (unsigned j = 1; j < 28; ++j)
             assert((testComparisons6(
                 year_month_day{year{1234}, January, day{i}},
                 year_month_day{year{1234}, January, day{j}},
                 i == j, i < j )));
 
-//  same year, different months
+    // same year, different months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons6(
                 year_month_day{year{1234}, month{i}, day{12}},
                 year_month_day{year{1234}, month{j}, day{12}},
                 i == j, i < j )));
 
-//  same month, different years
-    for (int i = 1000; i < 20; ++i)
-        for (int j = 1000; j < 20; ++j)
+    // same month, different years
+    for (int i = 1000; i < 2000; ++i)
+        for (int j = 1000; j < 2000; ++j)
         assert((testComparisons6(
             year_month_day{year{i}, January, day{12}},
             year_month_day{year{j}, January, day{12}},
             i == j, i < j )));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class year_month_day;
-
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const year_month_day& ym);
-//
-// Returns: os << ym.year() << '/' << ym.month().
-//
-//
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year_month_day& ym);
-//
-// Effects: Streams ym into os using the format specified by the NTCTS fmt. fmt encoding follows the rules specified in 25.11.
-//
-// template<class charT, class traits, class Alloc = allocator<charT>>
-//     basic_istream<charT, traits>&
-//   from_stream(basic_istream<charT, traits>& is, const charT* fmt,
-//               year_month_day& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr,
-//               minutes* offset = nullptr);
-//
-// Effects: Attempts to parse the input stream is into the year_month_day ym using the format
-//         flags given in the NTCTS fmt as specified in 25.12. If the parse fails to decode
-//         a valid year_month_day, is.setstate(ios_- base::failbit) shall be called and ym shall
-//         not be modified. If %Z is used and successfully parsed, that value will be assigned
-//         to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
-//         successfully parsed, that value will be assigned to *offset if offset is non-null.
-
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using year_month_day = std::chrono::year_month_day;
-    using year           = std::chrono::year;
-    using month          = std::chrono::month;
-    using day            = std::chrono::day;
-
-    std::cout << year_month_day{year{2018}, month{3}, day{12}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.members/day.pass.cpp

int main(int, char**)
     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;
 
     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
+    // 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}, "");
 
     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}));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp

int main(int, char**)
     constexpr month January = std::chrono::January;
     constexpr month February = std::chrono::February;
 
     static_assert( testComparisons6(
         year_month_day_last{year{1234}, month_day_last{January}},
         year_month_day_last{year{1234}, month_day_last{January}},
         true, false), "");
 
-//  different month
+    // different month
     static_assert( testComparisons6(
         year_month_day_last{year{1234}, month_day_last{January}},
         year_month_day_last{year{1234}, month_day_last{February}},
         false, true), "");
 
-//  different year
+    // different year
     static_assert( testComparisons6(
         year_month_day_last{year{1234}, month_day_last{January}},
         year_month_day_last{year{1235}, month_day_last{January}},
         false, true), "");
 
-//  different month
+    // different month
     static_assert( testComparisons6(
         year_month_day_last{year{1234}, month_day_last{January}},
         year_month_day_last{year{1234}, month_day_last{February}},
         false, true), "");
 
-//  different year and month
+    // different year and month
     static_assert( testComparisons6(
         year_month_day_last{year{1234}, month_day_last{February}},
         year_month_day_last{year{1235}, month_day_last{January}},
         false, true), "");
 
-//  same year, different months
+    // same year, different months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons6(
                 year_month_day_last{year{1234}, month_day_last{month{i}}},
                 year_month_day_last{year{1234}, month_day_last{month{j}}},
                 i == j, i < j )));
 
-//  same month, different years
-    for (int i = 1000; i < 20; ++i)
-        for (int j = 1000; j < 20; ++j)
+    // same month, different years
+    for (int i = 1000; i < 2000; ++i)
+        for (int j = 1000; j < 2000; ++j)
         assert((testComparisons6(
             year_month_day_last{year{i}, month_day_last{January}},
             year_month_day_last{year{j}, month_day_last{January}},
             i == j, i < j )));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/minus.pass.cpp

int main(int, char**)
     }
     }
 
     { // year_month_day_last - months
     ASSERT_NOEXCEPT(                               std::declval<year_month_day_last>() - std::declval<months>());
     ASSERT_SAME_TYPE(year_month_day_last, decltype(std::declval<year_month_day_last>() - std::declval<months>()));
 
     static_assert(testConstexprMonths(year_month_day_last{year{1234}, month_day_last{December}}), "");
-//  TODO test wrapping
+    // TODO test wrapping
     year_month_day_last ym{year{1234}, month_day_last{December}};
     for (unsigned i = 0; i <= 10; ++i)
     {
         year_month_day_last ym1 = ym - months{i};
         assert(static_cast<int>(ym1.year()) == 1234);
         assert(static_cast<unsigned>(ym1.month()) == 12U-i);
     }
     }
 
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class year_month_day_last;
-
-// template<class charT, class traits>
-//   basic_ostream<charT, traits>&
-//   operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
-//
-// Returns: os << ymdl.year() << '/' << ymdl.month_day_last().
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using year_month_day_last = std::chrono::year_month_day_last;
-    using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using month_day_last      = std::chrono::month_day_last;
-
-    std::cout << year_month_day_last{year{2018}, month_day_last{month{3}}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.local_days.pass.cpp

int main(int, char**)
     {
     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
+    // 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
     }
 

libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.members/op.sys_days.pass.cpp

int main(int, char**)
     {
     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
+    // 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
     }
 

libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp

int main(int, char**)
     constexpr month February  = std::chrono::February;
     constexpr weekday Tuesday = std::chrono::Tuesday;
 
     static_assert( testComparisons2(
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
         true), "");
 
-//  different day
+    // different day
     static_assert( testComparisons2(
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 2}},
         false), "");
 
-//  different month
+    // different month
     static_assert( testComparisons2(
         year_month_weekday{year{1234}, January,  weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1234}, February, weekday_indexed{Tuesday, 1}},
         false), "");
 
-//  different year
+    // different year
     static_assert( testComparisons2(
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1235}, January, weekday_indexed{Tuesday, 1}},
         false), "");
 
 
-//  different month and day
+    // different month and day
     static_assert( testComparisons2(
         year_month_weekday{year{1234}, January,  weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1234}, February, weekday_indexed{Tuesday, 2}},
         false), "");
 
-//  different year and month
+    // different year and month
     static_assert( testComparisons2(
         year_month_weekday{year{1234}, February, weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1235}, January,  weekday_indexed{Tuesday, 1}},
         false), "");
 
-//  different year and day
+    // different year and day
     static_assert( testComparisons2(
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 2}},
         year_month_weekday{year{1235}, January, weekday_indexed{Tuesday, 1}},
         false), "");
 
-//  different year, month and day
+    // different year, month and day
     static_assert( testComparisons2(
         year_month_weekday{year{1234}, February, weekday_indexed{Tuesday, 2}},
         year_month_weekday{year{1235}, January,  weekday_indexed{Tuesday, 1}},
         false), "");
 
 
-//  same year, different days
+    // same year, different days
     for (unsigned i = 1; i < 28; ++i)
         for (unsigned j = 1; j < 28; ++j)
             assert((testComparisons2(
                 year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, i}},
                 year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, j}},
                 i == j)));
 
-//  same year, different months
+    // same year, different months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons2(
                 year_month_weekday{year{1234}, month{i}, weekday_indexed{Tuesday, 1}},
                 year_month_weekday{year{1234}, month{j}, weekday_indexed{Tuesday, 1}},
                 i == j)));
 
-//  same month, different years
-    for (int i = 1000; i < 20; ++i)
-        for (int j = 1000; j < 20; ++j)
+    // same month, different years
+    for (int i = 1000; i < 2000; ++i)
+        for (int j = 1000; j < 2000; ++j)
         assert((testComparisons2(
             year_month_weekday{year{i}, January, weekday_indexed{Tuesday, 1}},
             year_month_weekday{year{j}, January, weekday_indexed{Tuesday, 1}},
             i == j)));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class year_month_weekday;
-
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ym);
-//
-// Returns: os << ym.year() << '/' << ym.month().
-//
-//
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year_month_weekday& ym);
-//
-// Effects: Streams ym into os using the format specified by the NTCTS fmt. fmt encoding follows the rules specified in 25.11.
-//
-// template<class charT, class traits, class Alloc = allocator<charT>>
-//     basic_istream<charT, traits>&
-//   from_stream(basic_istream<charT, traits>& is, const charT* fmt,
-//               year_month_weekday& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr,
-//               minutes* offset = nullptr);
-//
-// Effects: Attempts to parse the input stream is into the year_month_weekday ym using the format
-//         flags given in the NTCTS fmt as specified in 25.12. If the parse fails to decode
-//         a valid year_month_weekday, is.setstate(ios_- base::failbit) shall be called and ym shall
-//         not be modified. If %Z is used and successfully parsed, that value will be assigned
-//         to *abbrev if abbrev is non-null. If %z (or a modified variant) is used and
-//         successfully parsed, that value will be assigned to *offset if offset is non-null.
-
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using year_month_weekday = std::chrono::year_month_weekday;
-    using year                = std::chrono::year;
-    using month               = std::chrono::month;
-    using weekday             = std::chrono::weekday;
-
-    std::cout << year_month_weekday{year{2018}, month{3}, weekday{4}};
-
-  return 0;
-}

libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp

int main(int, char**)
     constexpr weekday Tuesday = std::chrono::Tuesday;
     constexpr weekday Wednesday = std::chrono::Wednesday;
 
     static_assert( testComparisons2(
         year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
         year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
         true), "");
 
-//  different day
+    // different day
     static_assert( testComparisons2(
         year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
         year_month_weekday_last{year{1234}, January, weekday_last{Wednesday}},
         false), "");
 
-//  different month
+    // different month
     static_assert( testComparisons2(
         year_month_weekday_last{year{1234}, January,  weekday_last{Tuesday}},
         year_month_weekday_last{year{1234}, February, weekday_last{Tuesday}},
         false), "");
 
-//  different year
+    // different year
     static_assert( testComparisons2(
         year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
         year_month_weekday_last{year{1235}, January, weekday_last{Tuesday}},
         false), "");
 
 
-//  different month and day
+    // different month and day
     static_assert( testComparisons2(
         year_month_weekday_last{year{1234}, January,  weekday_last{Tuesday}},
         year_month_weekday_last{year{1234}, February, weekday_last{Wednesday}},
         false), "");
 
-//  different year and month
+    // different year and month
     static_assert( testComparisons2(
         year_month_weekday_last{year{1234}, February, weekday_last{Tuesday}},
         year_month_weekday_last{year{1235}, January,  weekday_last{Tuesday}},
         false), "");
 
-//  different year and day
+    // different year and day
     static_assert( testComparisons2(
         year_month_weekday_last{year{1234}, January, weekday_last{Wednesday}},
         year_month_weekday_last{year{1235}, January, weekday_last{Tuesday}},
         false), "");
 
-//  different year, month and day
+    // different year, month and day
     static_assert( testComparisons2(
         year_month_weekday_last{year{1234}, February, weekday_last{Wednesday}},
         year_month_weekday_last{year{1235}, January,  weekday_last{Tuesday}},
         false), "");
 
 
-//  same year, different days
+    // same year, different days
     for (unsigned i = 1; i < 28; ++i)
         for (unsigned j = 1; j < 28; ++j)
             assert((testComparisons2(
                 year_month_weekday_last{year{1234}, January, weekday_last{weekday{i}}},
                 year_month_weekday_last{year{1234}, January, weekday_last{weekday{j}}},
                 i == j)));
 
-//  same year, different months
+    // same year, different months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
             assert((testComparisons2(
                 year_month_weekday_last{year{1234}, month{i}, weekday_last{Tuesday}},
                 year_month_weekday_last{year{1234}, month{j}, weekday_last{Tuesday}},
                 i == j)));
 
-//  same month, different years
-    for (int i = 1000; i < 20; ++i)
-        for (int j = 1000; j < 20; ++j)
+    // same month, different years
+    for (int i = 1000; i < 2000; ++i)
+        for (int j = 1000; j < 2000; ++j)
         assert((testComparisons2(
             year_month_weekday_last{year{i}, January, weekday_last{Tuesday}},
             year_month_weekday_last{year{j}, January, weekday_last{Tuesday}},
             i == j)));
 
     return 0;
 }

libcxx/test/std/utilities/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/streaming.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-// XFAIL: *
-
-// <chrono>
-// class year_month_weekday_last;
-
-// template<class charT, class traits>
-//     basic_ostream<charT, traits>&
-//     operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
-//
-//   Returns: os << ymwdl.year() << '/' << ymwdl.month() << '/' << ymwdl.weekday_last().
-
-
-#include <chrono>
-#include <type_traits>
-#include <cassert>
-#include <iostream>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    using year_month_weekday_last = std::chrono::year_month_weekday_last;
-    using year                    = std::chrono::year;
-    using month                   = std::chrono::month;
-    using weekday                 = std::chrono::weekday;
-    using weekday_last            = std::chrono::weekday_last;
-
-    std::cout << year_month_weekday_last{year{2018}, month{3}, weekday_last{weekday{4}}};
-
-  return 0;
-}