libcxx/test/std/language.support/cmp/cmp.alg/weak_order.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // UNSUPPORTED: c++03, c++11, c++14, c++17
  10
  11 // <compare>
  12
  13 // template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
  14
  15 #include <compare>
  16
  17 #include <cassert>
  18 #include <cmath>
  19 #include <iterator> // std::size
  20 #include <limits>
  21 #include <type_traits>
  22 #include <utility>
  23
  24 #include "test_macros.h"
  25
  26 template<class T, class U>
  27 constexpr auto has_weak_order(T&& t, U&& u)
  28     -> decltype(std::weak_order(static_cast<T&&>(t), static_cast<U&&>(u)), true)
  29 {
  30     return true;
  31 }
  32
  33 constexpr bool has_weak_order(...) {
  34     return false;
  35 }
  36
  37 namespace N11 {
  38     struct A {};
  39     struct B {};
  40     std::strong_ordering weak_order(const A&, const A&) { return std::strong_ordering::less; }
  41     std::strong_ordering weak_order(const A&, const B&);
  42 }
  43
  44 void test_1_1()
  45 {
  46     // If the decayed types of E and F differ, weak_order(E, F) is ill-formed.
  47
  48     static_assert( has_weak_order(1, 2));
  49     static_assert(!has_weak_order(1, (short)2));
  50     static_assert(!has_weak_order(1, 2.0));
  51     static_assert(!has_weak_order(1.0f, 2.0));
  52
  53     static_assert( has_weak_order((int*)nullptr, (int*)nullptr));
  54     static_assert(!has_weak_order((int*)nullptr, (const int*)nullptr));
  55     static_assert(!has_weak_order((const int*)nullptr, (int*)nullptr));
  56     static_assert( has_weak_order((const int*)nullptr, (const int*)nullptr));
  57
  58     N11::A a;
  59     N11::B b;
  60     static_assert( has_weak_order(a, a));
  61     static_assert(!has_weak_order(a, b));
  62 }
  63
  64 namespace N12 {
  65     struct A {};
  66     std::strong_ordering weak_order(A&, A&&) { return std::strong_ordering::less; }
  67     std::strong_ordering weak_order(A&&, A&&) { return std::strong_ordering::equal; }
  68     std::strong_ordering weak_order(const A&, const A&);
  69
  70     struct B {
  71         friend std::partial_ordering weak_order(B&, B&);
  72     };
  73
  74     struct WeakOrder {
  75         explicit operator std::weak_ordering() const { return std::weak_ordering::less; }
  76     };
  77     struct C {
  78         bool touched = false;
  79         friend WeakOrder weak_order(C& lhs, C&) { lhs.touched = true; return WeakOrder(); }
  80     };
  81 }
  82
  83 void test_1_2()
  84 {
  85     // Otherwise, weak_ordering(weak_order(E, F))
  86     // if it is a well-formed expression with overload resolution performed
  87     // in a context that does not include a declaration of std::weak_order.
  88
  89     // Test that weak_order does not const-qualify the forwarded arguments.
  90     N12::A a;
  91     assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
  92     assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
  93
  94     // The type of weak_order(e,f) must be explicitly convertible to weak_ordering.
  95     N12::B b;
  96     static_assert(!has_weak_order(b, b));
  97
  98     N12::C c1, c2;
  99     ASSERT_SAME_TYPE(decltype(std::weak_order(c1, c2)), std::weak_ordering);
 100     assert(std::weak_order(c1, c2) == std::weak_ordering::less);
 101     assert(c1.touched);
 102     assert(!c2.touched);
 103 }
 104
 105 template<class F>
 106 constexpr bool test_1_3()
 107 {
 108     // Otherwise, if the decayed type T of E is a floating-point type,
 109     // yields a value of type weak_ordering that is consistent with
 110     // the ordering observed by T's comparison operators and strong_order,
 111     // and if numeric_limits<T>::is_iec559 is true, is additionally consistent with
 112     // the following equivalence classes...
 113
 114     // std::numeric_limits<F>::is_iec559 is usually true.
 115     // It is false for F=long double on AIX; but this test is still expected
 116     // to pass (e.g. std::weak_order(+0, -0) == weak_ordering::equivalent,
 117     // even on AIX).
 118
 119     ASSERT_SAME_TYPE(decltype(std::weak_order(F(0), F(0))), std::weak_ordering);
 120
 121     F v[] = {
 122         -std::numeric_limits<F>::infinity(),
 123         std::numeric_limits<F>::lowest(),  // largest (finite) negative number
 124         F(-1.0), F(-0.1),
 125         -std::numeric_limits<F>::min(),    // smallest (normal) negative number
 126         F(-0.0),                           // negative zero
 127         F(0.0),
 128         std::numeric_limits<F>::min(),     // smallest (normal) positive number
 129         F(0.1), F(1.0), F(2.0), F(3.14),
 130         std::numeric_limits<F>::max(),     // largest (finite) positive number
 131         std::numeric_limits<F>::infinity(),
 132     };
 133
 134     static_assert(std::size(v) == 14);
 135
 136     // Sanity-check that array 'v' is indeed in the right order.
 137     for (int i=0; i < 14; ++i) {
 138         for (int j=0; j < 14; ++j) {
 139             auto naturalOrder = (v[i] <=> v[j]);
 140             if (v[i] == 0 && v[j] == 0) {
 141                 assert(naturalOrder == std::partial_ordering::equivalent);
 142             } else {
 143                 assert(naturalOrder == std::partial_ordering::unordered || naturalOrder == (i <=> j));
 144             }
 145         }
 146     }
 147
 148     assert(std::weak_order(v[0], v[0]) == std::weak_ordering::equivalent);
 149     assert(std::weak_order(v[0], v[1]) == std::weak_ordering::less);
 150     assert(std::weak_order(v[0], v[2]) == std::weak_ordering::less);
 151     assert(std::weak_order(v[0], v[3]) == std::weak_ordering::less);
 152     assert(std::weak_order(v[0], v[4]) == std::weak_ordering::less);
 153     assert(std::weak_order(v[0], v[5]) == std::weak_ordering::less);
 154     assert(std::weak_order(v[0], v[6]) == std::weak_ordering::less);
 155     assert(std::weak_order(v[0], v[7]) == std::weak_ordering::less);
 156     assert(std::weak_order(v[0], v[8]) == std::weak_ordering::less);
 157     assert(std::weak_order(v[0], v[9]) == std::weak_ordering::less);
 158     assert(std::weak_order(v[0], v[10]) == std::weak_ordering::less);
 159     assert(std::weak_order(v[0], v[11]) == std::weak_ordering::less);
 160     assert(std::weak_order(v[0], v[12]) == std::weak_ordering::less);
 161     assert(std::weak_order(v[0], v[13]) == std::weak_ordering::less);
 162     assert(std::weak_order(v[1], v[0]) == std::weak_ordering::greater);
 163     assert(std::weak_order(v[1], v[1]) == std::weak_ordering::equivalent);
 164     assert(std::weak_order(v[1], v[2]) == std::weak_ordering::less);
 165     assert(std::weak_order(v[1], v[3]) == std::weak_ordering::less);
 166     assert(std::weak_order(v[1], v[4]) == std::weak_ordering::less);
 167     assert(std::weak_order(v[1], v[5]) == std::weak_ordering::less);
 168     assert(std::weak_order(v[1], v[6]) == std::weak_ordering::less);
 169     assert(std::weak_order(v[1], v[7]) == std::weak_ordering::less);
 170     assert(std::weak_order(v[1], v[8]) == std::weak_ordering::less);
 171     assert(std::weak_order(v[1], v[9]) == std::weak_ordering::less);
 172     assert(std::weak_order(v[1], v[10]) == std::weak_ordering::less);
 173     assert(std::weak_order(v[1], v[11]) == std::weak_ordering::less);
 174     assert(std::weak_order(v[1], v[12]) == std::weak_ordering::less);
 175     assert(std::weak_order(v[1], v[13]) == std::weak_ordering::less);
 176     assert(std::weak_order(v[2], v[0]) == std::weak_ordering::greater);
 177     assert(std::weak_order(v[2], v[1]) == std::weak_ordering::greater);
 178     assert(std::weak_order(v[2], v[2]) == std::weak_ordering::equivalent);
 179     assert(std::weak_order(v[2], v[3]) == std::weak_ordering::less);
 180     assert(std::weak_order(v[2], v[4]) == std::weak_ordering::less);
 181     assert(std::weak_order(v[2], v[5]) == std::weak_ordering::less);
 182     assert(std::weak_order(v[2], v[6]) == std::weak_ordering::less);
 183     assert(std::weak_order(v[2], v[7]) == std::weak_ordering::less);
 184     assert(std::weak_order(v[2], v[8]) == std::weak_ordering::less);
 185     assert(std::weak_order(v[2], v[9]) == std::weak_ordering::less);
 186     assert(std::weak_order(v[2], v[10]) == std::weak_ordering::less);
 187     assert(std::weak_order(v[2], v[11]) == std::weak_ordering::less);
 188     assert(std::weak_order(v[2], v[12]) == std::weak_ordering::less);
 189     assert(std::weak_order(v[2], v[13]) == std::weak_ordering::less);
 190     assert(std::weak_order(v[3], v[0]) == std::weak_ordering::greater);
 191     assert(std::weak_order(v[3], v[1]) == std::weak_ordering::greater);
 192     assert(std::weak_order(v[3], v[2]) == std::weak_ordering::greater);
 193     assert(std::weak_order(v[3], v[3]) == std::weak_ordering::equivalent);
 194     assert(std::weak_order(v[3], v[4]) == std::weak_ordering::less);
 195     assert(std::weak_order(v[3], v[5]) == std::weak_ordering::less);
 196     assert(std::weak_order(v[3], v[6]) == std::weak_ordering::less);
 197     assert(std::weak_order(v[3], v[7]) == std::weak_ordering::less);
 198     assert(std::weak_order(v[3], v[8]) == std::weak_ordering::less);
 199     assert(std::weak_order(v[3], v[9]) == std::weak_ordering::less);
 200     assert(std::weak_order(v[3], v[10]) == std::weak_ordering::less);
 201     assert(std::weak_order(v[3], v[11]) == std::weak_ordering::less);
 202     assert(std::weak_order(v[3], v[12]) == std::weak_ordering::less);
 203     assert(std::weak_order(v[3], v[13]) == std::weak_ordering::less);
 204     assert(std::weak_order(v[4], v[0]) == std::weak_ordering::greater);
 205     assert(std::weak_order(v[4], v[1]) == std::weak_ordering::greater);
 206     assert(std::weak_order(v[4], v[2]) == std::weak_ordering::greater);
 207     assert(std::weak_order(v[4], v[3]) == std::weak_ordering::greater);
 208     assert(std::weak_order(v[4], v[4]) == std::weak_ordering::equivalent);
 209     assert(std::weak_order(v[4], v[5]) == std::weak_ordering::less);
 210     assert(std::weak_order(v[4], v[6]) == std::weak_ordering::less);
 211     assert(std::weak_order(v[4], v[7]) == std::weak_ordering::less);
 212     assert(std::weak_order(v[4], v[8]) == std::weak_ordering::less);
 213     assert(std::weak_order(v[4], v[9]) == std::weak_ordering::less);
 214     assert(std::weak_order(v[4], v[10]) == std::weak_ordering::less);
 215     assert(std::weak_order(v[4], v[11]) == std::weak_ordering::less);
 216     assert(std::weak_order(v[4], v[12]) == std::weak_ordering::less);
 217     assert(std::weak_order(v[4], v[13]) == std::weak_ordering::less);
 218     assert(std::weak_order(v[5], v[0]) == std::weak_ordering::greater);
 219     assert(std::weak_order(v[5], v[1]) == std::weak_ordering::greater);
 220     assert(std::weak_order(v[5], v[2]) == std::weak_ordering::greater);
 221     assert(std::weak_order(v[5], v[3]) == std::weak_ordering::greater);
 222     assert(std::weak_order(v[5], v[4]) == std::weak_ordering::greater);
 223     assert(std::weak_order(v[5], v[5]) == std::weak_ordering::equivalent);
 224     assert(std::weak_order(v[5], v[6]) == std::weak_ordering::equivalent);
 225     assert(std::weak_order(v[5], v[7]) == std::weak_ordering::less);
 226     assert(std::weak_order(v[5], v[8]) == std::weak_ordering::less);
 227     assert(std::weak_order(v[5], v[9]) == std::weak_ordering::less);
 228     assert(std::weak_order(v[5], v[10]) == std::weak_ordering::less);
 229     assert(std::weak_order(v[5], v[11]) == std::weak_ordering::less);
 230     assert(std::weak_order(v[5], v[12]) == std::weak_ordering::less);
 231     assert(std::weak_order(v[5], v[13]) == std::weak_ordering::less);
 232     assert(std::weak_order(v[6], v[0]) == std::weak_ordering::greater);
 233     assert(std::weak_order(v[6], v[1]) == std::weak_ordering::greater);
 234     assert(std::weak_order(v[6], v[2]) == std::weak_ordering::greater);
 235     assert(std::weak_order(v[6], v[3]) == std::weak_ordering::greater);
 236     assert(std::weak_order(v[6], v[4]) == std::weak_ordering::greater);
 237     assert(std::weak_order(v[6], v[5]) == std::weak_ordering::equivalent);
 238     assert(std::weak_order(v[6], v[6]) == std::weak_ordering::equivalent);
 239     assert(std::weak_order(v[6], v[7]) == std::weak_ordering::less);
 240     assert(std::weak_order(v[6], v[8]) == std::weak_ordering::less);
 241     assert(std::weak_order(v[6], v[9]) == std::weak_ordering::less);
 242     assert(std::weak_order(v[6], v[10]) == std::weak_ordering::less);
 243     assert(std::weak_order(v[6], v[11]) == std::weak_ordering::less);
 244     assert(std::weak_order(v[6], v[12]) == std::weak_ordering::less);
 245     assert(std::weak_order(v[6], v[13]) == std::weak_ordering::less);
 246     assert(std::weak_order(v[7], v[0]) == std::weak_ordering::greater);
 247     assert(std::weak_order(v[7], v[1]) == std::weak_ordering::greater);
 248     assert(std::weak_order(v[7], v[2]) == std::weak_ordering::greater);
 249     assert(std::weak_order(v[7], v[3]) == std::weak_ordering::greater);
 250     assert(std::weak_order(v[7], v[4]) == std::weak_ordering::greater);
 251     assert(std::weak_order(v[7], v[5]) == std::weak_ordering::greater);
 252     assert(std::weak_order(v[7], v[6]) == std::weak_ordering::greater);
 253     assert(std::weak_order(v[7], v[7]) == std::weak_ordering::equivalent);
 254     assert(std::weak_order(v[7], v[8]) == std::weak_ordering::less);
 255     assert(std::weak_order(v[7], v[9]) == std::weak_ordering::less);
 256     assert(std::weak_order(v[7], v[10]) == std::weak_ordering::less);
 257     assert(std::weak_order(v[7], v[11]) == std::weak_ordering::less);
 258     assert(std::weak_order(v[7], v[12]) == std::weak_ordering::less);
 259     assert(std::weak_order(v[7], v[13]) == std::weak_ordering::less);
 260     assert(std::weak_order(v[8], v[0]) == std::weak_ordering::greater);
 261     assert(std::weak_order(v[8], v[1]) == std::weak_ordering::greater);
 262     assert(std::weak_order(v[8], v[2]) == std::weak_ordering::greater);
 263     assert(std::weak_order(v[8], v[3]) == std::weak_ordering::greater);
 264     assert(std::weak_order(v[8], v[4]) == std::weak_ordering::greater);
 265     assert(std::weak_order(v[8], v[5]) == std::weak_ordering::greater);
 266     assert(std::weak_order(v[8], v[6]) == std::weak_ordering::greater);
 267     assert(std::weak_order(v[8], v[7]) == std::weak_ordering::greater);
 268     assert(std::weak_order(v[8], v[8]) == std::weak_ordering::equivalent);
 269     assert(std::weak_order(v[8], v[9]) == std::weak_ordering::less);
 270     assert(std::weak_order(v[8], v[10]) == std::weak_ordering::less);
 271     assert(std::weak_order(v[8], v[11]) == std::weak_ordering::less);
 272     assert(std::weak_order(v[8], v[12]) == std::weak_ordering::less);
 273     assert(std::weak_order(v[8], v[13]) == std::weak_ordering::less);
 274     assert(std::weak_order(v[9], v[0]) == std::weak_ordering::greater);
 275     assert(std::weak_order(v[9], v[1]) == std::weak_ordering::greater);
 276     assert(std::weak_order(v[9], v[2]) == std::weak_ordering::greater);
 277     assert(std::weak_order(v[9], v[3]) == std::weak_ordering::greater);
 278     assert(std::weak_order(v[9], v[4]) == std::weak_ordering::greater);
 279     assert(std::weak_order(v[9], v[5]) == std::weak_ordering::greater);
 280     assert(std::weak_order(v[9], v[6]) == std::weak_ordering::greater);
 281     assert(std::weak_order(v[9], v[7]) == std::weak_ordering::greater);
 282     assert(std::weak_order(v[9], v[8]) == std::weak_ordering::greater);
 283     assert(std::weak_order(v[9], v[9]) == std::weak_ordering::equivalent);
 284     assert(std::weak_order(v[9], v[10]) == std::weak_ordering::less);
 285     assert(std::weak_order(v[9], v[11]) == std::weak_ordering::less);
 286     assert(std::weak_order(v[9], v[12]) == std::weak_ordering::less);
 287     assert(std::weak_order(v[9], v[13]) == std::weak_ordering::less);
 288     assert(std::weak_order(v[10], v[0]) == std::weak_ordering::greater);
 289     assert(std::weak_order(v[10], v[1]) == std::weak_ordering::greater);
 290     assert(std::weak_order(v[10], v[2]) == std::weak_ordering::greater);
 291     assert(std::weak_order(v[10], v[3]) == std::weak_ordering::greater);
 292     assert(std::weak_order(v[10], v[4]) == std::weak_ordering::greater);
 293     assert(std::weak_order(v[10], v[5]) == std::weak_ordering::greater);
 294     assert(std::weak_order(v[10], v[6]) == std::weak_ordering::greater);
 295     assert(std::weak_order(v[10], v[7]) == std::weak_ordering::greater);
 296     assert(std::weak_order(v[10], v[8]) == std::weak_ordering::greater);
 297     assert(std::weak_order(v[10], v[9]) == std::weak_ordering::greater);
 298     assert(std::weak_order(v[10], v[10]) == std::weak_ordering::equivalent);
 299     assert(std::weak_order(v[10], v[11]) == std::weak_ordering::less);
 300     assert(std::weak_order(v[10], v[12]) == std::weak_ordering::less);
 301     assert(std::weak_order(v[10], v[13]) == std::weak_ordering::less);
 302     assert(std::weak_order(v[11], v[0]) == std::weak_ordering::greater);
 303     assert(std::weak_order(v[11], v[1]) == std::weak_ordering::greater);
 304     assert(std::weak_order(v[11], v[2]) == std::weak_ordering::greater);
 305     assert(std::weak_order(v[11], v[3]) == std::weak_ordering::greater);
 306     assert(std::weak_order(v[11], v[4]) == std::weak_ordering::greater);
 307     assert(std::weak_order(v[11], v[5]) == std::weak_ordering::greater);
 308     assert(std::weak_order(v[11], v[6]) == std::weak_ordering::greater);
 309     assert(std::weak_order(v[11], v[7]) == std::weak_ordering::greater);
 310     assert(std::weak_order(v[11], v[8]) == std::weak_ordering::greater);
 311     assert(std::weak_order(v[11], v[9]) == std::weak_ordering::greater);
 312     assert(std::weak_order(v[11], v[10]) == std::weak_ordering::greater);
 313     assert(std::weak_order(v[11], v[11]) == std::weak_ordering::equivalent);
 314     assert(std::weak_order(v[11], v[12]) == std::weak_ordering::less);
 315     assert(std::weak_order(v[11], v[13]) == std::weak_ordering::less);
 316     assert(std::weak_order(v[12], v[0]) == std::weak_ordering::greater);
 317     assert(std::weak_order(v[12], v[1]) == std::weak_ordering::greater);
 318     assert(std::weak_order(v[12], v[2]) == std::weak_ordering::greater);
 319     assert(std::weak_order(v[12], v[3]) == std::weak_ordering::greater);
 320     assert(std::weak_order(v[12], v[4]) == std::weak_ordering::greater);
 321     assert(std::weak_order(v[12], v[5]) == std::weak_ordering::greater);
 322     assert(std::weak_order(v[12], v[6]) == std::weak_ordering::greater);
 323     assert(std::weak_order(v[12], v[7]) == std::weak_ordering::greater);
 324     assert(std::weak_order(v[12], v[8]) == std::weak_ordering::greater);
 325     assert(std::weak_order(v[12], v[9]) == std::weak_ordering::greater);
 326     assert(std::weak_order(v[12], v[10]) == std::weak_ordering::greater);
 327     assert(std::weak_order(v[12], v[11]) == std::weak_ordering::greater);
 328     assert(std::weak_order(v[12], v[12]) == std::weak_ordering::equivalent);
 329     assert(std::weak_order(v[12], v[13]) == std::weak_ordering::less);
 330     assert(std::weak_order(v[13], v[0]) == std::weak_ordering::greater);
 331     assert(std::weak_order(v[13], v[1]) == std::weak_ordering::greater);
 332     assert(std::weak_order(v[13], v[2]) == std::weak_ordering::greater);
 333     assert(std::weak_order(v[13], v[3]) == std::weak_ordering::greater);
 334     assert(std::weak_order(v[13], v[4]) == std::weak_ordering::greater);
 335     assert(std::weak_order(v[13], v[5]) == std::weak_ordering::greater);
 336     assert(std::weak_order(v[13], v[6]) == std::weak_ordering::greater);
 337     assert(std::weak_order(v[13], v[7]) == std::weak_ordering::greater);
 338     assert(std::weak_order(v[13], v[8]) == std::weak_ordering::greater);
 339     assert(std::weak_order(v[13], v[9]) == std::weak_ordering::greater);
 340     assert(std::weak_order(v[13], v[10]) == std::weak_ordering::greater);
 341     assert(std::weak_order(v[13], v[11]) == std::weak_ordering::greater);
 342     assert(std::weak_order(v[13], v[12]) == std::weak_ordering::greater);
 343     assert(std::weak_order(v[13], v[13]) == std::weak_ordering::equivalent);
 344
 345
 346     // There's no way to produce a specifically positive or negative NAN
 347     // at compile-time, so the NAN-related tests must be runtime-only.
 348
 349     if (!std::is_constant_evaluated()) {
 350         F nq = std::copysign(std::numeric_limits<F>::quiet_NaN(), F(-1));
 351         F ns = std::copysign(std::numeric_limits<F>::signaling_NaN(), F(-1));
 352         F ps = std::copysign(std::numeric_limits<F>::signaling_NaN(), F(+1));
 353         F pq = std::copysign(std::numeric_limits<F>::quiet_NaN(), F(+1));
 354
 355         assert(std::weak_order(nq, nq) == std::weak_ordering::equivalent);
 356         assert(std::weak_order(nq, ns) == std::weak_ordering::equivalent);
 357         for (int i=0; i < 14; ++i) {
 358             assert(std::weak_order(nq, v[i]) == std::weak_ordering::less);
 359         }
 360         assert(std::weak_order(nq, ps) == std::weak_ordering::less);
 361         assert(std::weak_order(nq, pq) == std::weak_ordering::less);
 362
 363         assert(std::weak_order(ns, nq) == std::weak_ordering::equivalent);
 364         assert(std::weak_order(ns, ns) == std::weak_ordering::equivalent);
 365         for (int i=0; i < 14; ++i) {
 366             assert(std::weak_order(ns, v[i]) == std::weak_ordering::less);
 367         }
 368         assert(std::weak_order(ns, ps) == std::weak_ordering::less);
 369         assert(std::weak_order(ns, pq) == std::weak_ordering::less);
 370
 371         assert(std::weak_order(ps, nq) == std::weak_ordering::greater);
 372         assert(std::weak_order(ps, ns) == std::weak_ordering::greater);
 373         for (int i=0; i < 14; ++i) {
 374             assert(std::weak_order(ps, v[i]) == std::weak_ordering::greater);
 375         }
 376         assert(std::weak_order(ps, ps) == std::weak_ordering::equivalent);
 377         assert(std::weak_order(ps, pq) == std::weak_ordering::equivalent);
 378
 379         assert(std::weak_order(pq, nq) == std::weak_ordering::greater);
 380         assert(std::weak_order(pq, ns) == std::weak_ordering::greater);
 381         for (int i=0; i < 14; ++i) {
 382             assert(std::weak_order(pq, v[i]) == std::weak_ordering::greater);
 383         }
 384         assert(std::weak_order(pq, ps) == std::weak_ordering::equivalent);
 385         assert(std::weak_order(pq, pq) == std::weak_ordering::equivalent);
 386     }
 387
 388     return true;
 389 }
 390
 391 namespace N14 {
 392     // Compare to N12::A.
 393     struct A {};
 394     bool operator==(const A&, const A&);
 395     constexpr std::weak_ordering operator<=>(A&, A&&) { return std::weak_ordering::less; }
 396     constexpr std::weak_ordering operator<=>(A&&, A&&) { return std::weak_ordering::equivalent; }
 397     std::weak_ordering operator<=>(const A&, const A&);
 398     static_assert(std::three_way_comparable<A>);
 399
 400     struct B {
 401         std::weak_ordering operator<=>(const B&) const;  // lacks operator==
 402     };
 403     static_assert(!std::three_way_comparable<B>);
 404
 405     struct C {
 406         bool *touched;
 407         bool operator==(const C&) const;
 408         constexpr std::weak_ordering operator<=>(const C& rhs) const {
 409             *rhs.touched = true;
 410             return std::weak_ordering::equivalent;
 411         }
 412     };
 413     static_assert(std::three_way_comparable<C>);
 414 }
 415
 416 constexpr bool test_1_4()
 417 {
 418     // Otherwise, weak_ordering(compare_three_way()(E, F)) if it is a well-formed expression.
 419
 420     // Test neither weak_order nor compare_three_way const-qualify the forwarded arguments.
 421     N14::A a;
 422     assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
 423     assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
 424
 425     N14::B b;
 426     static_assert(!has_weak_order(b, b));
 427
 428     // Test that the arguments are passed to <=> in the correct order.
 429     bool c1_touched = false;
 430     bool c2_touched = false;
 431     N14::C c1 = {&c1_touched};
 432     N14::C c2 = {&c2_touched};
 433     assert(std::weak_order(c1, c2) == std::weak_ordering::equivalent);
 434     assert(!c1_touched);
 435     assert(c2_touched);
 436
 437     return true;
 438 }
 439
 440 namespace N15 {
 441     struct A {};
 442     constexpr std::strong_ordering strong_order(A&, A&&) { return std::strong_ordering::less; }
 443     constexpr std::strong_ordering strong_order(A&&, A&&) { return std::strong_ordering::equal; }
 444     std::strong_ordering strong_order(const A&, const A&);
 445
 446     struct B {
 447         friend std::weak_ordering strong_order(B&, B&);
 448     };
 449
 450     struct WeakOrder {
 451         operator std::weak_ordering() const { return std::weak_ordering::less; }
 452     };
 453     struct C {
 454         friend WeakOrder strong_order(C& lhs, C&);
 455     };
 456
 457     struct StrongOrder {
 458         constexpr explicit operator std::strong_ordering() const { return std::strong_ordering::less; }
 459         operator std::weak_ordering() const = delete;
 460     };
 461     struct D {
 462         bool touched = false;
 463         friend constexpr StrongOrder strong_order(D& lhs, D&) { lhs.touched = true; return StrongOrder(); }
 464     };
 465 }
 466
 467 constexpr bool test_1_5()
 468 {
 469     // Otherwise, weak_ordering(strong_order(E, F)) [that is, std::strong_order]
 470     // if it is a well-formed expression.
 471
 472     // Test that weak_order and strong_order do not const-qualify the forwarded arguments.
 473     N15::A a;
 474     assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
 475     assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
 476
 477     // The type of ADL strong_order(e,f) must be explicitly convertible to strong_ordering
 478     // (not just to weak_ordering), or else std::strong_order(e,f) won't exist.
 479     N15::B b;
 480     static_assert(!has_weak_order(b, b));
 481
 482     // The type of ADL strong_order(e,f) must be explicitly convertible to strong_ordering
 483     // (not just to weak_ordering), or else std::strong_order(e,f) won't exist.
 484     N15::C c;
 485     static_assert(!has_weak_order(c, c));
 486
 487     N15::D d1, d2;
 488     ASSERT_SAME_TYPE(decltype(std::weak_order(d1, d2)), std::weak_ordering);
 489     assert(std::weak_order(d1, d2) == std::weak_ordering::less);
 490     assert(d1.touched);
 491     assert(!d2.touched);
 492
 493     return true;
 494 }
 495
 496 int main(int, char**)
 497 {
 498     test_1_1();
 499     test_1_2();
 500     test_1_3<float>();
 501     test_1_3<double>();
 502     test_1_3<long double>();
 503     test_1_4();
 504     test_1_5();
 505
 506     static_assert(test_1_3<float>());
 507     static_assert(test_1_3<double>());
 508     static_assert(test_1_3<long double>());
 509     static_assert(test_1_4());
 510     static_assert(test_1_5());
 511
 512     return 0;
 513 }