[libc++][test] Adds spaceship support to macros.

[Mordante]

Summary

This was already reviewed as D128603. This contains only the updates to
the test script.

[Mordante]

Restart CI

[Mordante]

This was approved in D128603 so landing it since the CI passes.

libcxx/test/std/containers/associative/map/map.nonmember/op_compare.pass.cpp

 int main(int, char**) {
     typedef std::map<int, std::string> map_type;
     typedef map_type::value_type value_type;
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(2, "abc"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "abc"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, true, false));
+        assert(testComparisons(cm1, cm2, true, false));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "ab"));
         m2.insert(value_type(1, "abc"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "bcd"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "abc"));
         m2.insert(value_type(2, "abc"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     return 0;
 }

libcxx/test/std/containers/associative/multimap/multimap.nonmember/op_compare.pass.cpp

 int main(int, char**) {
     typedef std::multimap<int, std::string> map_type;
     typedef map_type::value_type value_type;
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(2, "abc"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "abc"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, true, false));
+        assert(testComparisons(cm1, cm2, true, false));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "ab"));
         m2.insert(value_type(1, "abc"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "bcd"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "abc"));
         m2.insert(value_type(2, "abc"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     {
         map_type m1, m2;
         m1.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "abc"));
         m2.insert(value_type(1, "bcd"));
         const map_type& cm1 = m1, cm2 = m2;
-        assert(testComparisons6(cm1, cm2, false, true));
+        assert(testComparisons(cm1, cm2, false, true));
     }
     return 0;
 }

libcxx/test/std/containers/associative/multiset/multiset.nonmember/op_compare.pass.cpp

 #include "test_comparisons.h"
 
 int main(int, char**) {
     {
         std::multiset<int> s1, s2;
         s1.insert(1);
         s2.insert(2);
         const std::multiset<int>& cs1 = s1, cs2 = s2;
-        assert(testComparisons6(cs1, cs2, false, true));
+        assert(testComparisons(cs1, cs2, false, true));
     }
     {
         std::multiset<int> s1, s2;
         s1.insert(1);
         s2.insert(1);
         const std::multiset<int>& cs1 = s1, cs2 = s2;
-        assert(testComparisons6(cs1, cs2, true, false));
+        assert(testComparisons(cs1, cs2, true, false));
     }
     {
         std::multiset<int> s1, s2;
         s1.insert(1);
         s2.insert(1);
         s2.insert(2);
         const std::multiset<int>& cs1 = s1, cs2 = s2;
-        assert(testComparisons6(cs1, cs2, false, true));
+        assert(testComparisons(cs1, cs2, false, true));
     }
     {
         std::multiset<int> s1, s2;
         s1.insert(1);
         s2.insert(1);
         s2.insert(1);
         s2.insert(1);
         const std::multiset<int>& cs1 = s1, cs2 = s2;
-        assert(testComparisons6(cs1, cs2, false, true));
+        assert(testComparisons(cs1, cs2, false, true));
     }
     return 0;
 }

libcxx/test/std/containers/associative/set/set.nonmember/op_compare.pass.cpp

 #include "test_comparisons.h"
 
 int main(int, char**) {
     {
         std::set<int> s1, s2;
         s1.insert(1);
         s2.insert(2);
         const std::set<int>& cs1 = s1, cs2 = s2;
-        assert(testComparisons6(cs1, cs2, false, true));
+        assert(testComparisons(cs1, cs2, false, true));
     }
     {
         std::set<int> s1, s2;
         s1.insert(1);
         s2.insert(1);
         const std::set<int>& cs1 = s1, cs2 = s2;
-        assert(testComparisons6(cs1, cs2, true, false));
+        assert(testComparisons(cs1, cs2, true, false));
     }
     {
         std::set<int> s1, s2;
         s1.insert(1);
         s2.insert(1);
         s2.insert(2);
         const std::set<int>& cs1 = s1, cs2 = s2;
-        assert(testComparisons6(cs1, cs2, false, true));
+        assert(testComparisons(cs1, cs2, false, true));
     }
     return 0;
 }

libcxx/test/std/containers/sequences/array/compare.pass.cpp

 TEST_CONSTEXPR_CXX20 bool tests()
 {
     {
         typedef std::array<int, 3> C;
         const C c1 = {1, 2, 3};
         const C c2 = {1, 2, 3};
         const C c3 = {3, 2, 1};
         const C c4 = {1, 2, 1};
-        assert(testComparisons6(c1, c2, true, false));
-        assert(testComparisons6(c1, c3, false, true));
-        assert(testComparisons6(c1, c4, false, false));
+        assert(testComparisons(c1, c2, true, false));
+        assert(testComparisons(c1, c3, false, true));
+        assert(testComparisons(c1, c4, false, false));
     }
     {
         typedef std::array<int, 0> C;
         const C c1 = {};
         const C c2 = {};
-        assert(testComparisons6(c1, c2, true, false));
+        assert(testComparisons(c1, c2, true, false));
     }
     {
         typedef std::array<LessAndEqComp, 3> C;
         const C c1 = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(3)};
         const C c2 = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(3)};
         const C c3 = {LessAndEqComp(3), LessAndEqComp(2), LessAndEqComp(1)};
         const C c4 = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(1)};
-        assert(testComparisons6(c1, c2, true, false));
-        assert(testComparisons6(c1, c3, false, true));
-        assert(testComparisons6(c1, c4, false, false));
+        assert(testComparisons(c1, c2, true, false));
+        assert(testComparisons(c1, c3, false, true));
+        assert(testComparisons(c1, c4, false, false));
     }
     {
         typedef std::array<LessAndEqComp, 0> C;
         const C c1 = {};
         const C c2 = {};
-        assert(testComparisons6(c1, c2, true, false));
+        assert(testComparisons(c1, c2, true, false));
     }
 
     return true;
 }
 
 int main(int, char**)
 {
     tests();
 #if TEST_STD_VER >= 20
     static_assert(tests(), "");
 #endif
     return 0;
 }

libcxx/test/std/containers/sequences/deque/compare.pass.cpp

 #include <cassert>
 
 #include "test_comparisons.h"
 
 int main(int, char**)
 {
     {
         const std::deque<int> d1, d2;
-        assert(testComparisons6(d1, d2, true, false));
+        assert(testComparisons(d1, d2, true, false));
     }
     {
         const std::deque<int> d1(1, 1), d2(1, 1);
-        assert(testComparisons6(d1, d2, true, false));
+        assert(testComparisons(d1, d2, true, false));
     }
     {
         int items[3] = {1, 2, 3};
         const std::deque<int> d1(items, items + 3);
         const std::deque<int> d2(items, items + 3);
-        assert(testComparisons6(d1, d2, true, false));
+        assert(testComparisons(d1, d2, true, false));
     }
     {
         const std::deque<int> d1(1, 1), d2;
-        assert(testComparisons6(d1, d2, false, false));
+        assert(testComparisons(d1, d2, false, false));
     }
     {
         const std::deque<int> d1(1, 1), d2(1, 2);
-        assert(testComparisons6(d1, d2, false, true));
+        assert(testComparisons(d1, d2, false, true));
     }
     {
         int items1[2] = {1, 2};
         int items2[2] = {1, 3};
         const std::deque<int> d1(items1, items1 + 2);
         const std::deque<int> d2(items2, items2 + 2);
-        assert(testComparisons6(d1, d2, false, true));
+        assert(testComparisons(d1, d2, false, true));
     }
     {
         int items1[2] = {2, 2};
         int items2[2] = {1, 3};
         const std::deque<int> d1(items1, items1 + 2);
         const std::deque<int> d2(items2, items2 + 2);
-        assert(testComparisons6(d1, d2, false, false));
+        assert(testComparisons(d1, d2, false, false));
     }
     {
         const std::deque<LessAndEqComp> d1, d2;
-        assert(testComparisons6(d1, d2, true, false));
+        assert(testComparisons(d1, d2, true, false));
     }
     {
         const std::deque<LessAndEqComp> d1(1, LessAndEqComp(1));
         const std::deque<LessAndEqComp> d2(1, LessAndEqComp(1));
-        assert(testComparisons6(d1, d2, true, false));
+        assert(testComparisons(d1, d2, true, false));
     }
     {
         LessAndEqComp items[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(3)};
         const std::deque<LessAndEqComp> d1(items, items + 3);
         const std::deque<LessAndEqComp> d2(items, items + 3);
-        assert(testComparisons6(d1, d2, true, false));
+        assert(testComparisons(d1, d2, true, false));
     }
     {
         const std::deque<LessAndEqComp> d1(1, LessAndEqComp(1));
         const std::deque<LessAndEqComp> d2;
-        assert(testComparisons6(d1, d2, false, false));
+        assert(testComparisons(d1, d2, false, false));
     }
     {
         const std::deque<LessAndEqComp> d1(1, LessAndEqComp(1));
         const std::deque<LessAndEqComp> d2(1, LessAndEqComp(2));
-        assert(testComparisons6(d1, d2, false, true));
+        assert(testComparisons(d1, d2, false, true));
     }
     {
         LessAndEqComp items1[2] = {LessAndEqComp(1), LessAndEqComp(2)};
         LessAndEqComp items2[2] = {LessAndEqComp(1), LessAndEqComp(3)};
         const std::deque<LessAndEqComp> d1(items1, items1 + 2);
         const std::deque<LessAndEqComp> d2(items2, items2 + 2);
-        assert(testComparisons6(d1, d2, false, true));
+        assert(testComparisons(d1, d2, false, true));
     }
     {
         LessAndEqComp items1[2] = {LessAndEqComp(2), LessAndEqComp(2)};
         LessAndEqComp items2[2] = {LessAndEqComp(1), LessAndEqComp(3)};
         const std::deque<LessAndEqComp> d1(items1, items1 + 2);
         const std::deque<LessAndEqComp> d2(items2, items2 + 2);
-        assert(testComparisons6(d1, d2, false, false));
+        assert(testComparisons(d1, d2, false, false));
     }
 
     return 0;
 }

libcxx/test/std/containers/sequences/list/compare.pass.cpp

 #include <list>
 #include <cassert>
 
 #include "test_comparisons.h"
 
 int main(int, char**) {
     {
         const std::list<int> l1, l2;
-        assert(testComparisons6(l1, l2, true, false));
+        assert(testComparisons(l1, l2, true, false));
     }
     {
         const std::list<int> l1(1, 1), l2(1, 1);
-        assert(testComparisons6(l1, l2, true, false));
+        assert(testComparisons(l1, l2, true, false));
     }
     {
         int items[3] = {1, 2, 3};
         const std::list<int> l1(items, items + 3);
         const std::list<int> l2(items, items + 3);
-        assert(testComparisons6(l1, l2, true, false));
+        assert(testComparisons(l1, l2, true, false));
     }
     {
         const std::list<int> l1(1, 1), l2;
-        assert(testComparisons6(l1, l2, false, false));
+        assert(testComparisons(l1, l2, false, false));
     }
     {
         const std::list<int> l1(1, 1), l2(1, 2);
-        assert(testComparisons6(l1, l2, false, true));
+        assert(testComparisons(l1, l2, false, true));
     }
     {
         int items1[2] = {1, 2};
         int items2[2] = {1, 3};
         const std::list<int> l1(items1, items1 + 2);
         const std::list<int> l2(items2, items2 + 2);
-        assert(testComparisons6(l1, l2, false, true));
+        assert(testComparisons(l1, l2, false, true));
     }
     {
         int items1[2] = {2, 2};
         int items2[2] = {1, 3};
         const std::list<int> l1(items1, items1 + 2);
         const std::list<int> l2(items2, items2 + 2);
-        assert(testComparisons6(l1, l2, false, false));
+        assert(testComparisons(l1, l2, false, false));
     }
     {
         const std::list<LessAndEqComp> l1, l2;
-        assert(testComparisons6(l1, l2, true, false));
+        assert(testComparisons(l1, l2, true, false));
     }
     {
         const std::list<LessAndEqComp> l1(1, LessAndEqComp(1));
         const std::list<LessAndEqComp> l2(1, LessAndEqComp(1));
-        assert(testComparisons6(l1, l2, true, false));
+        assert(testComparisons(l1, l2, true, false));
     }
     {
         LessAndEqComp items[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(3)};
         const std::list<LessAndEqComp> l1(items, items + 3);
         const std::list<LessAndEqComp> l2(items, items + 3);
-        assert(testComparisons6(l1, l2, true, false));
+        assert(testComparisons(l1, l2, true, false));
     }
     {
         const std::list<LessAndEqComp> l1(1, LessAndEqComp(1));
         const std::list<LessAndEqComp> l2;
-        assert(testComparisons6(l1, l2, false, false));
+        assert(testComparisons(l1, l2, false, false));
     }
     {
         const std::list<LessAndEqComp> l1(1, LessAndEqComp(1));
         const std::list<LessAndEqComp> l2(1, LessAndEqComp(2));
-        assert(testComparisons6(l1, l2, false, true));
+        assert(testComparisons(l1, l2, false, true));
     }
     {
         LessAndEqComp items1[2] = {LessAndEqComp(1), LessAndEqComp(2)};
         LessAndEqComp items2[2] = {LessAndEqComp(1), LessAndEqComp(3)};
         const std::list<LessAndEqComp> l1(items1, items1 + 2);
         const std::list<LessAndEqComp> l2(items2, items2 + 2);
-        assert(testComparisons6(l1, l2, false, true));
+        assert(testComparisons(l1, l2, false, true));
     }
     {
         LessAndEqComp items1[2] = {LessAndEqComp(2), LessAndEqComp(2)};
         LessAndEqComp items2[2] = {LessAndEqComp(1), LessAndEqComp(3)};
         const std::list<LessAndEqComp> l1(items1, items1 + 2);
         const std::list<LessAndEqComp> l2(items2, items2 + 2);
-        assert(testComparisons6(l1, l2, false, false));
+        assert(testComparisons(l1, l2, false, false));
     }
     return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/compare.pass.cpp

 #include <cassert>
 
 #include "test_comparisons.h"
 
 int main(int, char**) {
     typedef std::vector<bool> VB;
     {
         const VB v1, v2;
-        assert(testComparisons6(v1, v2, true, false));
+        assert(testComparisons(v1, v2, true, false));
     }
     {
         const VB v1(1, true);
         const VB v2(1, true);
-        assert(testComparisons6(v1, v2, true, false));
+        assert(testComparisons(v1, v2, true, false));
     }
     {
         const VB v1(1, false);
         const VB v2(1, true);
-        assert(testComparisons6(v1, v2, false, true));
+        assert(testComparisons(v1, v2, false, true));
     }
     {
         const VB v1, v2(1, true);
-        assert(testComparisons6(v1, v2, false, true));
+        assert(testComparisons(v1, v2, false, true));
     }
     {
         bool items1[3] = {false, true, false};
         bool items2[3] = {false, true, true};
         const VB v1(items1, items1 + 3);
         const VB v2(items2, items2 + 3);
-        assert(testComparisons6(v1, v2, false, true));
+        assert(testComparisons(v1, v2, false, true));
     }
     {
         bool items1[3] = {false, false, false};
         bool items2[3] = {false, true, false};
         const VB v1(items1, items1 + 3);
         const VB v2(items2, items2 + 3);
-        assert(testComparisons6(v1, v2, false, true));
+        assert(testComparisons(v1, v2, false, true));
     }
     {
         bool items1[2] = {false, true};
         bool items2[3] = {false, true, false};
         const VB v1(items1, items1 + 2);
         const VB v2(items2, items2 + 3);
-        assert(testComparisons6(v1, v2, false, true));
+        assert(testComparisons(v1, v2, false, true));
     }
     {
         bool items[3] = {false, true, false};
         const VB v1(items, items + 3);
         const VB v2(1, true);
-        assert(testComparisons6(v1, v2, false, true));
+        assert(testComparisons(v1, v2, false, true));
     }
     {
         assert( (std::vector<bool>() == std::vector<bool>()));
         assert(!(std::vector<bool>() != std::vector<bool>()));
         assert(!(std::vector<bool>() < std::vector<bool>()));
         assert( (std::vector<bool>() <= std::vector<bool>()));
         assert(!(std::vector<bool>() > std::vector<bool>()));
         assert( (std::vector<bool>() >= std::vector<bool>()));
     }
 
     return 0;
 }

libcxx/test/std/containers/sequences/vector/compare.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "test_comparisons.h"
 
 int main(int, char**) {
     {
         const std::vector<int> c1, c2;
-        assert(testComparisons6(c1, c2, true, false));
+        assert(testComparisons(c1, c2, true, false));
     }
     {
         const std::vector<int> c1(1, 1), c2(1, 2);
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         const std::vector<int> c1, c2(1, 2);
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         int items1[3] = {1, 2, 1};
         int items2[3] = {1, 2, 2};
         const std::vector<int> c1(items1, items1 + 3);
         const std::vector<int> c2(items2, items2 + 3);
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         int items1[3] = {3, 2, 3};
         int items2[3] = {3, 1, 3};
         const std::vector<int> c1(items1, items1 + 3);
         const std::vector<int> c2(items2, items2 + 3);
 
-        assert(testComparisons6(c1, c2, false, false));
+        assert(testComparisons(c1, c2, false, false));
     }
     {
         int items1[2] = {1, 2};
         int items2[3] = {1, 2, 0};
         const std::vector<int> c1(items1, items1 + 2);
         const std::vector<int> c2(items2, items2 + 3);
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         int items1[3] = {1, 2, 0};
         const std::vector<int> c1(items1, items1 + 3);
         const std::vector<int> c2(1, 3);
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         const std::vector<LessAndEqComp> c1, c2;
-        assert(testComparisons6(c1, c2, true, false));
+        assert(testComparisons(c1, c2, true, false));
     }
     {
         const std::vector<LessAndEqComp> c1(1, LessAndEqComp(1));
         const std::vector<LessAndEqComp> c2(1, LessAndEqComp(1));
-        assert(testComparisons6(c1, c2, true, false));
+        assert(testComparisons(c1, c2, true, false));
     }
     {
         const std::vector<LessAndEqComp> c1(1, LessAndEqComp(1));
         const std::vector<LessAndEqComp> c2(1, LessAndEqComp(2));
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         const std::vector<LessAndEqComp> c1;
         const std::vector<LessAndEqComp> c2(1, LessAndEqComp(2));
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         LessAndEqComp items1[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(2)};
         LessAndEqComp items2[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(1)};
         const std::vector<LessAndEqComp> c1(items1, items1 + 3);
         const std::vector<LessAndEqComp> c2(items2, items2 + 3);
-        assert(testComparisons6(c1, c2, false, false));
+        assert(testComparisons(c1, c2, false, false));
     }
     {
         LessAndEqComp items1[3] = {LessAndEqComp(3), LessAndEqComp(3), LessAndEqComp(3)};
         LessAndEqComp items2[3] = {LessAndEqComp(3), LessAndEqComp(2), LessAndEqComp(3)};
         const std::vector<LessAndEqComp> c1(items1, items1 + 3);
         const std::vector<LessAndEqComp> c2(items2, items2 + 3);
-        assert(testComparisons6(c1, c2, false, false));
+        assert(testComparisons(c1, c2, false, false));
     }
     {
         LessAndEqComp items1[2] = {LessAndEqComp(1), LessAndEqComp(2)};
         LessAndEqComp items2[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(0)};
         const std::vector<LessAndEqComp> c1(items1, items1 + 2);
         const std::vector<LessAndEqComp> c2(items2, items2 + 3);
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         LessAndEqComp items1[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(0)};
         const std::vector<LessAndEqComp> c1(items1, items1 + 3);
         const std::vector<LessAndEqComp> c2(1, LessAndEqComp(3));
-        assert(testComparisons6(c1, c2, false, true));
+        assert(testComparisons(c1, c2, false, true));
     }
     {
         assert((std::vector<int>() == std::vector<int>()));
         assert(!(std::vector<int>() != std::vector<int>()));
         assert(!(std::vector<int>() < std::vector<int>()));
         assert((std::vector<int>() <= std::vector<int>()));
         assert(!(std::vector<int>() > std::vector<int>()));
         assert((std::vector<int>() >= std::vector<int>()));
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/eq.pass.cpp

int main(int, char**)
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c1(std::begin(a), std::end(a));
         const C c2;
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
     }
     {
         typedef std::unordered_map<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c1(std::begin(a), std::end(a));
         const C c2 = c1;
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
     }
     {
         typedef std::unordered_map<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         C c1(std::begin(a), std::end(a));
         C c2 = c1;
         c2.rehash(30);
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
         c2.insert(P(90, "ninety"));
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
         c1.insert(P(90, "ninety"));
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
     }
     {
         typedef std::unordered_map<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         C c1(std::begin(a), std::end(a));
         C c2 = c1;
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
         c1.insert(P(90, "ninety"));
         c2.insert(P(100, "onehundred"));
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c1(std::begin(a), std::end(a));
         const C c2;
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
     }
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c1(std::begin(a), std::end(a));
         const C c2 = c1;
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
     }
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         C c1(std::begin(a), std::end(a));
         C c2 = c1;
         c2.rehash(30);
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
         c2.insert(P(90, "ninety"));
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
         c1.insert(P(90, "ninety"));
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
     }
     {
         typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         C c1(std::begin(a), std::end(a));
         C c2 = c1;
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
         c1.insert(P(90, "ninety"));
         c2.insert(P(100, "onehundred"));
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/eq.pass.cpp

int main(int, char**)
             P(50, "fifty 2"),
             P(50, "fifty 3"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c1(std::begin(a), std::end(a));
         const C c2;
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(20, "twenty 2"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(50, "fifty 2"),
             P(50, "fifty 3"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c1(std::begin(a), std::end(a));
         const C c2 = c1;
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(20, "twenty 2"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(50, "fifty 2"),
             P(50, "fifty 3"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         C c1(std::begin(a), std::end(a));
         C c2 = c1;
         c2.rehash(30);
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
         c2.insert(P(90, "ninety"));
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
         c1.insert(P(90, "ninety"));
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
     }
     {
         typedef std::unordered_multimap<int, std::string> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(20, "twenty 2"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(50, "fifty 2"),
             P(50, "fifty 3"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         C c1(std::begin(a), std::end(a));
         C c2 = c1;
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
         c1.insert(P(70, "seventy 2"));
         c2.insert(P(80, "eighty 2"));
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(20, "twenty 2"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(50, "fifty 2"),
             P(50, "fifty 3"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c1(std::begin(a), std::end(a));
         const C c2;
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
     }
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(20, "twenty 2"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(50, "fifty 2"),
             P(50, "fifty 3"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         const C c1(std::begin(a), std::end(a));
         const C c2 = c1;
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
     }
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(20, "twenty 2"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(50, "fifty 2"),
             P(50, "fifty 3"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         C c1(std::begin(a), std::end(a));
         C c2 = c1;
         c2.rehash(30);
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
         c2.insert(P(90, "ninety"));
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
         c1.insert(P(90, "ninety"));
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
     }
     {
         typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
                             min_allocator<std::pair<const int, std::string>>> C;
         typedef std::pair<int, std::string> P;
         P a[] =
         {
             P(10, "ten"),
             P(20, "twenty"),
             P(20, "twenty 2"),
             P(30, "thirty"),
             P(40, "forty"),
             P(50, "fifty"),
             P(50, "fifty 2"),
             P(50, "fifty 3"),
             P(60, "sixty"),
             P(70, "seventy"),
             P(80, "eighty"),
         };
         C c1(std::begin(a), std::end(a));
         C c2 = c1;
-        assert(testComparisons2(c1, c2, true));
+        assert(testEquality(c1, c2, true));
         c1.insert(P(70, "seventy 2"));
         c2.insert(P(80, "eighty 2"));
-        assert(testComparisons2(c1, c2, false));
+        assert(testEquality(c1, c2, false));
     }
 #endif
 
   return 0;
 }

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

 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
 int main(int, char**)
 {
     using day = std::chrono::day;
 
-    AssertComparisons6AreNoexcept<day>();
-    AssertComparisons6ReturnBool<day>();
+    AssertComparisonsAreNoexcept<day>();
+    AssertComparisonsReturnBool<day>();
 
-    static_assert(testComparisons6Values<day>(0U, 0U), "");
-    static_assert(testComparisons6Values<day>(0U, 1U), "");
+    static_assert(testComparisonsValues<day>(0U, 0U), "");
+    static_assert(testComparisonsValues<day>(0U, 1U), "");
 
     //  Some 'ok' values as well
-    static_assert(testComparisons6Values<day>( 5U,  5U), "");
-    static_assert(testComparisons6Values<day>( 5U, 10U), "");
+    static_assert(testComparisonsValues<day>( 5U,  5U), "");
+    static_assert(testComparisonsValues<day>( 5U, 10U), "");
 
     for (unsigned i = 1; i < 10; ++i)
         for (unsigned j = 1; j < 10; ++j)
-            assert(testComparisons6Values<day>(i, j));
+            assert(testComparisonsValues<day>(i, j));
 
   return 0;
 }

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

 #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;
 
-    AssertComparisons6AreNoexcept<month_day>();
-    AssertComparisons6ReturnBool<month_day>();
+    AssertComparisonsAreNoexcept<month_day>();
+    AssertComparisonsReturnBool<month_day>();
 
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         month_day{std::chrono::January, day{1}},
         month_day{std::chrono::January, day{1}},
         true, false), "");
 
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         month_day{std::chrono::January, day{1}},
         month_day{std::chrono::January, day{2}},
         false, true), "");
 
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         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(
+            assert((testComparisons(
                 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(
+            assert((testComparisons(
                 month_day{month{2}, day{i}},
                 month_day{month{2}, day{j}},
                 i == j, i < j )));
 
 
   return 0;
 }

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

 #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;
 
-    AssertComparisons6AreNoexcept<month_day_last>();
-    AssertComparisons6ReturnBool<month_day_last>();
+    AssertComparisonsAreNoexcept<month_day_last>();
+    AssertComparisonsReturnBool<month_day_last>();
 
-    static_assert( testComparisons6Values<month_day_last>(month{1}, month{1}), "");
-    static_assert( testComparisons6Values<month_day_last>(month{1}, month{2}), "");
+    static_assert( testComparisonsValues<month_day_last>(month{1}, month{1}), "");
+    static_assert( testComparisonsValues<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}));
+            assert(testComparisonsValues<month_day_last>(month{i}, month{j}));
 
     return 0;
 }

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

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

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

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;
 
     constexpr weekday Sunday = std::chrono::Sunday;
     constexpr weekday Monday = std::chrono::Monday;
 
-    AssertComparisons2AreNoexcept<month_weekday>();
-    AssertComparisons2ReturnBool<month_weekday>();
+    AssertEqualityAreNoexcept<month_weekday>();
+    AssertEqualityReturnBool<month_weekday>();
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         month_weekday{std::chrono::January, weekday_indexed{Sunday, 1}},
         month_weekday{std::chrono::January, weekday_indexed{Sunday, 1}},
         true), "");
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         month_weekday{std::chrono::January, weekday_indexed{Sunday, 1}},
         month_weekday{std::chrono::January, weekday_indexed{Sunday, 2}},
         false), "");
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         month_weekday{std::chrono::January,  weekday_indexed{Sunday, 1}},
         month_weekday{std::chrono::February, weekday_indexed{Sunday, 1}},
         false), "");
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         month_weekday{std::chrono::January, weekday_indexed{Monday, 1}},
         month_weekday{std::chrono::January, weekday_indexed{Sunday, 2}},
         false), "");
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         month_weekday{std::chrono::January,  weekday_indexed{Monday, 1}},
         month_weekday{std::chrono::February, weekday_indexed{Sunday, 1}},
         false), "");
 
 //  same day, different months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons2(
+            assert((testEquality(
                 month_weekday{month{i}, weekday_indexed{Sunday, 1}},
                 month_weekday{month{j}, weekday_indexed{Sunday, 1}},
                 i == j)));
 
 //  same month, different weeks
     for (unsigned i = 1; i < 5; ++i)
         for (unsigned j = 1; j < 5; ++j)
-            assert((testComparisons2(
+            assert((testEquality(
                 month_weekday{month{2}, weekday_indexed{Sunday, i}},
                 month_weekday{month{2}, weekday_indexed{Sunday, j}},
                 i == j)));
 
 //  same month, different days
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
-            assert((testComparisons2(
+            assert((testEquality(
                 month_weekday{month{2}, weekday_indexed{weekday{i}, 2}},
                 month_weekday{month{2}, weekday_indexed{weekday{j}, 2}},
                 i == j)));
 
   return 0;
 }

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

int main(int, char**)
     using weekday_last       = std::chrono::weekday_last;
     using weekday            = std::chrono::weekday;
     using month_weekday_last = std::chrono::month_weekday_last;
 
     constexpr month January = std::chrono::January;
     constexpr weekday Tuesday = std::chrono::Tuesday;
     constexpr weekday Wednesday = std::chrono::Wednesday;
 
-    AssertComparisons2AreNoexcept<month_weekday_last>();
-    AssertComparisons2ReturnBool<month_weekday_last>();
+    AssertEqualityAreNoexcept<month_weekday_last>();
+    AssertEqualityReturnBool<month_weekday_last>();
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
         month_weekday_last{std::chrono::January, weekday_last{Tuesday}},
         true), "");
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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(
+            assert((testEquality(
                 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(
+            assert((testEquality(
                 month_weekday_last{January, weekday_last{weekday{i}}},
                 month_weekday_last{January, weekday_last{weekday{j}}},
             i == j)));
 
     //  both different
-    assert((testComparisons2(
+    assert((testEquality(
         month_weekday_last{month{1}, weekday_last{weekday{1}}},
         month_weekday_last{month{2}, weekday_last{weekday{2}}},
     false)));
 
     return 0;
 }

libcxx/test/std/time/time.cal/time.cal.operators/month_day.pass.cpp

 // Returns: month(m) / d.
 
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "test_comparisons.h"
 
 int main(int, char**)
 {
     using month_day = std::chrono::month_day;
     using month     = std::chrono::month;
     using day       = std::chrono::day;
 
     constexpr month February = std::chrono::February;

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

 //     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;

libcxx/test/std/time/time.cal/time.cal.operators/month_weekday.pass.cpp

 
 
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "test_comparisons.h"
 
 int main(int, char**)
 {
     using month_weekday   = std::chrono::month_weekday;
     using month           = std::chrono::month;
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
 

libcxx/test/std/time/time.cal/time.cal.operators/month_weekday_last.pass.cpp

 
 
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "test_comparisons.h"
 
 int main(int, char**)
 {
     using month_weekday      = std::chrono::month_weekday;
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
     using weekday_last       = std::chrono::weekday_last;
     using month_weekday_last = std::chrono::month_weekday_last;

libcxx/test/std/time/time.cal/time.cal.operators/year_month.pass.cpp

 
 
 
 #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 year       = std::chrono::year;
     using year_month = std::chrono::year_month;
 
     constexpr month February = std::chrono::February;

libcxx/test/std/time/time.cal/time.cal.operators/year_month_day.pass.cpp

 // Returns: year(y) / md.
 
 
 #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 day            = std::chrono::day;
     using year_month     = std::chrono::year_month;
     using month_day      = std::chrono::month_day;

libcxx/test/std/time/time.cal/time.cal.operators/year_month_day_last.pass.cpp

 // Returns: year(y) / mdl.
 
 
 #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 year_month          = std::chrono::year_month;
     using year                = std::chrono::year;
     using month_day_last      = std::chrono::month_day_last;

libcxx/test/std/time/time.cal/time.cal.operators/year_month_weekday.pass.cpp

 //   operator/(const month_weekday& mwd, int y) noexcept;
 // Returns: year(y) / mwd.
 
 #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 year_month         = std::chrono::year_month;
     using month_weekday      = std::chrono::month_weekday;
     using year_month_weekday = std::chrono::year_month_weekday;
     using month              = std::chrono::month;

libcxx/test/std/time/time.cal/time.cal.operators/year_month_weekday_last.pass.cpp

 
 
 
 #include <chrono>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "test_comparisons.h"
 
 int main(int, char**)
 {
     using year_month         = std::chrono::year_month;
     using year               = std::chrono::year;
     using month              = std::chrono::month;
     using weekday            = std::chrono::weekday;
     using weekday_last       = std::chrono::weekday_last;

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

 #include "test_macros.h"
 #include "test_comparisons.h"
 
 int main(int, char**)
 {
     using weekday         = std::chrono::weekday;
     using weekday_indexed = std::chrono::weekday_indexed;
 
-    AssertComparisons2AreNoexcept<weekday_indexed>();
-    AssertComparisons2ReturnBool<weekday_indexed>();
+    AssertEqualityAreNoexcept<weekday_indexed>();
+    AssertEqualityReturnBool<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

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

 #include "test_macros.h"
 #include "test_comparisons.h"
 
 int main(int, char**)
 {
     using weekday      = std::chrono::weekday;
     using weekday_last = std::chrono::weekday_last;
 
-    AssertComparisons2AreNoexcept<weekday_last>();
-    AssertComparisons2ReturnBool<weekday_last>();
+    AssertEqualityAreNoexcept<weekday_last>();
+    AssertEqualityReturnBool<weekday_last>();
 
-    static_assert(testComparisons2Values<weekday_last>(weekday{0}, weekday{0}), "");
-    static_assert(testComparisons2Values<weekday_last>(weekday{0}, weekday{1}), "");
+    static_assert(testEqualityValues<weekday_last>(weekday{0}, weekday{0}), "");
+    static_assert(testEqualityValues<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}), "");
+    static_assert(testEqualityValues<weekday_last>(weekday{2}, weekday{2}), "");
+    static_assert(testEqualityValues<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}));
+            assert(testEqualityValues<weekday_last>(weekday{i}, weekday{j}));
 
     return 0;
 }

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

 
 #include "test_macros.h"
 #include "test_comparisons.h"
 
 int main(int, char**)
 {
     using weekday = std::chrono::weekday;
 
-    AssertComparisons2AreNoexcept<weekday>();
-    AssertComparisons2ReturnBool<weekday>();
+    AssertEqualityAreNoexcept<weekday>();
+    AssertEqualityReturnBool<weekday>();
 
-    static_assert(testComparisons2Values<weekday>(0U ,0U), "");
-    static_assert(testComparisons2Values<weekday>(0U, 1U), "");
+    static_assert(testEqualityValues<weekday>(0U ,0U), "");
+    static_assert(testEqualityValues<weekday>(0U, 1U), "");
 
     //  Some 'ok' values as well
-    static_assert(testComparisons2Values<weekday>(5U, 5U), "");
-    static_assert(testComparisons2Values<weekday>(5U, 2U), "");
+    static_assert(testEqualityValues<weekday>(5U, 5U), "");
+    static_assert(testEqualityValues<weekday>(5U, 2U), "");
 
     for (unsigned i = 0; i < 6; ++i)
         for (unsigned j = 0; j < 6; ++j)
-            assert(testComparisons2Values<weekday>(i, j));
+            assert(testEqualityValues<weekday>(i, j));
 
     return 0;
 }

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

 #include "test_macros.h"
 #include "test_comparisons.h"
 
 
 int main(int, char**)
 {
     using year = std::chrono::year;
 
-    AssertComparisons6AreNoexcept<year>();
-    AssertComparisons6ReturnBool<year>();
+    AssertComparisonsAreNoexcept<year>();
+    AssertComparisonsReturnBool<year>();
 
-    static_assert(testComparisons6Values<year>(0,0), "");
-    static_assert(testComparisons6Values<year>(0,1), "");
+    static_assert(testComparisonsValues<year>(0,0), "");
+    static_assert(testComparisonsValues<year>(0,1), "");
 
     //  Some 'ok' values as well
-    static_assert(testComparisons6Values<year>( 5, 5), "");
-    static_assert(testComparisons6Values<year>( 5,10), "");
+    static_assert(testComparisonsValues<year>( 5, 5), "");
+    static_assert(testComparisonsValues<year>( 5,10), "");
 
     for (int i = 1; i < 10; ++i)
         for (int j = 1; j < 10; ++j)
-            assert(testComparisons6Values<year>(i, j));
+            assert(testComparisonsValues<year>(i, j));
 
     return 0;
 }

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

 #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;
 
-    AssertComparisons6AreNoexcept<year_month>();
-    AssertComparisons6ReturnBool<year_month>();
+    AssertComparisonsAreNoexcept<year_month>();
+    AssertComparisonsReturnBool<year_month>();
 
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month{year{1234}, std::chrono::January},
         year_month{year{1234}, std::chrono::January},
         true, false), "");
 
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month{year{1234}, std::chrono::January},
         year_month{year{1234}, std::chrono::February},
         false, true), "");
 
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         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(
+            assert((testComparisons(
                 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 < 2000; ++i)
         for (int j = 1000; j < 2000; ++j)
-        assert((testComparisons6(
+        assert((testComparisons(
             year_month{year{i}, std::chrono::January},
             year_month{year{j}, std::chrono::January},
             i == j, i < j )));
 
     return 0;
 }

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

 
 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;
 
-    AssertComparisons6AreNoexcept<year_month_day>();
-    AssertComparisons6ReturnBool<year_month_day>();
+    AssertComparisonsAreNoexcept<year_month_day>();
+    AssertComparisonsReturnBool<year_month_day>();
 
     constexpr month January = std::chrono::January;
     constexpr month February = std::chrono::February;
 
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day{year{1234}, January, day{1}},
         year_month_day{year{1234}, January, day{1}},
         true, false), "");
 
     // different day
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day{year{1234}, January, day{1}},
         year_month_day{year{1234}, January, day{2}},
         false, true), "");
 
     // different month
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day{year{1234}, January, day{1}},
         year_month_day{year{1234}, February, day{1}},
         false, true), "");
 
     // different year
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day{year{1234}, January, day{1}},
         year_month_day{year{1235}, January, day{1}},
         false, true), "");
 
 
     // different month and day
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day{year{1234}, January, day{2}},
         year_month_day{year{1234}, February, day{1}},
         false, true), "");
 
     // different year and month
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day{year{1234}, February, day{1}},
         year_month_day{year{1235}, January, day{1}},
         false, true), "");
 
     // different year and day
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day{year{1234}, January, day{2}},
         year_month_day{year{1235}, January, day{1}},
         false, true), "");
 
     // different year, month and day
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day{year{1234}, February, day{2}},
         year_month_day{year{1235}, January, day{1}},
         false, true), "");
 
 
     // same year, different days
     for (unsigned i = 1; i < 28; ++i)
         for (unsigned j = 1; j < 28; ++j)
-            assert((testComparisons6(
+            assert((testComparisons(
                 year_month_day{year{1234}, January, day{i}},
                 year_month_day{year{1234}, January, day{j}},
                 i == j, i < j )));
 
     // same year, different months
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons6(
+            assert((testComparisons(
                 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 < 2000; ++i)
         for (int j = 1000; j < 2000; ++j)
-        assert((testComparisons6(
+        assert((testComparisons(
             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/time/time.cal/time.cal.ymdlast/time.cal.ymdlast.nonmembers/comparisons.pass.cpp

 
 int main(int, char**)
 {
     using year                = std::chrono::year;
     using month               = std::chrono::month;
     using month_day_last      = std::chrono::month_day_last;
     using year_month_day_last = std::chrono::year_month_day_last;
 
-    AssertComparisons6AreNoexcept<year_month_day_last>();
-    AssertComparisons6ReturnBool<year_month_day_last>();
+    AssertComparisonsAreNoexcept<year_month_day_last>();
+    AssertComparisonsReturnBool<year_month_day_last>();
 
     constexpr month January = std::chrono::January;
     constexpr month February = std::chrono::February;
 
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day_last{year{1234}, month_day_last{January}},
         year_month_day_last{year{1234}, month_day_last{January}},
         true, false), "");
 
     // different month
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day_last{year{1234}, month_day_last{January}},
         year_month_day_last{year{1234}, month_day_last{February}},
         false, true), "");
 
     // different year
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         year_month_day_last{year{1234}, month_day_last{January}},
         year_month_day_last{year{1235}, month_day_last{January}},
         false, true), "");
 
     // different month
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         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
-    static_assert( testComparisons6(
+    static_assert( testComparisons(
         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
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons6(
+            assert((testComparisons(
                 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 < 2000; ++i)
         for (int j = 1000; j < 2000; ++j)
-        assert((testComparisons6(
+        assert((testComparisons(
             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/time/time.cal/time.cal.ymwd/time.cal.ymwd.nonmembers/comparisons.pass.cpp

 int main(int, char**)
 {
     using year               = std::chrono::year;
     using month              = std::chrono::month;
     using weekday_indexed    = std::chrono::weekday_indexed;
     using weekday            = std::chrono::weekday;
     using year_month_weekday = std::chrono::year_month_weekday;
 
-    AssertComparisons2AreNoexcept<year_month_weekday>();
-    AssertComparisons2ReturnBool<year_month_weekday>();
+    AssertEqualityAreNoexcept<year_month_weekday>();
+    AssertEqualityReturnBool<year_month_weekday>();
 
     constexpr month January   = std::chrono::January;
     constexpr month February  = std::chrono::February;
     constexpr weekday Tuesday = std::chrono::Tuesday;
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
         true), "");
 
     // different day
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1234}, January, weekday_indexed{Tuesday, 2}},
         false), "");
 
     // different month
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         year_month_weekday{year{1234}, January,  weekday_indexed{Tuesday, 1}},
         year_month_weekday{year{1234}, February, weekday_indexed{Tuesday, 1}},
         false), "");
 
     // different year
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
     for (unsigned i = 1; i < 28; ++i)
         for (unsigned j = 1; j < 28; ++j)
-            assert((testComparisons2(
+            assert((testEquality(
                 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
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons2(
+            assert((testEquality(
                 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 < 2000; ++i)
         for (int j = 1000; j < 2000; ++j)
-        assert((testComparisons2(
+        assert((testEquality(
             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/time/time.cal/time.cal.ymwdlast/time.cal.ymwdlast.nonmembers/comparisons.pass.cpp

 int main(int, char**)
 {
     using year                    = std::chrono::year;
     using month                   = std::chrono::month;
     using weekday                 = std::chrono::weekday;
     using weekday_last            = std::chrono::weekday_last;
     using year_month_weekday_last = std::chrono::year_month_weekday_last;
 
-    AssertComparisons2AreNoexcept<year_month_weekday_last>();
-    AssertComparisons2ReturnBool<year_month_weekday_last>();
+    AssertEqualityAreNoexcept<year_month_weekday_last>();
+    AssertEqualityReturnBool<year_month_weekday_last>();
 
     constexpr month January   = std::chrono::January;
     constexpr month February  = std::chrono::February;
     constexpr weekday Tuesday = std::chrono::Tuesday;
     constexpr weekday Wednesday = std::chrono::Wednesday;
 
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
         year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
         true), "");
 
     // different day
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         year_month_weekday_last{year{1234}, January, weekday_last{Tuesday}},
         year_month_weekday_last{year{1234}, January, weekday_last{Wednesday}},
         false), "");
 
     // different month
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         year_month_weekday_last{year{1234}, January,  weekday_last{Tuesday}},
         year_month_weekday_last{year{1234}, February, weekday_last{Tuesday}},
         false), "");
 
     // different year
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
-    static_assert( testComparisons2(
+    static_assert( testEquality(
         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
     for (unsigned i = 1; i < 28; ++i)
         for (unsigned j = 1; j < 28; ++j)
-            assert((testComparisons2(
+            assert((testEquality(
                 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
     for (unsigned i = 1; i < 12; ++i)
         for (unsigned j = 1; j < 12; ++j)
-            assert((testComparisons2(
+            assert((testEquality(
                 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 < 2000; ++i)
         for (int j = 1000; j < 2000; ++j)
-        assert((testComparisons2(
+        assert((testEquality(
             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/support/test_comparisons.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //  A set of routines for testing the comparison operators of a type
 //
-//      XXXX6 tests all six comparison operators
-//      XXXX2 tests only op== and op!=
+//      FooOrder<expected-ordering>  All seven comparison operators, requires C++20 or newer.
+//      FooComparison                All six pre-C++20 comparison operators
+//      FooEquality                  Equality operators operator== and operator!=
 //
-//      AssertComparisonsXAreNoexcept       static_asserts that the operations are all noexcept.
-//      AssertComparisonsXReturnBool        static_asserts that the operations return bool.
-//      AssertComparisonsXConvertibleToBool static_asserts that the operations return something convertible to bool.
-
+//      AssertXAreNoexcept           static_asserts that the operations are all noexcept.
+//      AssertXReturnBool            static_asserts that the operations return bool.
+//      AssertOrderReturn            static_asserts that the pre-C++20 comparison operations
+//                                   return bool and operator<=> returns the proper type.
+//      AssertXConvertibleToBool     static_asserts that the operations return something convertible to bool.
+//      testXValues                  returns the result of the comparison of all operations.
+//
+//      AssertOrderConvertibleToBool doesn't exist yet. It will be implemented when needed.
 
 #ifndef TEST_COMPARISONS_H
 #define TEST_COMPARISONS_H
 
 #include <type_traits>
 #include <cassert>
 #include "test_macros.h"
 
 //  Test all six comparison operations for sanity
 template <class T, class U = T>
-TEST_CONSTEXPR_CXX14 bool testComparisons6(const T& t1, const U& t2, bool isEqual, bool isLess)
+TEST_CONSTEXPR_CXX14 bool testComparisons(const T& t1, const U& t2, bool isEqual, bool isLess)
 {
     assert(!(isEqual && isLess) && "isEqual and isLess cannot be both true");
     if (isEqual)
         {
         if (!(t1 == t2)) return false;
         if (!(t2 == t1)) return false;
         if ( (t1 != t2)) return false;
         if ( (t2 != t1)) return false;
else /* greater */
         if ( (t2 >= t1)) return false;
         }
 
     return true;
 }
 
 //  Easy call when you can init from something already comparable.
 template <class T, class Param>
-TEST_CONSTEXPR_CXX14 bool testComparisons6Values(Param val1, Param val2)
+TEST_CONSTEXPR_CXX14 bool testComparisonsValues(Param val1, Param val2)
 {
     const bool isEqual = val1 == val2;
     const bool isLess  = val1  < val2;
 
-    return testComparisons6(T(val1), T(val2), isEqual, isLess);
+    return testComparisons(T(val1), T(val2), isEqual, isLess);
 }
 
 template <class T, class U = T>
-void AssertComparisons6AreNoexcept()
+void AssertComparisonsAreNoexcept()
 {
     ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() <  std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() >  std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() >= std::declval<const U&>());
 }
 
 template <class T, class U = T>
-void AssertComparisons6ReturnBool()
+void AssertComparisonsReturnBool()
 {
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <  std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <= std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >  std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >= std::declval<const U&>()), bool);
 }
 
 
 template <class T, class U = T>
-void AssertComparisons6ConvertibleToBool()
+void AssertComparisonsConvertibleToBool()
 {
     static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() <  std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() <= std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() >  std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() >= std::declval<const U&>()), bool>::value), "");
 }
 
+#if TEST_STD_VER > 17
+template <class T, class U = T>
+void AssertOrderAreNoexcept() {
+  AssertComparisonsAreNoexcept<T, U>();
+  ASSERT_NOEXCEPT(std::declval<const T&>() <=> std::declval<const U&>());
+}
+
+template <class Order, class T, class U = T>
+void AssertOrderReturn() {
+  AssertComparisonsReturnBool<T, U>();
+  ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <=> std::declval<const U&>()), Order);
+}
+
+template <class Order, class T, class U = T>
+constexpr bool testOrder(const T& t1, const U& t2, Order order) {
+  return (t1 <=> t2 == order) &&
+         testComparisons(t1, t2, order == Order::equal || order == Order::equivalent, order == Order::less);
+}
+
+template <class T, class Param>
+constexpr bool testOrderValues(Param val1, Param val2) {
+  return testOrder(T(val1), T(val2), val1 <=> val2);
+}
+
+#endif
+
 //  Test all two comparison operations for sanity
 template <class T, class U = T>
-TEST_CONSTEXPR_CXX14 bool testComparisons2(const T& t1, const U& t2, bool isEqual)
+TEST_CONSTEXPR_CXX14 bool testEquality(const T& t1, const U& t2, bool isEqual)
 {
     if (isEqual)
         {
         if (!(t1 == t2)) return false;
         if (!(t2 == t1)) return false;
         if ( (t1 != t2)) return false;
         if ( (t2 != t1)) return false;
         }
     else /* not equal */
         {
         if ( (t1 == t2)) return false;
         if ( (t2 == t1)) return false;
         if (!(t1 != t2)) return false;
         if (!(t2 != t1)) return false;
         }
 
     return true;
 }
 
 //  Easy call when you can init from something already comparable.
 template <class T, class Param>
-TEST_CONSTEXPR_CXX14 bool testComparisons2Values(Param val1, Param val2)
+TEST_CONSTEXPR_CXX14 bool testEqualityValues(Param val1, Param val2)
 {
     const bool isEqual = val1 == val2;
 
-    return testComparisons2(T(val1), T(val2), isEqual);
+    return testEquality(T(val1), T(val2), isEqual);
 }
 
 template <class T, class U = T>
-void AssertComparisons2AreNoexcept()
+void AssertEqualityAreNoexcept()
 {
     ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
     ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
 }
 
 template <class T, class U = T>
-void AssertComparisons2ReturnBool()
+void AssertEqualityReturnBool()
 {
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
 }
 
 
 template <class T, class U = T>
-void AssertComparisons2ConvertibleToBool()
+void AssertEqualityConvertibleToBool()
 {
     static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
     static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
 }
 
 struct LessAndEqComp {
   int value;