libsupc++: Implement comparison algorithms for C++20
This is incomplete because std::strong_order doesn't support floating-point types. The partial_order and weak_order tests use VERIFY instead of static_assert because of PR 92431. * libsupc++/compare (strong_order, weak_order, partial_order) (compare_strong_order_fallback, compare_weak_order_fallback) (compare_partial_order_fallback): Define customization point objects for C++20. * testsuite/18_support/comparisons/algorithms/partial_order.cc: New test. * testsuite/18_support/comparisons/algorithms/strong_order.cc: New test. * testsuite/18_support/comparisons/algorithms/weak_order.cc: New test. From-SVN: r278149
This commit is contained in:
Jonathan Wakely
Jonathan Wakely
parent
5d46287769
commit
0ff15d21c8
|
|
@ -1,3 +1,15 @@
|
|||
2019-11-13 Jonathan Wakely <jwakely@redhat.com>
|
||||
|
||||
* libsupc++/compare (strong_order, weak_order, partial_order)
|
||||
(compare_strong_order_fallback, compare_weak_order_fallback)
|
||||
(compare_partial_order_fallback): Define customization point objects
|
||||
for C++20.
|
||||
* testsuite/18_support/comparisons/algorithms/partial_order.cc: New
|
||||
test.
|
||||
* testsuite/18_support/comparisons/algorithms/strong_order.cc: New
|
||||
test.
|
||||
* testsuite/18_support/comparisons/algorithms/weak_order.cc: New test.
|
||||
|
||||
2019-11-11 Gerald Pfeifer <gerald@pfeifer.com>
|
||||
|
||||
* doc/xml/gnu/gpl-3.0.xml: Adjust link to "Why not LGPL".
|
||||
|
|
|
|||
|
|
@ -576,20 +576,346 @@ namespace std
|
|||
using is_transparent = void;
|
||||
};
|
||||
|
||||
namespace __cmp_cust
|
||||
{
|
||||
template<floating_point _Tp>
|
||||
constexpr weak_ordering
|
||||
__fp_weak_ordering(_Tp __e, _Tp __f)
|
||||
{
|
||||
// Returns an integer with the same sign as the argument, and magnitude
|
||||
// indicating the classification: zero=1 subnorm=2 norm=3 inf=4 nan=5
|
||||
auto __cat = [](_Tp __fp) -> int {
|
||||
const int __sign = __builtin_signbit(__fp) ? -1 : 1;
|
||||
if (__builtin_isnormal(__fp))
|
||||
return (__fp == 0 ? 1 : 3) * __sign;
|
||||
if (__builtin_isnan(__fp))
|
||||
return 5 * __sign;
|
||||
if (int __inf = __builtin_isinf_sign(__fp))
|
||||
return 4 * __inf;
|
||||
return 2 * __sign;
|
||||
};
|
||||
|
||||
auto __po = __e <=> __f;
|
||||
if (is_lt(__po))
|
||||
return weak_ordering::less;
|
||||
else if (is_gt(__po))
|
||||
return weak_ordering::greater;
|
||||
else if (__po == partial_ordering::equivalent)
|
||||
return weak_ordering::equivalent;
|
||||
else // unordered, at least one argument is NaN
|
||||
{
|
||||
// return -1 for negative nan, +1 for positive nan, 0 otherwise.
|
||||
auto __isnan_sign = [](_Tp __fp) -> int {
|
||||
return __builtin_isnan(__fp)
|
||||
? __builtin_signbit(__fp) ? -1 : 1
|
||||
: 0;
|
||||
};
|
||||
auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f);
|
||||
if (is_eq(__ord))
|
||||
return weak_ordering::equivalent;
|
||||
else if (is_lt(__ord))
|
||||
return weak_ordering::less;
|
||||
else
|
||||
return weak_ordering::greater;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Up>
|
||||
concept __adl_strong = requires(_Tp&& __t, _Up&& __u)
|
||||
{
|
||||
strong_ordering(strong_order(static_cast<_Tp&&>(__t),
|
||||
static_cast<_Up&&>(__u)));
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Up>
|
||||
concept __adl_weak = requires(_Tp&& __t, _Up&& __u)
|
||||
{
|
||||
weak_ordering(weak_order(static_cast<_Tp&&>(__t),
|
||||
static_cast<_Up&&>(__u)));
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Up>
|
||||
concept __adl_partial = requires(_Tp&& __t, _Up&& __u)
|
||||
{
|
||||
partial_ordering(partial_order(static_cast<_Tp&&>(__t),
|
||||
static_cast<_Up&&>(__u)));
|
||||
};
|
||||
|
||||
template<typename _Ord, typename _Tp, typename _Up>
|
||||
concept __op_cmp = requires(_Tp&& __t, _Up&& __u)
|
||||
{
|
||||
_Ord(static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u));
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Up>
|
||||
concept __strongly_ordered
|
||||
= __adl_strong<_Tp, _Up>
|
||||
// FIXME: || floating_point<remove_reference_t<_Tp>>
|
||||
|| __op_cmp<strong_ordering, _Tp, _Up>;
|
||||
|
||||
class _Strong_order
|
||||
{
|
||||
template<typename _Tp, typename _Up>
|
||||
static constexpr bool
|
||||
_S_noexcept()
|
||||
{
|
||||
if constexpr (floating_point<decay_t<_Tp>>)
|
||||
return true;
|
||||
else if constexpr (__adl_strong<_Tp, _Up>)
|
||||
return noexcept(strong_ordering(strong_order(std::declval<_Tp>(),
|
||||
std::declval<_Up>())));
|
||||
else if constexpr (__op_cmp<strong_ordering, _Tp, _Up>)
|
||||
return noexcept(std::declval<_Tp>() <=> std::declval<_Up>());
|
||||
}
|
||||
|
||||
friend class _Weak_order;
|
||||
friend class _Strong_fallback;
|
||||
|
||||
public:
|
||||
template<typename _Tp, typename _Up>
|
||||
requires __strongly_ordered<_Tp, _Up>
|
||||
constexpr strong_ordering
|
||||
operator()(_Tp&& __e, _Up&& __f) const
|
||||
noexcept(_S_noexcept<_Tp, _Up>())
|
||||
{
|
||||
static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
|
||||
|
||||
/* FIXME:
|
||||
if constexpr (floating_point<decay_t<_Tp>>)
|
||||
return __cmp_cust::__fp_strong_order(__e, __f);
|
||||
else */ if constexpr (__adl_strong<_Tp, _Up>)
|
||||
return strong_ordering(strong_order(static_cast<_Tp&&>(__e),
|
||||
static_cast<_Up&&>(__f)));
|
||||
else if constexpr (__op_cmp<strong_ordering, _Tp, _Up>)
|
||||
return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Up>
|
||||
concept __weakly_ordered
|
||||
= floating_point<remove_reference_t<_Tp>>
|
||||
|| __adl_weak<_Tp, _Up>
|
||||
|| __op_cmp<weak_ordering, _Tp, _Up>
|
||||
|| __strongly_ordered<_Tp, _Up>;
|
||||
|
||||
class _Weak_order
|
||||
{
|
||||
template<typename _Tp, typename _Up>
|
||||
static constexpr bool
|
||||
_S_noexcept()
|
||||
{
|
||||
if constexpr (floating_point<decay_t<_Tp>>)
|
||||
return true;
|
||||
else if constexpr (__adl_weak<_Tp, _Up>)
|
||||
return noexcept(weak_ordering(weak_order(std::declval<_Tp>(),
|
||||
std::declval<_Up>())));
|
||||
else if constexpr (__op_cmp<weak_ordering, _Tp, _Up>)
|
||||
return noexcept(std::declval<_Tp>() <=> std::declval<_Up>());
|
||||
else if constexpr (__strongly_ordered<_Tp, _Up>)
|
||||
return _Strong_order::_S_noexcept<_Tp, _Up>();
|
||||
}
|
||||
|
||||
friend class _Partial_order;
|
||||
friend class _Weak_fallback;
|
||||
|
||||
public:
|
||||
template<typename _Tp, typename _Up>
|
||||
requires __weakly_ordered<_Tp, _Up>
|
||||
constexpr weak_ordering
|
||||
operator()(_Tp&& __e, _Up&& __f) const
|
||||
noexcept(_S_noexcept<_Tp, _Up>())
|
||||
{
|
||||
static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
|
||||
|
||||
if constexpr (floating_point<decay_t<_Tp>>)
|
||||
return __cmp_cust::__fp_weak_ordering(__e, __f);
|
||||
else if constexpr (__adl_weak<_Tp, _Up>)
|
||||
return weak_ordering(weak_order(static_cast<_Tp&&>(__e),
|
||||
static_cast<_Up&&>(__f)));
|
||||
else if constexpr (__op_cmp<weak_ordering, _Tp, _Up>)
|
||||
return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
|
||||
else if constexpr (__strongly_ordered<_Tp, _Up>)
|
||||
return _Strong_order{}(static_cast<_Tp&&>(__e),
|
||||
static_cast<_Up&&>(__f));
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Up>
|
||||
concept __partially_ordered
|
||||
= __adl_partial<_Tp, _Up>
|
||||
|| __op_cmp<partial_ordering, _Tp, _Up>
|
||||
|| __weakly_ordered<_Tp, _Up>;
|
||||
|
||||
class _Partial_order
|
||||
{
|
||||
template<typename _Tp, typename _Up>
|
||||
static constexpr bool
|
||||
_S_noexcept()
|
||||
{
|
||||
if constexpr (__adl_partial<_Tp, _Up>)
|
||||
return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
|
||||
std::declval<_Up>())));
|
||||
else if constexpr (__op_cmp<partial_ordering, _Tp, _Up>)
|
||||
return noexcept(std::declval<_Tp>() <=> std::declval<_Up>());
|
||||
else if constexpr (__weakly_ordered<_Tp, _Up>)
|
||||
return _Weak_order::_S_noexcept<_Tp, _Up>();
|
||||
}
|
||||
|
||||
friend class _Partial_fallback;
|
||||
|
||||
public:
|
||||
template<typename _Tp, typename _Up>
|
||||
requires __partially_ordered<_Tp, _Up>
|
||||
constexpr partial_ordering
|
||||
operator()(_Tp&& __e, _Up&& __f) const
|
||||
noexcept(_S_noexcept<_Tp, _Up>())
|
||||
{
|
||||
static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
|
||||
|
||||
if constexpr (__adl_partial<_Tp, _Up>)
|
||||
return partial_ordering(partial_order(static_cast<_Tp&&>(__e),
|
||||
static_cast<_Up&&>(__f)));
|
||||
else if constexpr (__op_cmp<partial_ordering, _Tp, _Up>)
|
||||
return static_cast<_Tp&&>(__e) <=> static_cast<_Up&&>(__f);
|
||||
else if constexpr (__weakly_ordered<_Tp, _Up>)
|
||||
return _Weak_order{}(static_cast<_Tp&&>(__e),
|
||||
static_cast<_Up&&>(__f));
|
||||
}
|
||||
};
|
||||
|
||||
template<typename _Tp, typename _Up>
|
||||
concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u)
|
||||
{
|
||||
{ static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) }
|
||||
-> convertible_to<bool>;
|
||||
{ static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) }
|
||||
-> convertible_to<bool>;
|
||||
};
|
||||
|
||||
class _Strong_fallback
|
||||
{
|
||||
template<typename _Tp, typename _Up>
|
||||
static constexpr bool
|
||||
_S_noexcept()
|
||||
{
|
||||
if constexpr (__strongly_ordered<_Tp, _Up>)
|
||||
return _Strong_order::_S_noexcept<_Tp, _Up>();
|
||||
else
|
||||
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
|
||||
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
|
||||
}
|
||||
|
||||
public:
|
||||
template<typename _Tp, typename _Up>
|
||||
requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
|
||||
constexpr decltype(auto)
|
||||
operator()(_Tp&& __e, _Up&& __f) const
|
||||
noexcept(_S_noexcept<_Tp, _Up>())
|
||||
{
|
||||
static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
|
||||
|
||||
if constexpr (__strongly_ordered<_Tp, _Up>)
|
||||
return _Strong_order{}(static_cast<_Tp&&>(__e),
|
||||
static_cast<_Up&&>(__f));
|
||||
else if constexpr (__op_eq_lt<_Tp, _Up>)
|
||||
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
|
||||
? strong_ordering::equal
|
||||
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
|
||||
? strong_ordering::less
|
||||
: strong_ordering::greater;
|
||||
}
|
||||
};
|
||||
|
||||
class _Weak_fallback
|
||||
{
|
||||
template<typename _Tp, typename _Up>
|
||||
static constexpr bool
|
||||
_S_noexcept()
|
||||
{
|
||||
if constexpr (__weakly_ordered<_Tp, _Up>)
|
||||
return _Weak_order::_S_noexcept<_Tp, _Up>();
|
||||
else
|
||||
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
|
||||
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
|
||||
}
|
||||
|
||||
public:
|
||||
template<typename _Tp, typename _Up>
|
||||
requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
|
||||
constexpr decltype(auto)
|
||||
operator()(_Tp&& __e, _Up&& __f) const
|
||||
noexcept(_S_noexcept<_Tp, _Up>())
|
||||
{
|
||||
static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
|
||||
|
||||
if constexpr (__weakly_ordered<_Tp, _Up>)
|
||||
return _Weak_order{}(static_cast<_Tp&&>(__e),
|
||||
static_cast<_Up&&>(__f));
|
||||
else if constexpr (__op_eq_lt<_Tp, _Up>)
|
||||
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
|
||||
? weak_ordering::equivalent
|
||||
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
|
||||
? weak_ordering::less
|
||||
: weak_ordering::greater;
|
||||
}
|
||||
};
|
||||
|
||||
class _Partial_fallback
|
||||
{
|
||||
template<typename _Tp, typename _Up>
|
||||
static constexpr bool
|
||||
_S_noexcept()
|
||||
{
|
||||
if constexpr (__partially_ordered<_Tp, _Up>)
|
||||
return _Partial_order::_S_noexcept<_Tp, _Up>();
|
||||
else
|
||||
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
|
||||
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
|
||||
}
|
||||
|
||||
public:
|
||||
template<typename _Tp, typename _Up>
|
||||
requires __partially_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
|
||||
constexpr decltype(auto)
|
||||
operator()(_Tp&& __e, _Up&& __f) const
|
||||
noexcept(_S_noexcept<_Tp, _Up>())
|
||||
{
|
||||
static_assert(same_as<decay_t<_Tp>, decay_t<_Up>>);
|
||||
|
||||
if constexpr (__partially_ordered<_Tp, _Up>)
|
||||
return _Partial_order{}(static_cast<_Tp&&>(__e),
|
||||
static_cast<_Up&&>(__f));
|
||||
else if constexpr (__op_eq_lt<_Tp, _Up>)
|
||||
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
|
||||
? partial_ordering::equivalent
|
||||
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
|
||||
? partial_ordering::less
|
||||
: static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e)
|
||||
? partial_ordering::greater
|
||||
: partial_ordering::unordered;
|
||||
}
|
||||
};
|
||||
} // namespace __cmp_cust
|
||||
|
||||
// [cmp.alg], comparison algorithms
|
||||
inline namespace __cmp_alg
|
||||
{
|
||||
// TODO
|
||||
#if 0
|
||||
inline constexpr unspecified strong_order = unspecified;
|
||||
inline constexpr unspecified weak_order = unspecified;
|
||||
inline constexpr unspecified partial_order = unspecified;
|
||||
inline constexpr unspecified compare_strong_order_fallback = unspecified;
|
||||
inline constexpr unspecified compare_weak_order_fallback = unspecified;
|
||||
inline constexpr unspecified compare_partial_order_fallback = unspecified;
|
||||
#endif
|
||||
inline constexpr __cmp_cust::_Strong_order strong_order{};
|
||||
|
||||
inline constexpr __cmp_cust::_Weak_order weak_order{};
|
||||
|
||||
inline constexpr __cmp_cust::_Partial_order partial_order{};
|
||||
|
||||
inline constexpr __cmp_cust::_Strong_fallback
|
||||
compare_strong_order_fallback{};
|
||||
|
||||
inline constexpr __cmp_cust::_Weak_fallback
|
||||
compare_weak_order_fallback{};
|
||||
|
||||
inline constexpr __cmp_cust::_Partial_fallback
|
||||
compare_partial_order_fallback{};
|
||||
}
|
||||
#endif
|
||||
#endif // concepts
|
||||
} // namespace std
|
||||
|
||||
#pragma GCC visibility pop
|
||||
|
|
|
|||
|
|
@ -0,0 +1,118 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=gnu++2a" }
|
||||
// { dg-do run { target c++2a } }
|
||||
|
||||
#include <compare>
|
||||
#include <limits>
|
||||
#include <testsuite_hooks.h>
|
||||
|
||||
using std::partial_order;
|
||||
using std::partial_ordering;
|
||||
|
||||
void
|
||||
test01()
|
||||
{
|
||||
int one = 1, two = 2;
|
||||
|
||||
VERIFY( partial_order(one, two) == partial_ordering::less );
|
||||
VERIFY( partial_order(one, one) == partial_ordering::equivalent );
|
||||
VERIFY( partial_order(two, one) == partial_ordering::greater );
|
||||
static_assert( noexcept(partial_order(1, 1)) );
|
||||
}
|
||||
|
||||
constexpr partial_ordering different_cv_quals(int i, const int j)
|
||||
{
|
||||
return partial_order(i, j);
|
||||
}
|
||||
|
||||
void
|
||||
test02()
|
||||
{
|
||||
int fortytwo = 42, nines = 999, lots = 1000;
|
||||
VERIFY( different_cv_quals(fortytwo, nines) == partial_ordering::less );
|
||||
VERIFY( different_cv_quals(-nines, -nines) == partial_ordering::equivalent );
|
||||
VERIFY( different_cv_quals(-nines, -lots) == partial_ordering::greater );
|
||||
}
|
||||
|
||||
void
|
||||
test03()
|
||||
{
|
||||
double zero = 0.0;
|
||||
VERIFY( partial_order(zero, zero) == partial_ordering::equivalent );
|
||||
VERIFY( partial_order(-zero, -zero) == partial_ordering::equivalent );
|
||||
VERIFY( partial_order(-zero, zero) == partial_ordering::equivalent );
|
||||
VERIFY( partial_order(zero, -zero) == partial_ordering::equivalent );
|
||||
static_assert( noexcept(partial_order(zero, 1.0)) );
|
||||
static_assert( partial_order(0.0, 1.0) == std::partial_ordering::less );
|
||||
|
||||
double min = std::numeric_limits<double>::lowest();
|
||||
double max = std::numeric_limits<double>::max();
|
||||
double nan = std::numeric_limits<double>::quiet_NaN();
|
||||
double inf = std::numeric_limits<double>::infinity();
|
||||
double denorm = std::numeric_limits<double>::denorm_min();
|
||||
double smallest = std::numeric_limits<double>::min();
|
||||
double epsilon = std::numeric_limits<double>::epsilon();
|
||||
VERIFY( partial_order(denorm, smallest) == partial_ordering::less );
|
||||
VERIFY( partial_order(denorm, 0.0) == partial_ordering::greater );
|
||||
VERIFY( partial_order(0.0, nan) == partial_ordering::unordered );
|
||||
VERIFY( partial_order(nan, nan) == partial_ordering::unordered );
|
||||
VERIFY( partial_order(nan, 0.0) == partial_ordering::unordered );
|
||||
VERIFY( partial_order(-nan, 0.0) == partial_ordering::unordered );
|
||||
VERIFY( partial_order(-nan, min) == partial_ordering::unordered );
|
||||
VERIFY( partial_order(-inf, min) == partial_ordering::less );
|
||||
VERIFY( partial_order(-nan, -inf) == partial_ordering::unordered );
|
||||
VERIFY( partial_order(-inf, -nan) == partial_ordering::unordered );
|
||||
VERIFY( partial_order(max, inf) == partial_ordering::less );
|
||||
VERIFY( partial_order(inf, max) == partial_ordering::greater );
|
||||
VERIFY( partial_order(inf, nan) == partial_ordering::unordered );
|
||||
VERIFY( partial_order(1.0, 1.0+epsilon) == partial_ordering::less );
|
||||
}
|
||||
|
||||
namespace N
|
||||
{
|
||||
struct X { int i; };
|
||||
|
||||
constexpr partial_ordering operator<=>(X l, X r)
|
||||
{
|
||||
if (l.i < 0 && r.i < 0)
|
||||
return partial_ordering::equivalent;
|
||||
return r.i <=> l.i;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
test04()
|
||||
{
|
||||
using N::X;
|
||||
X one{1};
|
||||
X negone{-1};
|
||||
|
||||
VERIFY( partial_order(one, X{1}) == partial_ordering::equivalent );
|
||||
VERIFY( partial_order(negone, X{-2}) == partial_ordering::equivalent );
|
||||
VERIFY( partial_order(one, X{2}) == partial_ordering::greater );
|
||||
static_assert( !noexcept(partial_order(X{1}, X{2})) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
test02();
|
||||
test03();
|
||||
test04();
|
||||
}
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=gnu++2a" }
|
||||
// { dg-do compile { target c++2a } }
|
||||
|
||||
#include <compare>
|
||||
#include <limits>
|
||||
|
||||
using std::strong_order;
|
||||
using std::strong_ordering;
|
||||
|
||||
static_assert( strong_order(1, 2) == strong_ordering::less );
|
||||
static_assert( strong_order(1, 1) == strong_ordering::equal );
|
||||
static_assert( strong_order(2, 1) == strong_ordering::greater );
|
||||
static_assert( noexcept(strong_order(1, 1)) );
|
||||
|
||||
constexpr strong_ordering different_cv_quals(int i, const int j)
|
||||
{
|
||||
return strong_order(i, j);
|
||||
}
|
||||
static_assert( different_cv_quals(42, 999) == strong_ordering::less );
|
||||
static_assert( different_cv_quals(-999, -999) == strong_ordering::equal );
|
||||
static_assert( different_cv_quals(-99, -111) == strong_ordering::greater );
|
||||
|
||||
namespace N
|
||||
{
|
||||
struct X { int i; };
|
||||
|
||||
constexpr strong_ordering operator<=>(X l, X r)
|
||||
{
|
||||
if (l.i < 0 && r.i < 0)
|
||||
return strong_ordering::equivalent;
|
||||
return r.i <=> l.i;
|
||||
}
|
||||
}
|
||||
using N::X;
|
||||
|
||||
static_assert( strong_order(X{1}, X{1}) == strong_ordering::equal );
|
||||
static_assert( strong_order(X{-1}, X{-2}) == strong_ordering::equivalent );
|
||||
static_assert( strong_order(X{1}, X{2}) == strong_ordering::greater );
|
||||
static_assert( !noexcept(strong_order(X{1}, X{2})) );
|
||||
|
|
@ -0,0 +1,119 @@
|
|||
// Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 3, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
// { dg-options "-std=gnu++2a" }
|
||||
// { dg-do run { target c++2a } }
|
||||
|
||||
#include <compare>
|
||||
#include <limits>
|
||||
#include <testsuite_hooks.h>
|
||||
|
||||
using std::weak_order;
|
||||
using std::weak_ordering;
|
||||
|
||||
void
|
||||
test01()
|
||||
{
|
||||
int one = 1, two = 2;
|
||||
|
||||
VERIFY( weak_order(one, two) == weak_ordering::less );
|
||||
VERIFY( weak_order(one, one) == weak_ordering::equivalent );
|
||||
VERIFY( weak_order(two, one) == weak_ordering::greater );
|
||||
static_assert( noexcept(weak_order(1, 1)) );
|
||||
}
|
||||
|
||||
constexpr weak_ordering different_cv_quals(int i, const int j)
|
||||
{
|
||||
return weak_order(i, j);
|
||||
}
|
||||
|
||||
void
|
||||
test02()
|
||||
{
|
||||
int fortytwo = 42, nines = 999, lots = 1000;
|
||||
|
||||
VERIFY( different_cv_quals(fortytwo, nines) == weak_ordering::less );
|
||||
VERIFY( different_cv_quals(-nines, -nines) == weak_ordering::equivalent );
|
||||
VERIFY( different_cv_quals(-nines, -lots) == weak_ordering::greater );
|
||||
}
|
||||
|
||||
void
|
||||
test03()
|
||||
{
|
||||
double zero = 0.0;
|
||||
VERIFY( weak_order(zero, zero) == weak_ordering::equivalent );
|
||||
VERIFY( weak_order(-zero, -zero) == weak_ordering::equivalent );
|
||||
VERIFY( weak_order(-zero, zero) == weak_ordering::equivalent );
|
||||
VERIFY( weak_order(zero, -zero) == weak_ordering::equivalent );
|
||||
|
||||
double min = std::numeric_limits<double>::lowest();
|
||||
double max = std::numeric_limits<double>::max();
|
||||
double nan = std::numeric_limits<double>::quiet_NaN();
|
||||
double inf = std::numeric_limits<double>::infinity();
|
||||
double denorm = std::numeric_limits<double>::denorm_min();
|
||||
double smallest = std::numeric_limits<double>::min();
|
||||
double epsilon = std::numeric_limits<double>::epsilon();
|
||||
VERIFY( weak_order(denorm, smallest) == weak_ordering::less );
|
||||
VERIFY( weak_order(denorm, 0.0) == weak_ordering::greater );
|
||||
VERIFY( weak_order(0.0, nan) == weak_ordering::less );
|
||||
VERIFY( weak_order(nan, nan) == weak_ordering::equivalent );
|
||||
VERIFY( weak_order(nan, -nan) == weak_ordering::greater );
|
||||
VERIFY( weak_order(-nan, nan) == weak_ordering::less );
|
||||
VERIFY( weak_order(nan, 0.0) == weak_ordering::greater );
|
||||
VERIFY( weak_order(-nan, 0.0) == weak_ordering::less );
|
||||
VERIFY( weak_order(-nan, min) == weak_ordering::less );
|
||||
VERIFY( weak_order(-inf, min) == weak_ordering::less );
|
||||
VERIFY( weak_order(-nan, -inf) == weak_ordering::less );
|
||||
VERIFY( weak_order(-inf, -nan) == weak_ordering::greater );
|
||||
VERIFY( weak_order(max, inf) == weak_ordering::less );
|
||||
VERIFY( weak_order(inf, max) == weak_ordering::greater );
|
||||
VERIFY( weak_order(inf, nan) == weak_ordering::less );
|
||||
VERIFY( weak_order(1.0, 1.0+epsilon) == weak_ordering::less );
|
||||
}
|
||||
|
||||
namespace N
|
||||
{
|
||||
struct X { int i; };
|
||||
|
||||
constexpr weak_ordering operator<=>(X l, X r)
|
||||
{
|
||||
if (l.i < 0 && r.i < 0)
|
||||
return weak_ordering::equivalent;
|
||||
return r.i <=> l.i;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
test04()
|
||||
{
|
||||
using N::X;
|
||||
X one{1};
|
||||
X negone{-1};
|
||||
|
||||
VERIFY( weak_order(one, X{1}) == weak_ordering::equivalent );
|
||||
VERIFY( weak_order(negone, X{-2}) == weak_ordering::equivalent );
|
||||
VERIFY( weak_order(one, X{2}) == weak_ordering::greater );
|
||||
static_assert( !noexcept(weak_order(X{1}, X{2})) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test01();
|
||||
test02();
|
||||
test03();
|
||||
test04();
|
||||
}
|
||||
Loading…
Reference in New Issue