[libc++][chrono] Uses operator<=> in the calendar.

[Mordante]

Summary

Since the calendar is added in C++20 the existing operators are removed.

Implements part of:

• P1614R2 The Mothership has Landed

[ldionne]

libcxx/include/__chrono/year_month.h

62–80

Is this an omission?

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

53–56

Let's just always use 1010, I don't think we gain any fundamental coverage by doing more than that (do you agree?).

And in fact, we probably also want to test boundary values (at least year{0} and year{1}) if we don't already.

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

102

Same comment about number of steps and boundary values.

[Mordante]

Thanks for the review!

libcxx/include/__chrono/year_month.h

62–80

Yes, thanks for spotting the issue.

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

53–56

I'll change the range to -5 to 5. Same for the next one.

[Mordante]

Rebased and addresses the review comments.
I will land this after the CI is happy.

libcxx/docs/Status/SpaceshipProjects.csv

 | `[queue.ops] <https://wg21.link/queue.ops>`_,| queue,None,Unassigned,|Not Started|
 | `[stack.ops] <https://wg21.link/stack.ops>`_,| stack,None,Unassigned,|Not Started|
 | `[reverse.iter.cmp] <https://wg21.link/reverse.iter.cmp>`_,| reverse_iterator,None,Mikhail Maltsev,|Complete|
 | `[move.iter.op.comp] <https://wg21.link/move.iter.op.comp>`_,| move_iterator,None,Unassigned,|Not Started|
 | `[counted.iter.cmp] <https://wg21.link/counted.iter.cmp>`_,| counted_iterator,None,Unassigned,|Not Started|
 | `[range.iota.iterator] <https://wg21.link/range.iota.iterator>`_,| ranges::iota_view::iterator,[concepts.cmp],Unassigned,|Not Started|
 | `[range.transform.iterator] <https://wg21.link/range.transform.iterator>`_,| ranges::transform_view::iterator,[concepts.cmp],Unassigned,|Not Started|
 | `[range.elements.iterator] <https://wg21.link/range.elements.iterator>`_,| ranges::elements_view::iterator,[concepts.cmp],Unassigned,|Not Started|
-"| `[time.duration.comparisons] <https://wg21.link/time.duration.comparisons>`_
-| `[time.point.comparisons] <https://wg21.link/time.point.comparisons>`_
-| `[time.cal.day.nonmembers] <https://wg21.link/time.cal.day.nonmembers>`_
+| `[time.duration.comparisons] <https://wg21.link/time.duration.comparisons>`_, "chrono::duration", None, Mark de Wever, |Not Started|
+| `[time.point.comparisons] <https://wg21.link/time.point.comparisons>`_, "chrono::point", None, Mark de Wever, |Not Started|
+"| `[time.cal.day.nonmembers] <https://wg21.link/time.cal.day.nonmembers>`_
 | `[time.cal.month.nonmembers] <https://wg21.link/time.cal.month.nonmembers>`_
 | `[time.cal.year.nonmembers] <https://wg21.link/time.cal.year.nonmembers>`_
 | `[time.cal.md.nonmembers] <https://wg21.link/time.cal.md.nonmembers>`_
 | `[time.cal.mdlast] <https://wg21.link/time.cal.mdlast>`_
 | `[time.cal.ym.nonmembers] <https://wg21.link/time.cal.ym.nonmembers>`_
 | `[time.cal.ymd.nonmembers] <https://wg21.link/time.cal.ymd.nonmembers>`_
-| `[time.cal.ymdlast.nonmembers] <https://wg21.link/time.cal.ymdlast.nonmembers>`_
-| `[time.zone.nonmembers] <https://wg21.link/time.zone.nonmembers>`_
-| `[time.zone.leap.nonmembers] <https://wg21.link/time.zone.leap.nonmembers>`_
-| `[time.zone.link.nonmembers] <https://wg21.link/time.zone.link.nonmembers>`_","| chrono::duration
-| chrono::time_point
-| chrono::day
+| `[time.cal.ymdlast.nonmembers] <https://wg21.link/time.cal.ymdlast.nonmembers>`_","| chrono::day
 | chrono::month
 | chrono::year
 | chrono::month_day
 | chrono::month_day_last
 | chrono::year_month
 | chrono::year_month_day
-| chrono::year_month_day_last
-| chrono::time_zone
+| chrono::year_month_day_last",None,Mark de Wever,|Complete|
+"| `[time.zone.nonmembers] <https://wg21.link/time.zone.nonmembers>`_
+| `[time.zone.leap.nonmembers] <https://wg21.link/time.zone.leap.nonmembers>`_
+| `[time.zone.link.nonmembers] <https://wg21.link/time.zone.link.nonmembers>`_","| chrono::time_zone
 | chrono::leap_second
-| chrono::time_zone_link",None,Unassigned,|Not Started|
+| chrono::time_zone_link",A ``<chrono>`` implementation,Unassigned,|Not Started|
 | `[fs.path.nonmember] <https://wg21.link/fs.path.nonmember>`_,| filesystem::path,None,Unassigned,|Not Started|
 | `[fs.dir.entry.obs] <https://wg21.link/fs.dir.entry.obs>`_,| filesystem::directory_entry,None,Unassigned,|Not Started|
 | `[re.submatch.op] <https://wg21.link/re.submatch.op>`_,| sub_match,None,Unassigned,|Not Started|
 | `[thread.thread.id] <https://wg21.link/thread.thread.id>`_,| thread::id,None,Unassigned,|Not Started|

libcxx/include/__chrono/month.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___CHRONO_MONTH_H
 #define _LIBCPP___CHRONO_MONTH_H
 
 #include <__chrono/duration.h>
 #include <__config>
+#include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
public:
     _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m >= 1 && __m <= 12; }
 };
 
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator==(const month& __lhs, const month& __rhs) noexcept
 { return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const month& __lhs, const month& __rhs) noexcept
-{ return !(__lhs == __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator< (const month& __lhs, const month& __rhs) noexcept
-{ return static_cast<unsigned>(__lhs)  < static_cast<unsigned>(__rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator> (const month& __lhs, const month& __rhs) noexcept
-{ return __rhs < __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator<=(const month& __lhs, const month& __rhs) noexcept
-{ return !(__rhs < __lhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator>=(const month& __lhs, const month& __rhs) noexcept
-{ return !(__lhs < __rhs); }
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const month& __lhs, const month& __rhs) noexcept {
+    return static_cast<unsigned>(__lhs) <=> static_cast<unsigned>(__rhs);
+}
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 month operator+ (const month& __lhs, const months& __rhs) noexcept
 {
     auto const __mu = static_cast<long long>(static_cast<unsigned>(__lhs)) + (__rhs.count() - 1);
     auto const __yr = (__mu >= 0 ? __mu : __mu - 11) / 12;
     return month{static_cast<unsigned>(__mu - __yr * 12 + 1)};
 }

libcxx/include/__chrono/monthday.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___CHRONO_MONTHDAY_H
 #define _LIBCPP___CHRONO_MONTHDAY_H
 
 #include <__chrono/calendar.h>
 #include <__chrono/day.h>
 #include <__chrono/month.h>
 #include <__config>
+#include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD
if (__mval == 4 || __mval == 6 || __mval == 9 || __mval == 11)
         return __dval == 30;
     return true;
 }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator==(const month_day& __lhs, const month_day& __rhs) noexcept
 { return __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const month_day& __lhs, const month_day& __rhs) noexcept
-{ return !(__lhs == __rhs); }
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const month_day& __lhs, const month_day& __rhs) noexcept {
+    if (auto __c = __lhs.month() <=> __rhs.month(); __c != 0)
+        return __c;
+    return __lhs.day() <=> __rhs.day();
+}
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 month_day operator/(const month& __lhs, const day& __rhs) noexcept
 { return month_day{__lhs, __rhs}; }
 
 _LIBCPP_HIDE_FROM_ABI constexpr
 month_day operator/(const day& __lhs, const month& __rhs) noexcept
 { return __rhs / __lhs; }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 month_day operator/(const month& __lhs, int __rhs) noexcept
 { return __lhs / day(__rhs); }
 
 _LIBCPP_HIDE_FROM_ABI constexpr
 month_day operator/(int __lhs, const day& __rhs) noexcept
 { return month(__lhs) / __rhs; }
 
 _LIBCPP_HIDE_FROM_ABI constexpr
 month_day operator/(const day& __lhs, int __rhs) noexcept
 { return month(__rhs) / __lhs; }
 
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator< (const month_day& __lhs, const month_day& __rhs) noexcept
-{ return __lhs.month() != __rhs.month() ? __lhs.month() < __rhs.month() : __lhs.day() < __rhs.day(); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator> (const month_day& __lhs, const month_day& __rhs) noexcept
-{ return __rhs < __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator<=(const month_day& __lhs, const month_day& __rhs) noexcept
-{ return !(__rhs < __lhs);}
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator>=(const month_day& __lhs, const month_day& __rhs) noexcept
-{ return !(__lhs < __rhs); }
-
-
-
 class month_day_last {
 private:
     chrono::month __m;
 public:
     _LIBCPP_HIDE_FROM_ABI explicit constexpr month_day_last(const chrono::month& __val) noexcept
         : __m{__val} {}
     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m; }
     _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m.ok(); }
 };
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator==(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
 { return __lhs.month() == __rhs.month(); }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
-{ return !(__lhs == __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator< (const month_day_last& __lhs, const month_day_last& __rhs) noexcept
-{ return __lhs.month() < __rhs.month(); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator> (const month_day_last& __lhs, const month_day_last& __rhs) noexcept
-{ return __rhs < __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator<=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
-{ return !(__rhs < __lhs);}
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator>=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
-{ return !(__lhs < __rhs); }
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering
+operator<=>(const month_day_last& __lhs, const month_day_last& __rhs) noexcept {
+    return __lhs.month() <=> __rhs.month();
+}
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 month_day_last operator/(const month& __lhs, last_spec) noexcept
 { return month_day_last{__lhs}; }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 month_day_last operator/(last_spec, const month& __rhs) noexcept
 { return month_day_last{__rhs}; }

libcxx/include/__chrono/year.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___CHRONO_YEAR_H
 #define _LIBCPP___CHRONO_YEAR_H
 
 #include <__chrono/duration.h>
 #include <__config>
+#include <compare>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
public:
     _LIBCPP_HIDE_FROM_ABI static inline constexpr year max() noexcept { return year{ 32767}; }
 };
 
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator==(const year& __lhs, const year& __rhs) noexcept
 { return static_cast<int>(__lhs) == static_cast<int>(__rhs); }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const year& __lhs, const year& __rhs) noexcept
-{ return !(__lhs == __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator< (const year& __lhs, const year& __rhs) noexcept
-{ return static_cast<int>(__lhs)  < static_cast<int>(__rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator> (const year& __lhs, const year& __rhs) noexcept
-{ return __rhs < __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator<=(const year& __lhs, const year& __rhs) noexcept
-{ return !(__rhs < __lhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator>=(const year& __lhs, const year& __rhs) noexcept
-{ return !(__lhs < __rhs); }
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const year& __lhs, const year& __rhs) noexcept {
+    return static_cast<int>(__lhs) <=> static_cast<int>(__rhs);
+}
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 year operator+ (const year& __lhs, const years& __rhs) noexcept
 { return year(static_cast<int>(__lhs) + __rhs.count()); }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 year operator+ (const years& __lhs, const year& __rhs) noexcept
 { return __rhs + __lhs; }

libcxx/include/__chrono/year_month.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___CHRONO_YEAR_MONTH_H
 #define _LIBCPP___CHRONO_YEAR_MONTH_H
 
 #include <__chrono/duration.h>
 #include <__chrono/month.h>
 #include <__chrono/year.h>
 #include <__config>
+#include <compare>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 year_month operator/(const year& __y, int __m) noexcept { return year_month{__y, month(__m)}; }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator==(const year_month& __lhs, const year_month& __rhs) noexcept
 { return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month(); }
 
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const year_month& __lhs, const year_month& __rhs) noexcept {
+    if (auto __c = __lhs.year() <=> __rhs.year(); __c != 0)
+      return __c;
+    return __lhs.month() <=> __rhs.month();
+}
+
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator!=(const year_month& __lhs, const year_month& __rhs) noexcept
 { return !(__lhs == __rhs); }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator< (const year_month& __lhs, const year_month& __rhs) noexcept
 { return __lhs.year() != __rhs.year() ? __lhs.year() < __rhs.year() : __lhs.month() < __rhs.month(); }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator> (const year_month& __lhs, const year_month& __rhs) noexcept
 { return __rhs < __lhs; }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator<=(const year_month& __lhs, const year_month& __rhs) noexcept
 { return !(__rhs < __lhs);}
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator>=(const year_month& __lhs, const year_month& __rhs) noexcept
 { return !(__lhs < __rhs); }
 
 _LIBCPP_HIDE_FROM_ABI constexpr
 year_month operator+(const year_month& __lhs, const months& __rhs) noexcept
 {
     int __dmi = static_cast<int>(static_cast<unsigned>(__lhs.month())) - 1 + __rhs.count();
     const int __dy = (__dmi >= 0 ? __dmi : __dmi-11) / 12;
     __dmi = __dmi - __dy * 12 + 1;
     return (__lhs.year() + years(__dy)) / month(static_cast<unsigned>(__dmi));

libcxx/include/__chrono/year_month_day.h

 #include <__chrono/duration.h>
 #include <__chrono/month.h>
 #include <__chrono/monthday.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
 #include <__chrono/year.h>
 #include <__chrono/year_month.h>
 #include <__config>
+#include <compare>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17
 
days year_month_day::__to_days() const noexcept
     const unsigned __doe = __yoe * 365 + __yoe/4 - __yoe/100 + __doy;                // [0, 146096]
     return days{__era * 146097 + static_cast<int>(__doe) - 719468};
 }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 bool operator==(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
 { return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
-{ return !(__lhs == __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator< (const year_month_day& __lhs, const year_month_day& __rhs) noexcept
-{
-    if (__lhs.year() < __rhs.year()) return true;
-    if (__lhs.year() > __rhs.year()) return false;
-    if (__lhs.month() < __rhs.month()) return true;
-    if (__lhs.month() > __rhs.month()) return false;
-    return __lhs.day() < __rhs.day();
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering
+operator<=>(const year_month_day& __lhs, const year_month_day& __rhs) noexcept {
+    if (auto __c = __lhs.year() <=> __rhs.year(); __c != 0)
+      return __c;
+    if (auto __c = __lhs.month() <=> __rhs.month(); __c != 0)
+      return __c;
+    return __lhs.day() <=> __rhs.day();
 }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator> (const year_month_day& __lhs, const year_month_day& __rhs) noexcept
-{ return __rhs < __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator<=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
-{ return !(__rhs < __lhs);}
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator>=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
-{ return !(__lhs < __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
 year_month_day operator/(const year_month& __lhs, const day& __rhs) noexcept
 { return year_month_day{__lhs.year(), __lhs.month(), __rhs}; }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr
 year_month_day operator/(const year_month& __lhs, int __rhs) noexcept
 { return __lhs / day(__rhs); }
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr

libcxx/include/chrono

 constexpr day  operator+(const day&  x, const days& y) noexcept;
 constexpr day  operator+(const days& x, const day&  y) noexcept;
 constexpr day  operator-(const day&  x, const days& y) noexcept;
 constexpr days operator-(const day&  x, const day&  y) noexcept;
 
 // 25.8.4, class month    // C++20
 class month;
 constexpr bool operator==(const month& x, const month& y) noexcept;
-constexpr bool operator!=(const month& x, const month& y) noexcept;
-constexpr bool operator< (const month& x, const month& y) noexcept;
-constexpr bool operator> (const month& x, const month& y) noexcept;
-constexpr bool operator<=(const month& x, const month& y) noexcept;
-constexpr bool operator>=(const month& x, const month& y) noexcept;
+constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
+
 constexpr month  operator+(const month&  x, const months& y) noexcept;
 constexpr month  operator+(const months& x,  const month& y) noexcept;
 constexpr month  operator-(const month&  x, const months& y) noexcept;
 constexpr months operator-(const month&  x,  const month& y) noexcept;
 
 // 25.8.5, class year    // C++20
 class year;
 constexpr bool operator==(const year& x, const year& y) noexcept;
-constexpr bool operator!=(const year& x, const year& y) noexcept;
-constexpr bool operator< (const year& x, const year& y) noexcept;
-constexpr bool operator> (const year& x, const year& y) noexcept;
-constexpr bool operator<=(const year& x, const year& y) noexcept;
-constexpr bool operator>=(const year& x, const year& y) noexcept;
+constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
+
 constexpr year  operator+(const year&  x, const years& y) noexcept;
 constexpr year  operator+(const years& x, const year&  y) noexcept;
 constexpr year  operator-(const year&  x, const years& y) noexcept;
 constexpr years operator-(const year&  x, const year&  y) noexcept;
 
 // 25.8.6, class weekday    // C++20
 class weekday;
 

 
 constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
 constexpr bool operator!=(const weekday_last& x, const weekday_last& y) noexcept;
 
 // 25.8.9, class month_day    // C++20
 class month_day;
 
 constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
-constexpr bool operator!=(const month_day& x, const month_day& y) noexcept;
-constexpr bool operator< (const month_day& x, const month_day& y) noexcept;
-constexpr bool operator> (const month_day& x, const month_day& y) noexcept;
-constexpr bool operator<=(const month_day& x, const month_day& y) noexcept;
-constexpr bool operator>=(const month_day& x, const month_day& y) noexcept;
+constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
 
 
 // 25.8.10, class month_day_last    // C++20
 class month_day_last;
 
 constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
-constexpr bool operator!=(const month_day_last& x, const month_day_last& y) noexcept;
-constexpr bool operator< (const month_day_last& x, const month_day_last& y) noexcept;
-constexpr bool operator> (const month_day_last& x, const month_day_last& y) noexcept;
-constexpr bool operator<=(const month_day_last& x, const month_day_last& y) noexcept;
-constexpr bool operator>=(const month_day_last& x, const month_day_last& y) noexcept;
+constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
 
 // 25.8.11, class month_weekday    // C++20
 class month_weekday;
 
 constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
 constexpr bool operator!=(const month_weekday& x, const month_weekday& y) noexcept;
 
 // 25.8.12, class month_weekday_last    // C++20
 class month_weekday_last;
 
 constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
 constexpr bool operator!=(const month_weekday_last& x, const month_weekday_last& y) noexcept;
 
 
 // 25.8.13, class year_month    // C++20
 class year_month;
 
 constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
-constexpr bool operator!=(const year_month& x, const year_month& y) noexcept;
-constexpr bool operator< (const year_month& x, const year_month& y) noexcept;
-constexpr bool operator> (const year_month& x, const year_month& y) noexcept;
-constexpr bool operator<=(const year_month& x, const year_month& y) noexcept;
-constexpr bool operator>=(const year_month& x, const year_month& y) noexcept;
+constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
 
 constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
 constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
 constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
 constexpr months operator-(const year_month& x, const year_month& y) noexcept;
 constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
 constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
 constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
 
 // 25.8.14, class year_month_day class    // C++20
 year_month_day;
 
 constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
-constexpr bool operator!=(const year_month_day& x, const year_month_day& y) noexcept;
-constexpr bool operator< (const year_month_day& x, const year_month_day& y) noexcept;
-constexpr bool operator> (const year_month_day& x, const year_month_day& y) noexcept;
-constexpr bool operator<=(const year_month_day& x, const year_month_day& y) noexcept;
-constexpr bool operator>=(const year_month_day& x, const year_month_day& y) noexcept;
+constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
 
 constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
 constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
 constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
 constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
 constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
 constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
 
 
 // 25.8.15, class year_month_day_last    // C++20
 class year_month_day_last;
 
-constexpr bool operator==(const year_month_day_last& x,
-                          const year_month_day_last& y) noexcept;
-constexpr bool operator!=(const year_month_day_last& x,
-                          const year_month_day_last& y) noexcept;
-constexpr bool operator< (const year_month_day_last& x,
-                          const year_month_day_last& y) noexcept;
-constexpr bool operator> (const year_month_day_last& x,
-                          const year_month_day_last& y) noexcept;
-constexpr bool operator<=(const year_month_day_last& x,
-                          const year_month_day_last& y) noexcept;
-constexpr bool operator>=(const year_month_day_last& x,
-                          const year_month_day_last& y) noexcept;
+constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
+constexpr strong_ordering operator<=>(const year_month_day_last_day& x, const year_month_day_last_day& y) noexcept;
 
 constexpr year_month_day_last
   operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
 constexpr year_month_day_last
   operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
 constexpr year_month_day_last
   operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
 constexpr year_month_day_last

libcxx/test/std/time/time.cal/time.cal.md/time.cal.md.nonmembers/comparisons.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
 
 // <chrono>
 // class month_day;
 
 // constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
-//   Returns: x.month() == y.month() && x.day() == y.day().
-//
-// constexpr bool operator< (const month_day& x, const month_day& y) noexcept;
-//   Returns:
-//      If x.month() < y.month() returns true.
-//      Otherwise, if x.month() > y.month() returns false.
-//      Otherwise, returns x.day() < y.day().
+// constexpr strong_comparison operator<=>(const month_day& x, const month_day& y) noexcept;
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main(int, char**)
-{
-    using day       = std::chrono::day;
-    using month     = std::chrono::month;
-    using month_day = std::chrono::month_day;
+constexpr bool test() {
 
-    AssertComparisonsAreNoexcept<month_day>();
-    AssertComparisonsReturnBool<month_day>();
+  assert(testOrder(
+      month_day{std::chrono::January, day{1}}, month_day{std::chrono::January, day{1}}, std::strong_ordering::equal));
+
+  assert(testOrder(
+      month_day{std::chrono::January, day{1}}, month_day{std::chrono::January, day{2}}, std::strong_ordering::less));
 
-    static_assert( testComparisons(
-        month_day{std::chrono::January, day{1}},
-        month_day{std::chrono::January, day{1}},
-        true, false), "");
-
-    static_assert( testComparisons(
-        month_day{std::chrono::January, day{1}},
-        month_day{std::chrono::January, day{2}},
-        false, true), "");
-
-    static_assert( testComparisons(
-        month_day{std::chrono::January,  day{1}},
-        month_day{std::chrono::February, day{1}},
-        false, true), "");
+  assert(testOrder(
+      month_day{std::chrono::January, day{1}}, month_day{std::chrono::February, day{1}}, std::strong_ordering::less));
 
-    //  same day, different months
-    for (unsigned i = 1; i < 12; ++i)
-        for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons(
-                month_day{month{i}, day{1}},
-                month_day{month{j}, day{1}},
-                i == j, i < j )));
+      assert((testOrder(
+          i == j  ? std::strong_ordering::equal
+          : i < j ? std::strong_ordering::less
+                  : std::strong_ordering::greater)));
 
-    //  same month, different days
-    for (unsigned i = 1; i < 31; ++i)
-        for (unsigned j = 1; j < 31; ++j)
-            assert((testComparisons(
-                month_day{month{2}, day{i}},
-                month_day{month{2}, day{j}},
-                i == j, i < j )));
+      assert((testOrder(
+          i == j  ? std::strong_ordering::equal
+          : i < j ? std::strong_ordering::less
+                  : std::strong_ordering::greater)));
+
+  return true;
+}
+
+int main(int, char**) {
+  using month_day = std::chrono::month_day;
+  AssertOrderAreNoexcept<month_day>();
+  AssertOrderReturn<std::strong_ordering, month_day>();
 
+  test();
+  static_assert(test());
 
   return 0;
 }

libcxx/test/std/time/time.cal/time.cal.month/time.cal.month.nonmembers/comparisons.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
 
 // <chrono>
 // class month;
 
 // constexpr bool operator==(const month& x, const month& y) noexcept;
-// constexpr bool operator!=(const month& x, const month& y) noexcept;
-// constexpr bool operator< (const month& x, const month& y) noexcept;
-// constexpr bool operator> (const month& x, const month& y) noexcept;
-// constexpr bool operator<=(const month& x, const month& y) noexcept;
-// constexpr bool operator>=(const month& x, const month& y) noexcept;
-
+// constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-
-int main(int, char**)
-{
-    using month = std::chrono::month;
+constexpr bool test() {
 
-    AssertComparisonsAreNoexcept<month>();
-    AssertComparisonsReturnBool<month>();
-
-    static_assert(testComparisonsValues<month>(0U ,0U), "");
-    static_assert(testComparisonsValues<month>(0U, 1U), "");
-
-    //  Some 'ok' values as well
-    static_assert(testComparisonsValues<month>( 5U,  5U), "");
-    static_assert(testComparisonsValues<month>( 5U, 10U), "");
+  // Validate invalid values. The range [0, 255] is guaranteed to be allowed.
+  assert(testOrderValues<month>(0U, 0U));
+  assert(testOrderValues<month>(0U, 1U));
+  assert(testOrderValues<month>(254U, 255U));
+  assert(testOrderValues<month>(255U, 255U));
 
-    for (unsigned i = 1; i <= 12; ++i)
-        for (unsigned j = 1; j <= 12; ++j)
-            assert(testComparisonsValues<month>(i, j));
+  // Validate some valid values.
+      assert(testOrderValues<month>(i, j));
+
+  return true;
+}
+
+int main(int, char**) {
+  using month = std::chrono::month;
+  AssertOrderAreNoexcept<month>();
+  AssertOrderReturn<std::strong_ordering, month>();
+
+  test();
+  static_assert(test());
 
   return 0;
 }

libcxx/test/std/time/time.cal/time.cal.year/time.cal.year.nonmembers/comparisons.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
 
 // <chrono>
 // class year;
 
 // constexpr bool operator==(const year& x, const year& y) noexcept;
-// constexpr bool operator!=(const year& x, const year& y) noexcept;
-// constexpr bool operator< (const year& x, const year& y) noexcept;
-// constexpr bool operator> (const year& x, const year& y) noexcept;
-// constexpr bool operator<=(const year& x, const year& y) noexcept;
-// constexpr bool operator>=(const year& x, const year& y) noexcept;
-
+// constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-
-int main(int, char**)
-{
-    using year = std::chrono::year;
+constexpr bool test() {
 
-    AssertComparisonsAreNoexcept<year>();
-    AssertComparisonsReturnBool<year>();
-
-    static_assert(testComparisonsValues<year>(0,0), "");
-    static_assert(testComparisonsValues<year>(0,1), "");
-
-    //  Some 'ok' values as well
-    static_assert(testComparisonsValues<year>( 5, 5), "");
-    static_assert(testComparisonsValues<year>( 5,10), "");
+  // Validate valid value. The range [-32768, 32767] is guaranteed to be allowed.
+  assert(testOrderValues<year>(-32768, -32768));
+  assert(testOrderValues<year>(-32768, -32767));
+  // Largest positive
+  assert(testOrderValues<year>(32767, 32766));
+  assert(testOrderValues<year>(32767, 32767));
 
-    for (int i = 1; i < 10; ++i)
-        for (int j = 1; j < 10; ++j)
-            assert(testComparisonsValues<year>(i, j));
+  // Validate some valid values.
+      assert(testOrderValues<year>(i, j));
+
+  return true;
+}
+
+int main(int, char**) {
+  using year = std::chrono::year;
+  AssertOrderAreNoexcept<year>();
+  AssertOrderReturn<std::strong_ordering, year>();
+
+  test();
+  static_assert(test());
 
-    return 0;
 }

libcxx/test/std/time/time.cal/time.cal.ym/time.cal.ym.nonmembers/comparisons.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
 
 // <chrono>
 // class year_month;
 
 // constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
-//   Returns: x.year() == y.year() && x.month() == y.month().
-//
-// constexpr bool operator< (const year_month& x, const year_month& y) noexcept;
-//   Returns:
-//      If x.year() < y.year() returns true.
-//      Otherwise, if x.year() > y.year() returns false.
-//      Otherwise, returns x.month() < y.month().
+// constexpr strong_order operator<=>(const year_month& x, const year_month& y) noexcept;
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main(int, char**)
-{
-    using year       = std::chrono::year;
-    using month      = std::chrono::month;
-    using year_month = std::chrono::year_month;
+constexpr bool test() {
 
-    AssertComparisonsAreNoexcept<year_month>();
-    AssertComparisonsReturnBool<year_month>();
-
-    static_assert( testComparisons(
-        year_month{year{1234}, std::chrono::January},
-        year_month{year{1234}, std::chrono::January},
-        true, false), "");
+  assert(testOrder(
+      std::strong_ordering::equal));
 
-    static_assert( testComparisons(
-        year_month{year{1234}, std::chrono::January},
-        year_month{year{1234}, std::chrono::February},
-        false, true), "");
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    static_assert( testComparisons(
-        year_month{year{1234}, std::chrono::January},
-        year_month{year{1235}, std::chrono::January},
-        false, true), "");
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    //  same year, different months
-    for (unsigned i = 1; i < 12; ++i)
-        for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons(
-                year_month{year{1234}, month{i}},
-                year_month{year{1234}, month{j}},
-                i == j, i < j )));
+      assert((testOrder(
+          i == j  ? std::strong_ordering::equal
+          : i < j ? std::strong_ordering::less
+                  : std::strong_ordering::greater)));
+
+  // Use a maximum to avoid hitting the maximum number of constexpr steps.
+  // Another solution would be increment the number of step, but that leads to
+  // long compilation times.
+  int max = std::is_constant_evaluated() ? 1010 : 2000;
 
-    //  same month, different years
-    for (int i = 1000; i < 2000; ++i)
-        for (int j = 1000; j < 2000; ++j)
-        assert((testComparisons(
-            year_month{year{i}, std::chrono::January},
-            year_month{year{j}, std::chrono::January},
-            i == j, i < j )));
+  for (int i = 1000; i < max; ++i)
+    for (int j = 1000; j < max; ++j)
+      assert((testOrder(
+          i == j  ? std::strong_ordering::equal
+          : i < j ? std::strong_ordering::less
+                  : std::strong_ordering::greater)));
+
+  return true;
+}
+
+int main(int, char**) {
+  using year_month = std::chrono::year_month;
+  AssertOrderAreNoexcept<year_month>();
+  AssertOrderReturn<std::strong_ordering, year_month>();
+
+  test();
+  static_assert(test());
 
-    return 0;
 }

libcxx/test/std/time/time.cal/time.cal.ymd/time.cal.ymd.nonmembers/comparisons.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
 
 // <chrono>
 // class year_month_day;
 
 // constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
-//   Returns: x.year() == y.year() && x.month() == y.month().
-//
-// constexpr bool operator< (const year_month_day& x, const year_month_day& y) noexcept;
-//   Returns:
-//      If x.year() < y.year() returns true.
-//      Otherwise, if x.year() > y.year() returns false.
-//      Otherwise, if x.month() < y.month() returns true.
-//      Otherwise, if x.month() > y.month() returns false.
-//      Otherwise, returns x.day() < y.day()
-
+// constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
-int main(int, char**)
-{
-    using day        = std::chrono::day;
-    using year       = std::chrono::year;
-    using month      = std::chrono::month;
-    using year_month_day = std::chrono::year_month_day;
+constexpr bool test() {
+  using day            = std::chrono::day;
+  using year           = std::chrono::year;
+  using month          = std::chrono::month;
 
-    AssertComparisonsAreNoexcept<year_month_day>();
-    AssertComparisonsReturnBool<year_month_day>();
-
-    constexpr month January = std::chrono::January;
-    constexpr month February = std::chrono::February;
+  constexpr month January  = std::chrono::January;
 
-    static_assert( testComparisons(
-        year_month_day{year{1234}, January, day{1}},
-        year_month_day{year{1234}, January, day{1}},
-        true, false), "");
+  assert(testOrder(
+      std::strong_ordering::equal));
 
-    // different day
-    static_assert( testComparisons(
-        year_month_day{year{1234}, January, day{1}},
-        year_month_day{year{1234}, January, day{2}},
-        false, true), "");
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    // different month
-    static_assert( testComparisons(
-        year_month_day{year{1234}, January, day{1}},
-        year_month_day{year{1234}, February, day{1}},
-        false, true), "");
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    // different year
-    static_assert( testComparisons(
-        year_month_day{year{1234}, January, day{1}},
-        year_month_day{year{1235}, January, day{1}},
-        false, true), "");
-
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    // different month and day
-    static_assert( testComparisons(
-        year_month_day{year{1234}, January, day{2}},
-        year_month_day{year{1234}, February, day{1}},
-        false, true), "");
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    // different year and month
-    static_assert( testComparisons(
-        year_month_day{year{1234}, February, day{1}},
-        year_month_day{year{1235}, January, day{1}},
-        false, true), "");
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    // different year and day
-    static_assert( testComparisons(
-        year_month_day{year{1234}, January, day{2}},
-        year_month_day{year{1235}, January, day{1}},
-        false, true), "");
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    // different year, month and day
-    static_assert( testComparisons(
-        year_month_day{year{1234}, February, day{2}},
-        year_month_day{year{1235}, January, day{1}},
-        false, true), "");
-
+  assert(testOrder(
+      std::strong_ordering::less));
 
-    // same year, different days
-    for (unsigned i = 1; i < 28; ++i)
-        for (unsigned j = 1; j < 28; ++j)
-            assert((testComparisons(
-                year_month_day{year{1234}, January, day{i}},
-                year_month_day{year{1234}, January, day{j}},
-                i == j, i < j )));
+      assert((testOrder(
+          i == j  ? std::strong_ordering::equal
+          : i < j ? std::strong_ordering::less
+                  : std::strong_ordering::greater)));
 
-    // same year, different months
-    for (unsigned i = 1; i < 12; ++i)
-        for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons(
-                year_month_day{year{1234}, month{i}, day{12}},
-                year_month_day{year{1234}, month{j}, day{12}},
-                i == j, i < j )));
+      assert((testOrder(
+          i == j  ? std::strong_ordering::equal
+          : i < j ? std::strong_ordering::less
+                  : std::strong_ordering::greater)));
+
+  // Use a maximum to avoid hitting the maximum number of constexpr steps.
+  // Another solution would be increment the number of step, but that leads to
+  // long compilation times.
+  int max = std::is_constant_evaluated() ? 1010 : 2000;
 
-    // same month, different years
-    for (int i = 1000; i < 2000; ++i)
-        for (int j = 1000; j < 2000; ++j)
-        assert((testComparisons(
-            year_month_day{year{i}, January, day{12}},
-            year_month_day{year{j}, January, day{12}},
-            i == j, i < j )));
+  for (int i = 1000; i < max; ++i)
+    for (int j = 1000; j < max; ++j)
+      assert((testOrder(
+          i == j  ? std::strong_ordering::equal
+          : i < j ? std::strong_ordering::less
+                  : std::strong_ordering::greater)));
+
+  return true;
+}
+
+int main(int, char**) {
+  using year_month_day = std::chrono::year_month_day;
+  AssertOrderAreNoexcept<year_month_day>();
+  AssertOrderReturn<std::strong_ordering, year_month_day>();
+
+  test();
+  static_assert(test());
 
-    return 0;
 }