[libcxx] r329460 - Implement P0768r1: Library support for the Spaceship Operator.
Richard Smith via cfe-commits
cfe-commits at lists.llvm.org
Fri Apr 6 15:00:15 PDT 2018
On 6 April 2018 at 14:37, Eric Fiselier via cfe-commits <
cfe-commits at lists.llvm.org> wrote:
> Author: ericwf
> Date: Fri Apr 6 14:37:23 2018
> New Revision: 329460
>
> URL: http://llvm.org/viewvc/llvm-project?rev=329460&view=rev
> Log:
> Implement P0768r1: Library support for the Spaceship Operator.
>
> this patch adds the <compare> header and implements all of it
> except for [comp.alg].
>
> As I understand it, the header is needed by the compiler in
> when implementing the semantics of operator<=>. For that reason
> I feel it's important to land this header early, despite
> all compilers lacking support.
>
> Added:
> libcxx/trunk/include/compare
> libcxx/trunk/test/libcxx/language.support/cmp/
> libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp
> libcxx/trunk/test/std/language.support/cmp/
> libcxx/trunk/test/std/language.support/cmp/cmp.common/
> libcxx/trunk/test/std/language.support/cmp/cmp.
> common/common_comparison_category.pass.cpp
> libcxx/trunk/test/std/language.support/cmp/cmp.partialord/
> libcxx/trunk/test/std/language.support/cmp/cmp.
> partialord/partialord.pass.cpp
> libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/
> libcxx/trunk/test/std/language.support/cmp/cmp.
> strongeq/cmp.strongeq.pass.cpp
> libcxx/trunk/test/std/language.support/cmp/cmp.strongord/
> libcxx/trunk/test/std/language.support/cmp/cmp.
> strongord/strongord.pass.cpp
> libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/
> libcxx/trunk/test/std/language.support/cmp/cmp.
> weakeq/cmp.weakeq.pass.cpp
> libcxx/trunk/test/std/language.support/cmp/cmp.weakord/
> libcxx/trunk/test/std/language.support/cmp/cmp.
> weakord/weakord.pass.cpp
> Modified:
> libcxx/trunk/include/CMakeLists.txt
> libcxx/trunk/include/__config
> libcxx/trunk/include/module.modulemap
> libcxx/trunk/test/libcxx/double_include.sh.cpp
> libcxx/trunk/test/support/test_macros.h
>
> Modified: libcxx/trunk/include/CMakeLists.txt
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/
> CMakeLists.txt?rev=329460&r1=329459&r2=329460&view=diff
> ============================================================
> ==================
> --- libcxx/trunk/include/CMakeLists.txt (original)
> +++ libcxx/trunk/include/CMakeLists.txt Fri Apr 6 14:37:23 2018
> @@ -77,5 +77,4 @@ if (LIBCXX_INSTALL_HEADERS)
> add_custom_target(install-libcxx-headers DEPENDS install-cxx-headers)
> add_custom_target(install-libcxx-headers-stripped DEPENDS
> install-cxx-headers-stripped)
> endif()
> -
> endif()
>
> Modified: libcxx/trunk/include/__config
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/_
> _config?rev=329460&r1=329459&r2=329460&view=diff
> ============================================================
> ==================
> --- libcxx/trunk/include/__config (original)
> +++ libcxx/trunk/include/__config Fri Apr 6 14:37:23 2018
> @@ -1196,6 +1196,11 @@ _LIBCPP_FUNC_VIS extern "C" void __sanit
> #define _LIBCPP_HAS_NO_COROUTINES
> #endif
>
> +// FIXME: Correct this macro when either (A) a feature test macro for the
> +// spaceship operator is provided, or (B) a compiler provides a complete
> +// implementation.
> +#define _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +
> // Decide whether to use availability macros.
> #if !defined(_LIBCPP_BUILDING_LIBRARY) &&
> \
> !defined(_LIBCPP_DISABLE_AVAILABILITY) &&
> \
>
> Added: libcxx/trunk/include/compare
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/
> compare?rev=329460&view=auto
> ============================================================
> ==================
> --- libcxx/trunk/include/compare (added)
> +++ libcxx/trunk/include/compare Fri Apr 6 14:37:23 2018
> @@ -0,0 +1,679 @@
> +// -*- C++ -*-
> +//===-------------------------- compare ------------------------------
> -----===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===------------------------------------------------------
> ----------------===//
> +
> +#ifndef _LIBCPP_COMPARE
> +#define _LIBCPP_COMPARE
> +
> +/*
> + compare synopsis
> +
> +namespace std {
> + // [cmp.categories], comparison category types
> + class weak_equality;
> + class strong_equality;
> + class partial_ordering;
> + class weak_ordering;
> + class strong_ordering;
> +
> + // named comparison functions
> + constexpr bool is_eq (weak_equality cmp) noexcept { return cmp ==
> 0; }
> + constexpr bool is_neq (weak_equality cmp) noexcept { return cmp !=
> 0; }
> + constexpr bool is_lt (partial_ordering cmp) noexcept { return cmp < 0;
> }
> + constexpr bool is_lteq(partial_ordering cmp) noexcept { return cmp <=
> 0; }
> + constexpr bool is_gt (partial_ordering cmp) noexcept { return cmp > 0;
> }
> + constexpr bool is_gteq(partial_ordering cmp) noexcept { return cmp >=
> 0; }
> +
> + // [cmp.common], common comparison category type
> + template<class... Ts>
> + struct common_comparison_category {
> + using type = see below;
> + };
> + template<class... Ts>
> + using common_comparison_category_t = typename
> common_comparison_category<Ts...>::type;
> +
> + // [cmp.alg], comparison algorithms
> + template<class T> constexpr strong_ordering strong_order(const T& a,
> const T& b);
> + template<class T> constexpr weak_ordering weak_order(const T& a, const
> T& b);
> + template<class T> constexpr partial_ordering partial_order(const T& a,
> const T& b);
> + template<class T> constexpr strong_equality strong_equal(const T& a,
> const T& b);
> + template<class T> constexpr weak_equality weak_equal(const T& a, const
> T& b);
> +}
> +*/
> +
> +#include <__config>
> +#include <type_traits>
> +#include <array>
> +
> +#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
> +#pragma GCC system_header
> +#endif
> +
> +_LIBCPP_BEGIN_NAMESPACE_STD
> +
> +#if _LIBCPP_STD_VER > 17
> +
> +// exposition only
> +enum class _LIBCPP_ENUM_VIS _EqResult : unsigned char {
> + __zero = 0,
> + __equal = __zero,
> + __equiv = __equal,
> + __nonequal = 1,
> + __nonequiv = __nonequal
> +};
> +
> +enum class _LIBCPP_ENUM_VIS _OrdResult : signed char {
> + __less = -1,
> + __greater = 1
> +};
> +
> +enum class _LIBCPP_ENUM_VIS _NCmpResult : signed char {
> + __unordered = -127
> +};
> +
> +struct _CmpUnspecifiedType;
> +using _CmpUnspecifiedParam = void (_CmpUnspecifiedType::*)();
>
FYI, I've been planning to add a __zero_type to the compiler for this (a
type that can only be initialized by a literal zero, not e.g. by nullptr).
Looks like that would be easy to retrofit here once it's available.
+
> +class weak_equality {
> + _LIBCPP_INLINE_VISIBILITY
> + constexpr explicit weak_equality(_EqResult __val) noexcept :
> __value_(__val) {}
> +
> +public:
> + static const weak_equality equivalent;
> + static const weak_equality nonequivalent;
> +
> + friend constexpr bool operator==(weak_equality __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator==(_CmpUnspecifiedParam, weak_equality
> __v) noexcept;
> + friend constexpr bool operator!=(weak_equality __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality
> __v) noexcept;
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> + friend constexpr weak_equality operator<=>(weak_equality __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr weak_equality operator<=>(_CmpUnspecifiedParam,
> weak_equality __v) noexcept;
> +#endif
> +
> +private:
> + _EqResult __value_;
> +};
> +
> +_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::equivalent(_
> EqResult::__equiv);
> +_LIBCPP_INLINE_VAR constexpr weak_equality weak_equality::nonequivalent(_
> EqResult::__nonequiv);
> +
> +_LIBCPP_INLINE_VISIBILITY
> +inline constexpr bool operator==(weak_equality __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ == _EqResult::__zero;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +inline constexpr bool operator==(_CmpUnspecifiedParam, weak_equality
> __v) noexcept {
> + return __v.__value_ == _EqResult::__zero;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +inline constexpr bool operator!=(weak_equality __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ != _EqResult::__zero;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +inline constexpr bool operator!=(_CmpUnspecifiedParam, weak_equality
> __v) noexcept {
> + return __v.__value_ != _EqResult::__zero;
> +}
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +_LIBCPP_INLINE_VISIBILITY
> +inline constexpr weak_equality operator<=>(weak_equality __v,
> _CmpUnspecifiedParam) noexcept {
> + return __v;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +inline constexpr weak_equality operator<=>(_CmpUnspecifiedParam,
> weak_equality __v) noexcept {
> + return __v;
> +}
> +#endif
> +
> +class strong_equality {
> + _LIBCPP_INLINE_VISIBILITY
> + explicit constexpr strong_equality(_EqResult __val) noexcept :
> __value_(__val) {}
> +
> +public:
> + static const strong_equality equal;
> + static const strong_equality nonequal;
> + static const strong_equality equivalent;
> + static const strong_equality nonequivalent;
> +
> + // conversion
> + constexpr operator weak_equality() const noexcept {
> + return __value_ == _EqResult::__zero ? weak_equality::equivalent
> + : weak_equality::nonequivalent;
> + }
> +
> + // comparisons
> + friend constexpr bool operator==(strong_equality __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator!=(strong_equality __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator==(_CmpUnspecifiedParam, strong_equality
> __v) noexcept;
> + friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality
> __v) noexcept;
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> + friend constexpr strong_equality operator<=>(strong_equality __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr strong_equality operator<=>(_CmpUnspecifiedParam,
> strong_equality __v) noexcept;
> +#endif
> +private:
> + _EqResult __value_;
> +};
> +
> +_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equal(_
> EqResult::__equal);
> +_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::nonequal(_
> EqResult::__nonequal);
> +_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::equivalent(_
> EqResult::__equiv);
> +_LIBCPP_INLINE_VAR constexpr strong_equality strong_equality::
> nonequivalent(_EqResult::__nonequiv);
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator==(strong_equality __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ == _EqResult::__zero;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator==(_CmpUnspecifiedParam, strong_equality __v)
> noexcept {
> + return __v.__value_ == _EqResult::__zero;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator!=(strong_equality __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ != _EqResult::__zero;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator!=(_CmpUnspecifiedParam, strong_equality __v)
> noexcept {
> + return __v.__value_ != _EqResult::__zero;
> +}
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr strong_equality operator<=>(strong_equality __v,
> _CmpUnspecifiedParam) noexcept {
> + return __v;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr strong_equality operator<=>(_CmpUnspecifiedParam,
> strong_equality __v) noexcept {
> + return __v;
> +}
> +#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +
> +class partial_ordering {
> + using _ValueT = signed char;
> +
> + _LIBCPP_INLINE_VISIBILITY
> + explicit constexpr partial_ordering(_EqResult __v) noexcept
> + : __value_(_ValueT(__v)) {}
> +
> + _LIBCPP_INLINE_VISIBILITY
> + explicit constexpr partial_ordering(_OrdResult __v) noexcept
> + : __value_(_ValueT(__v)) {}
> +
> + _LIBCPP_INLINE_VISIBILITY
> + explicit constexpr partial_ordering(_NCmpResult __v) noexcept
> + : __value_(_ValueT(__v)) {}
> +
> + constexpr bool __is_ordered() const noexcept {
> + return __value_ != _ValueT(_NCmpResult::__unordered);
> + }
> +public:
> + // valid values
> + static const partial_ordering less;
> + static const partial_ordering equivalent;
> + static const partial_ordering greater;
> + static const partial_ordering unordered;
> +
> + // conversion
> + constexpr operator weak_equality() const noexcept {
> + return __value_ == 0 ? weak_equality::equivalent :
> weak_equality::nonequivalent;
> + }
> +
> + // comparisons
> + friend constexpr bool operator==(partial_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator!=(partial_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator< (partial_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator<=(partial_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator> (partial_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator>=(partial_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator==(_CmpUnspecifiedParam,
> partial_ordering __v) noexcept;
> + friend constexpr bool operator!=(_CmpUnspecifiedParam,
> partial_ordering __v) noexcept;
> + friend constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering
> __v) noexcept;
> + friend constexpr bool operator<=(_CmpUnspecifiedParam,
> partial_ordering __v) noexcept;
> + friend constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering
> __v) noexcept;
> + friend constexpr bool operator>=(_CmpUnspecifiedParam,
> partial_ordering __v) noexcept;
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> + friend constexpr partial_ordering operator<=>(partial_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam,
> partial_ordering __v) noexcept;
> +#endif
> +
> +private:
> + _ValueT __value_;
> +};
> +
> +_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::less(_
> OrdResult::__less);
> +_LIBCPP_INLINE_VAR constexpr partial_ordering
> partial_ordering::equivalent(_EqResult::__equiv);
> +_LIBCPP_INLINE_VAR constexpr partial_ordering partial_ordering::greater(_
> OrdResult::__greater);
> +_LIBCPP_INLINE_VAR constexpr partial_ordering
> partial_ordering::unordered(_NCmpResult ::__unordered);
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__is_ordered() && __v.__value_ == 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator< (partial_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__is_ordered() && __v.__value_ < 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__is_ordered() && __v.__value_ <= 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator> (partial_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__is_ordered() && __v.__value_ > 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__is_ordered() && __v.__value_ >= 0;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator==(_CmpUnspecifiedParam, partial_ordering __v)
> noexcept {
> + return __v.__is_ordered() && 0 == __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v)
> noexcept {
> + return __v.__is_ordered() && 0 < __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v)
> noexcept {
> + return __v.__is_ordered() && 0 <= __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v)
> noexcept {
> + return __v.__is_ordered() && 0 > __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v)
> noexcept {
> + return __v.__is_ordered() && 0 >= __v.__value_;
> +}
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator!=(partial_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return !__v.__is_ordered() || __v.__value_ != 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator!=(_CmpUnspecifiedParam, partial_ordering __v)
> noexcept {
> + return !__v.__is_ordered() || __v.__value_ != 0;
> +}
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr partial_ordering operator<=>(partial_ordering __v,
> _CmpUnspecifiedParam) noexcept {
> + return __v;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr partial_ordering operator<=>(_CmpUnspecifiedParam,
> partial_ordering __v) noexcept {
> + return __v < 0 ? partial_ordering::greater : (__v > 0 ?
> partial_ordering::less : __v);
> +}
> +#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +
> +class weak_ordering {
> + using _ValueT = signed char;
> +
> + _LIBCPP_INLINE_VISIBILITY
> + explicit constexpr weak_ordering(_EqResult __v) noexcept :
> __value_(_ValueT(__v)) {}
> + _LIBCPP_INLINE_VISIBILITY
> + explicit constexpr weak_ordering(_OrdResult __v) noexcept :
> __value_(_ValueT(__v)) {}
> +
> +public:
> + static const weak_ordering less;
> + static const weak_ordering equivalent;
> + static const weak_ordering greater;
> +
> + // conversions
> + _LIBCPP_INLINE_VISIBILITY
> + constexpr operator weak_equality() const noexcept {
> + return __value_ == 0 ? weak_equality::equivalent
> + : weak_equality::nonequivalent;
> + }
> +
> + _LIBCPP_INLINE_VISIBILITY
> + constexpr operator partial_ordering() const noexcept {
> + return __value_ == 0 ? partial_ordering::equivalent
> + : (__value_ < 0 ? partial_ordering::less :
> partial_ordering::greater);
> + }
> +
> + // comparisons
> + friend constexpr bool operator==(weak_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator!=(weak_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator< (weak_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator<=(weak_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator> (weak_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator>=(weak_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering
> __v) noexcept;
> + friend constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering
> __v) noexcept;
> + friend constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering
> __v) noexcept;
> + friend constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering
> __v) noexcept;
> + friend constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering
> __v) noexcept;
> + friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering
> __v) noexcept;
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> + friend constexpr weak_ordering operator<=>(weak_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam,
> weak_ordering __v) noexcept;
> +#endif
> +
> +private:
> + _ValueT __value_;
> +};
> +
> +_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::less(_
> OrdResult::__less);
> +_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::equivalent(_
> EqResult::__equiv);
> +_LIBCPP_INLINE_VAR constexpr weak_ordering weak_ordering::greater(_
> OrdResult::__greater);
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ == 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator!=(weak_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ != 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator< (weak_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ < 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ <= 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator> (weak_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ > 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ >= 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator==(_CmpUnspecifiedParam, weak_ordering __v)
> noexcept {
> + return 0 == __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator!=(_CmpUnspecifiedParam, weak_ordering __v)
> noexcept {
> + return 0 != __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v)
> noexcept {
> + return 0 < __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v)
> noexcept {
> + return 0 <= __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v)
> noexcept {
> + return 0 > __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v)
> noexcept {
> + return 0 >= __v.__value_;
> +}
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr weak_ordering operator<=>(weak_ordering __v,
> _CmpUnspecifiedParam) noexcept {
> + return __v;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering
> __v) noexcept {
> + return __v < 0 ? weak_ordering::greater : (__v > 0 ?
> weak_ordering::less : __v);
> +}
> +#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +
> +class strong_ordering {
> + using _ValueT = signed char;
> +
> + _LIBCPP_INLINE_VISIBILITY
> + explicit constexpr strong_ordering(_EqResult __v) noexcept :
> __value_(_ValueT(__v)) {}
> + _LIBCPP_INLINE_VISIBILITY
> + explicit constexpr strong_ordering(_OrdResult __v) noexcept :
> __value_(_ValueT(__v)) {}
> +
> +public:
> + static const strong_ordering less;
> + static const strong_ordering equal;
> + static const strong_ordering equivalent;
> + static const strong_ordering greater;
> +
> + // conversions
> + _LIBCPP_INLINE_VISIBILITY
> + constexpr operator weak_equality() const noexcept {
> + return __value_ == 0 ? weak_equality::equivalent
> + : weak_equality::nonequivalent;
> + }
> +
> + _LIBCPP_INLINE_VISIBILITY
> + constexpr operator strong_equality() const noexcept {
> + return __value_ == 0 ? strong_equality::equal
> + : strong_equality::nonequal;
> + }
> +
> + _LIBCPP_INLINE_VISIBILITY
> + constexpr operator partial_ordering() const noexcept {
> + return __value_ == 0 ? partial_ordering::equivalent
> + : (__value_ < 0 ? partial_ordering::less :
> partial_ordering::greater);
> + }
> +
> + _LIBCPP_INLINE_VISIBILITY
> + constexpr operator weak_ordering() const noexcept {
> + return __value_ == 0 ? weak_ordering::equivalent
> + : (__value_ < 0 ? weak_ordering::less : weak_ordering::greater);
> + }
> +
> + // comparisons
> + friend constexpr bool operator==(strong_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator!=(strong_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator< (strong_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator<=(strong_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator> (strong_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator>=(strong_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering
> __v) noexcept;
> + friend constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering
> __v) noexcept;
> + friend constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering
> __v) noexcept;
> + friend constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering
> __v) noexcept;
> + friend constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering
> __v) noexcept;
> + friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering
> __v) noexcept;
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> + friend constexpr strong_ordering operator<=>(strong_ordering __v,
> _CmpUnspecifiedParam) noexcept;
> + friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam,
> strong_ordering __v) noexcept;
> +#endif
> +
> +private:
> + _ValueT __value_;
> +};
> +
> +_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::less(_
> OrdResult::__less);
> +_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::equal(_
> EqResult::__equal);
> +_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::equivalent(_
> EqResult::__equiv);
> +_LIBCPP_INLINE_VAR constexpr strong_ordering strong_ordering::greater(_
> OrdResult::__greater);
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ == 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator!=(strong_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ != 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator< (strong_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ < 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ <= 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator> (strong_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ > 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam)
> noexcept {
> + return __v.__value_ >= 0;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator==(_CmpUnspecifiedParam, strong_ordering __v)
> noexcept {
> + return 0 == __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator!=(_CmpUnspecifiedParam, strong_ordering __v)
> noexcept {
> + return 0 != __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v)
> noexcept {
> + return 0 < __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v)
> noexcept {
> + return 0 <= __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v)
> noexcept {
> + return 0 > __v.__value_;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v)
> noexcept {
> + return 0 >= __v.__value_;
> +}
> +
> +#ifndef _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr strong_ordering operator<=>(strong_ordering __v,
> _CmpUnspecifiedParam) noexcept {
> + return __v;
> +}
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr strong_ordering operator<=>(_CmpUnspecifiedParam,
> strong_ordering __v) noexcept {
> + return __v < 0 ? strong_ordering::greater : (__v > 0 ?
> strong_ordering::less : __v);
> +}
> +#endif // _LIBCPP_HAS_NO_SPACESHIP_OPERATOR
> +
> +// named comparison functions
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool is_eq(weak_equality __cmp) noexcept { return __cmp ==
> 0; }
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool is_neq(weak_equality __cmp) noexcept { return __cmp !=
> 0; }
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool is_lt(partial_ordering __cmp) noexcept { return __cmp < 0;
> }
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool is_lteq(partial_ordering __cmp) noexcept { return __cmp <=
> 0; }
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool is_gt(partial_ordering __cmp) noexcept { return __cmp > 0;
> }
> +
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr bool is_gteq(partial_ordering __cmp) noexcept { return __cmp >=
> 0; }
> +
> +namespace __comp_detail {
> +
> +enum _ClassifyCompCategory : unsigned{
> + _None,
> + _WeakEq,
> + _StrongEq,
> + _PartialOrd,
> + _WeakOrd,
> + _StrongOrd,
> + _CCC_Size
> +};
> +
> +template <class _Tp>
> +_LIBCPP_INLINE_VISIBILITY
> +constexpr _ClassifyCompCategory __type_to_enum() noexcept {
> + if (is_same_v<_Tp, weak_equality>)
> + return _WeakEq;
> + if (is_same_v<_Tp, strong_equality>)
> + return _StrongEq;
> + if (is_same_v<_Tp, partial_ordering>)
> + return _PartialOrd;
> + if (is_same_v<_Tp, weak_ordering>)
> + return _WeakOrd;
> + if (is_same_v<_Tp, strong_ordering>)
> + return _StrongOrd;
> + return _None;
> +}
> +
> +template <size_t _Size>
> +constexpr _ClassifyCompCategory
> +__compute_comp_type(std::array<_ClassifyCompCategory, _Size> __types) {
> + std::array<int, _CCC_Size> __seen = {};
> + for (auto __type : __types)
> + ++__seen[__type];
> + if (__seen[_None])
> + return _None;
> + if (__seen[_WeakEq])
> + return _WeakEq;
> + if (__seen[_StrongEq] && (__seen[_PartialOrd] || __seen[_WeakOrd]))
> + return _WeakEq;
> + if (__seen[_StrongEq])
> + return _StrongEq;
> + if (__seen[_PartialOrd])
> + return _PartialOrd;
> + if (__seen[_WeakOrd])
> + return _WeakOrd;
> + return _StrongOrd;
> +}
>
Hmm, it'd be nice to ask the compiler to work this out rather than
repeating the algorithm here. For example, something like:
template<size_t, typename T> struct CCT { friend T operator<=>(const CCT&,
const CCT&); };
template<typename N, typename ...T> struct CCC;
template<size_t ...N, typename ...T> struct CCC : CCT<N, T>... {
friend auto operator<=>(const CCC&, const CCC&) = default;
};
template<typename ...T> struct common_comparison_category {
template<typename C> static auto test(int) -> decltype(declval<const
C&>() <=> declval<const C&>());
template<typename C> static void test(...);
using type = decltype(test<CCC<std::make_index_sequence<sizeof...(T)>,
T...>>(0));
}
... should allow you to ask the compiler for the common comparison type.
> +
> +template <class ..._Ts>
> +constexpr auto __get_comp_type() {
> + using _CCC = _ClassifyCompCategory;
> + constexpr array<_CCC, sizeof...(_Ts)> __type_kinds{__comp_detail::__
> type_to_enum<_Ts>()...};
> + constexpr _CCC _Cat = sizeof...(_Ts) == 0 ? _StrongOrd
> + : __compute_comp_type(__type_kinds);
> + if constexpr (_Cat == _None)
> + return ((void)0);
>
void() is a more idiomatic way to write this. (Incidentally, this case
seems like a bug in the library spec to me --
common_comparison_category<...>::type should not exist in the case where
there is no common comparison type, for consistency with the other traits.)
> + else if constexpr (_Cat == _WeakEq)
> + return weak_equality::equivalent;
> + else if constexpr (_Cat == _StrongEq)
> + return strong_equality::equivalent;
> + else if constexpr (_Cat == _PartialOrd)
> + return partial_ordering::equivalent;
> + else if constexpr (_Cat == _WeakOrd)
> + return weak_ordering::equivalent;
> + else if constexpr (_Cat == _StrongOrd)
> + return strong_ordering::equivalent;
> + else
> + static_assert(_Cat != _Cat, "unhandled case");
> +}
> +} // namespace __comp_detail
> +
> +// [cmp.common], common comparison category type
> +template<class... _Ts>
> +struct _LIBCPP_TEMPLATE_VIS common_comparison_category {
> + using type = decltype(__comp_detail::__get_comp_type<_Ts...>());
> +};
> +
> +template<class... _Ts>
> +using common_comparison_category_t = typename common_comparison_category<_
> Ts...>::type;
> +
> +// [cmp.alg], comparison algorithms
> +// TODO: unimplemented
> +template<class _Tp> constexpr strong_ordering strong_order(const _Tp&
> __lhs, const _Tp& __rhs);
> +template<class _Tp> constexpr weak_ordering weak_order(const _Tp& __lhs,
> const _Tp& __rhs);
> +template<class _Tp> constexpr partial_ordering partial_order(const _Tp&
> __lhs, const _Tp& __rhs);
> +template<class _Tp> constexpr strong_equality strong_equal(const _Tp&
> __lhs, const _Tp& __rhs);
> +template<class _Tp> constexpr weak_equality weak_equal(const _Tp& __lhs,
> const _Tp& __rhs);
> +
> +#endif // _LIBCPP_STD_VER > 17
> +
> +_LIBCPP_END_NAMESPACE_STD
> +
> +#endif // _LIBCPP_COMPARE
>
> Modified: libcxx/trunk/include/module.modulemap
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/
> module.modulemap?rev=329460&r1=329459&r2=329460&view=diff
> ============================================================
> ==================
> --- libcxx/trunk/include/module.modulemap (original)
> +++ libcxx/trunk/include/module.modulemap Fri Apr 6 14:37:23 2018
> @@ -243,6 +243,10 @@ module std [system] {
> header "codecvt"
> export *
> }
> + module compare {
> + header "compare"
> + export *
> + }
> module complex {
> header "complex"
> export *
>
> Modified: libcxx/trunk/test/libcxx/double_include.sh.cpp
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/
> libcxx/double_include.sh.cpp?rev=329460&r1=329459&r2=329460&view=diff
> ============================================================
> ==================
> --- libcxx/trunk/test/libcxx/double_include.sh.cpp (original)
> +++ libcxx/trunk/test/libcxx/double_include.sh.cpp Fri Apr 6 14:37:23
> 2018
> @@ -41,6 +41,7 @@
> #include <clocale>
> #include <cmath>
> #include <codecvt>
> +#include <compare>
> #include <complex>
> #include <complex.h>
> #include <condition_variable>
>
> Added: libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/
> libcxx/language.support/cmp/version.pass.cpp?rev=329460&view=auto
> ============================================================
> ==================
> --- libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp (added)
> +++ libcxx/trunk/test/libcxx/language.support/cmp/version.pass.cpp Fri
> Apr 6 14:37:23 2018
> @@ -0,0 +1,20 @@
> +//===------------------------------------------------------
> ----------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===------------------------------------------------------
> ----------------===//
> +
> +// <compare>
> +
> +#include <compare>
> +
> +#ifndef _LIBCPP_VERSION
> +#error _LIBCPP_VERSION not defined
> +#endif
> +
> +int main()
> +{
> +}
>
> Added: libcxx/trunk/test/std/language.support/cmp/cmp.
> common/common_comparison_category.pass.cpp
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/
> language.support/cmp/cmp.common/common_comparison_
> category.pass.cpp?rev=329460&view=auto
> ============================================================
> ==================
> --- libcxx/trunk/test/std/language.support/cmp/cmp.
> common/common_comparison_category.pass.cpp (added)
> +++ libcxx/trunk/test/std/language.support/cmp/cmp.
> common/common_comparison_category.pass.cpp Fri Apr 6 14:37:23 2018
> @@ -0,0 +1,93 @@
> +//===------------------------------------------------------
> ----------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===------------------------------------------------------
> ----------------===//
> +
> +// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
> +
> +// <compare>
> +
> +// template <class ...Ts> struct common_comparison_category
> +// template <class ...Ts> using common_comparison_category_t
> +
> +
> +#include <compare>
> +#include <type_traits>
> +#include <cassert>
> +
> +#include "test_macros.h"
> +
> +const volatile void* volatile sink;
> +
> +template <class Expect, class ...Args>
> +void test_cat() {
> + using Cat = std::common_comparison_category<Args...>;
> + using CatT = typename Cat::type;
> + static_assert(std::is_same<CatT, std::common_comparison_category_t<Args...>>::value,
> "");
> + static_assert(std::is_same<CatT, Expect>::value, "expected different
> category");
> +};
> +
> +
> +// [class.spaceship]p4: The 'common comparison type' U of a
> possibly-empty list
> +// of 'n' types T0, T1, ..., TN, is defined as follows:
> +int main() {
> + using WE = std::weak_equality;
> + using SE = std::strong_equality;
> + using PO = std::partial_ordering;
> + using WO = std::weak_ordering;
> + using SO = std::strong_ordering;
> +
> + // [class.spaceship]p4.1: If any Ti is not a comparison category tpe, U
> is void.
> + {
> + test_cat<void, void>();
> + test_cat<void, int*>();
> + test_cat<void, SO&>();
> + test_cat<void, SO const>();
> + test_cat<void, SO*>();
> + test_cat<void, SO, void, SO>();
> + }
> +
> + // [class.spaceship]p4.2: Otherwise, if at least on Ti is
> + // std::weak_equality, or at least one Ti is std::strong_equality and
> at least
> + // one Tj is std::partial_ordering or std::weak_ordering, U is
> std::weak_equality
> + {
> + test_cat<WE, WE>();
> + test_cat<WE, SO, WE, SO>();
> + test_cat<WE, SE, SO, PO>();
> + test_cat<WE, WO, SO, SE>();
> + }
> +
> + // [class.spaceship]p4.3: Otherwise, if at least one Ti is
> std::strong_equality,
> + // U is std::strong_equality
> + {
> + test_cat<SE, SE>();
> + test_cat<SE, SO, SE, SO>();
> + }
> +
> + // [class.spaceship]p4.4: Otherwise, if at least one Ti is
> std::partial_ordering,
> + // U is std::partial_ordering
> + {
> + test_cat<PO, PO>();
> + test_cat<PO, SO, PO, SO>();
> + test_cat<PO, WO, PO, SO>();
> + }
> +
> + // [class.spaceship]p4.5: Otherwise, if at least one Ti is
> std::weak_ordering,
> + // U is std::weak_ordering
> + {
> + test_cat<WO, WO>();
> + test_cat<WO, SO, WO, SO>();
> + }
> +
> + // [class.spaceship]p4.6: Otherwise, U is std::strong_ordering. [Note:
> in
> + // particular this is the result when n is 0. -- end note]
> + {
> + test_cat<SO>(); // empty type list
> + test_cat<SO, SO>();
> + test_cat<SO, SO, SO>();
> + }
> +}
>
> Added: libcxx/trunk/test/std/language.support/cmp/cmp.
> partialord/partialord.pass.cpp
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/
> language.support/cmp/cmp.partialord/partialord.pass.
> cpp?rev=329460&view=auto
> ============================================================
> ==================
> --- libcxx/trunk/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
> (added)
> +++ libcxx/trunk/test/std/language.support/cmp/cmp.partialord/partialord.pass.cpp
> Fri Apr 6 14:37:23 2018
> @@ -0,0 +1,164 @@
> +//===------------------------------------------------------
> ----------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===------------------------------------------------------
> ----------------===//
> +
> +// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
> +
> +// <compare>
> +
> +// class partial_ordering
> +
> +
> +#include <compare>
> +#include <type_traits>
> +#include <cassert>
> +
> +#include "test_macros.h"
> +
> +const volatile void* volatile sink;
> +
> +void test_static_members() {
> + DoNotOptimize(&std::partial_ordering::less);
> + DoNotOptimize(&std::partial_ordering::equivalent);
> + DoNotOptimize(&std::partial_ordering::greater);
> + DoNotOptimize(&std::partial_ordering::unordered);
> +}
> +
> +void test_signatures() {
> + auto& Eq = std::partial_ordering::equivalent;
> +
> + ASSERT_NOEXCEPT(Eq == 0);
> + ASSERT_NOEXCEPT(0 == Eq);
> + ASSERT_NOEXCEPT(Eq != 0);
> + ASSERT_NOEXCEPT(0 != Eq);
> + ASSERT_NOEXCEPT(0 < Eq);
> + ASSERT_NOEXCEPT(Eq < 0);
> + ASSERT_NOEXCEPT(0 <= Eq);
> + ASSERT_NOEXCEPT(Eq <= 0);
> + ASSERT_NOEXCEPT(0 > Eq);
> + ASSERT_NOEXCEPT(Eq > 0);
> + ASSERT_NOEXCEPT(0 >= Eq);
> + ASSERT_NOEXCEPT(Eq >= 0);
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + ASSERT_NOEXCEPT(0 <=> Eq);
> + ASSERT_NOEXCEPT(Eq <=> 0);
> + ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::partial_ordering);
> + ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::partial_ordering);
> +#endif
> +}
> +
> +constexpr bool test_conversion() {
> + static_assert(std::is_convertible<const std::partial_ordering,
> std::weak_equality>::value, "");
> + { // value == 0
> + auto V = std::partial_ordering::equivalent;
> + std::weak_equality WV = V;
> + assert(WV == 0);
> + }
> + std::partial_ordering TestCases[] = {
> + std::partial_ordering::less,
> + std::partial_ordering::greater,
> + std::partial_ordering::unordered
> + };
> + for (auto V : TestCases)
> + { // value != 0
> + std::weak_equality WV = V;
> + assert(WV != 0);
> + }
> + return true;
> +}
> +
> +constexpr bool test_constexpr() {
> + auto& Eq = std::partial_ordering::equivalent;
> + auto& Less = std::partial_ordering::less;
> + auto& Greater = std::partial_ordering::greater;
> + auto& Unord = std::partial_ordering::unordered;
> + struct {
> + std::partial_ordering Value;
> + bool ExpectEq;
> + bool ExpectNeq;
> + bool ExpectLess;
> + bool ExpectGreater;
> + } TestCases[] = {
> + {Eq, true, false, false, false},
> + {Less, false, true, true, false},
> + {Greater, false, true, false, true},
> + {Unord, false, true, false, false}
> + };
> + for (auto TC : TestCases) {
> + auto V = TC.Value;
> + assert((V == 0) == TC.ExpectEq);
> + assert((0 == V) == TC.ExpectEq);
> + assert((V != 0) == TC.ExpectNeq);
> + assert((0 != V) == TC.ExpectNeq);
> +
> + assert((V < 0) == TC.ExpectLess);
> + assert((V > 0) == TC.ExpectGreater);
> + assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
> + assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
> +
> + assert((0 < V) == TC.ExpectGreater);
> + assert((0 > V) == TC.ExpectLess);
> + assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
> + assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
> + }
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + {
> + std::partial_ordering res = (Eq <=> 0);
> + ((void)res);
> + res = (0 <=> Eq);
> + ((void)res);
> + }
> + enum ExpectRes {
> + ER_Greater,
> + ER_Less,
> + ER_Equiv,
> + ER_Unord
> + };
> + struct {
> + std::partial_ordering Value;
> + ExpectRes Expect;
> + } SpaceshipTestCases[] = {
> + {std::partial_ordering::equivalent, ER_Equiv},
> + {std::partial_ordering::less, ER_Less},
> + {std::partial_ordering::greater, ER_Greater},
> + {std::partial_ordering::unordered, ER_Unord}
> + };
> + for (auto TC : SpaceshipTestCases)
> + {
> + std::partial_ordering Res = (0 <=> TC.Value);
> + switch (TC.Expect) {
> + case ER_Equiv:
> + assert(Res == 0);
> + assert(0 == Res);
> + break;
> + case ER_Less:
> + assert(Res < 0);
> + break;
> + case ER_Greater:
> + assert(Res > 0);
> + break;
> + case ER_Unord:
> + assert(Res != 0);
> + assert(0 != Res);
> + assert((Res < 0) == false);
> + assert((Res > 0) == false);
> + assert((Res == 0) == false);
> + break;
> + }
> + }
> +#endif
> +
> + return true;
> +}
> +
> +int main() {
> + test_static_members();
> + test_signatures();
> + static_assert(test_conversion(), "conversion test failed");
> + static_assert(test_constexpr(), "constexpr test failed");
> +}
>
> Added: libcxx/trunk/test/std/language.support/cmp/cmp.
> strongeq/cmp.strongeq.pass.cpp
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/
> language.support/cmp/cmp.strongeq/cmp.strongeq.pass.
> cpp?rev=329460&view=auto
> ============================================================
> ==================
> --- libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
> (added)
> +++ libcxx/trunk/test/std/language.support/cmp/cmp.strongeq/cmp.strongeq.pass.cpp
> Fri Apr 6 14:37:23 2018
> @@ -0,0 +1,96 @@
> +//===------------------------------------------------------
> ----------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===------------------------------------------------------
> ----------------===//
> +
> +// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
> +
> +// <compare>
> +
> +// class strong_equality
> +
> +
> +#include <compare>
> +#include <type_traits>
> +#include <cassert>
> +
> +#include "test_macros.h"
> +
> +const volatile void* volatile sink;
> +
> +void test_static_members() {
> + DoNotOptimize(&std::strong_equality::equal);
> + DoNotOptimize(&std::strong_equality::nonequal);
> + DoNotOptimize(&std::strong_equality::equivalent);
> + DoNotOptimize(&std::strong_equality::nonequivalent);
> +}
> +
> +void test_signatures() {
> + auto& Eq = std::strong_equality::equivalent;
> +
> + ASSERT_NOEXCEPT(Eq == 0);
> + ASSERT_NOEXCEPT(0 == Eq);
> + ASSERT_NOEXCEPT(Eq != 0);
> + ASSERT_NOEXCEPT(0 != Eq);
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + ASSERT_NOEXCEPT(0 <=> Eq);
> + ASSERT_NOEXCEPT(Eq <=> 0);
> + ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::strong_equality);
> + ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::strong_equality);
> +#endif
> +}
> +
> +void test_conversion() {
> + constexpr std::weak_equality res = std::strong_equality::equivalent;
> + static_assert(res == 0, "");
> + static_assert(std::is_convertible<const std::strong_equality&,
> + std::weak_equality>::value, "");
> + static_assert(res == 0, "expected equal");
> +
> + constexpr std::weak_equality neq_res = std::strong_equality::
> nonequivalent;
> + static_assert(neq_res != 0, "expected not equal");
> +}
> +
> +constexpr bool test_constexpr() {
> + auto& Eq = std::strong_equality::equal;
> + auto& NEq = std::strong_equality::nonequal;
> + auto& Equiv = std::strong_equality::equivalent;
> + auto& NEquiv = std::strong_equality::nonequivalent;
> + assert((Eq == 0) == true);
> + assert((0 == Eq) == true);
> + assert((Equiv == 0) == true);
> + assert((0 == Equiv) == true);
> + assert((NEq == 0) == false);
> + assert((0 == NEq) == false);
> + assert((NEquiv == 0) == false);
> + assert((0 == NEquiv) == false);
> +
> + assert((Eq != 0) == false);
> + assert((0 != Eq) == false);
> + assert((Equiv != 0) == false);
> + assert((0 != Equiv) == false);
> + assert((NEq != 0) == true);
> + assert((0 != NEq) == true);
> + assert((NEquiv != 0) == true);
> + assert((0 != NEquiv) == true);
> +
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + std::strong_equality res = (Eq <=> 0);
> + ((void)res);
> + res = (0 <=> Eq);
> + ((void)res);
> +#endif
> +
> + return true;
> +}
> +
> +int main() {
> + test_static_members();
> + test_signatures();
> + test_conversion();
> + static_assert(test_constexpr(), "constexpr test failed");
> +}
>
> Added: libcxx/trunk/test/std/language.support/cmp/cmp.
> strongord/strongord.pass.cpp
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/
> language.support/cmp/cmp.strongord/strongord.pass.cpp?rev=329460&view=auto
> ============================================================
> ==================
> --- libcxx/trunk/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
> (added)
> +++ libcxx/trunk/test/std/language.support/cmp/cmp.strongord/strongord.pass.cpp
> Fri Apr 6 14:37:23 2018
> @@ -0,0 +1,212 @@
> +//===------------------------------------------------------
> ----------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===------------------------------------------------------
> ----------------===//
> +
> +// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
> +
> +// <compare>
> +
> +// class strong_ordering
> +
> +
> +#include <compare>
> +#include <type_traits>
> +#include <cassert>
> +
> +#include "test_macros.h"
> +
> +const volatile void* volatile sink;
> +
> +void test_static_members() {
> + DoNotOptimize(&std::strong_ordering::less);
> + DoNotOptimize(&std::strong_ordering::equal);
> + DoNotOptimize(&std::strong_ordering::equivalent);
> + DoNotOptimize(&std::strong_ordering::greater);
> +}
> +
> +void test_signatures() {
> + auto& Eq = std::strong_ordering::equivalent;
> +
> + ASSERT_NOEXCEPT(Eq == 0);
> + ASSERT_NOEXCEPT(0 == Eq);
> + ASSERT_NOEXCEPT(Eq != 0);
> + ASSERT_NOEXCEPT(0 != Eq);
> + ASSERT_NOEXCEPT(0 < Eq);
> + ASSERT_NOEXCEPT(Eq < 0);
> + ASSERT_NOEXCEPT(0 <= Eq);
> + ASSERT_NOEXCEPT(Eq <= 0);
> + ASSERT_NOEXCEPT(0 > Eq);
> + ASSERT_NOEXCEPT(Eq > 0);
> + ASSERT_NOEXCEPT(0 >= Eq);
> + ASSERT_NOEXCEPT(Eq >= 0);
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + ASSERT_NOEXCEPT(0 <=> Eq);
> + ASSERT_NOEXCEPT(Eq <=> 0);
> + ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::strong_ordering);
> + ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::strong_ordering);
> +#endif
> +}
> +
> +constexpr bool test_conversion() {
> + static_assert(std::is_convertible<const std::strong_ordering&,
> + std::weak_equality>::value, "");
> + { // value == 0
> + auto V = std::strong_ordering::equivalent;
> + std::weak_equality WV = V;
> + assert(WV == 0);
> + }
> + std::strong_ordering WeakTestCases[] = {
> + std::strong_ordering::less,
> + std::strong_ordering::greater,
> + };
> + for (auto V : WeakTestCases)
> + { // value != 0
> + std::weak_equality WV = V;
> + assert(WV != 0);
> + }
> + static_assert(std::is_convertible<const std::strong_ordering&,
> + std::strong_equality>::value, "");
> + { // value == 0
> + auto V = std::strong_ordering::equivalent;
> + std::strong_equality WV = V;
> + assert(WV == 0);
> + }
> + { // value == 0
> + auto V = std::strong_ordering::equal;
> + std::strong_equality WV = V;
> + assert(WV == 0);
> + }
> + std::strong_ordering StrongTestCases[] = {
> + std::strong_ordering::less,
> + std::strong_ordering::greater,
> + };
> + for (auto V : StrongTestCases)
> + { // value != 0
> + std::strong_equality WV = V;
> + assert(WV != 0);
> + }
> +
> + static_assert(std::is_convertible<const std::strong_ordering&,
> + std::partial_ordering>::value, "");
> + { // value == 0
> + auto V = std::strong_ordering::equivalent;
> + std::partial_ordering WV = V;
> + assert(WV == 0);
> + }
> + { // value < 0
> + auto V = std::strong_ordering::less;
> + std::partial_ordering WV = V;
> + assert(WV < 0);
> + }
> + { // value > 0
> + auto V = std::strong_ordering::greater;
> + std::partial_ordering WV = V;
> + assert(WV > 0);
> + }
> +
> + static_assert(std::is_convertible<const std::strong_ordering&,
> + std::weak_ordering>::value, "");
> + { // value == 0
> + auto V = std::strong_ordering::equivalent;
> + std::weak_ordering WV = V;
> + assert(WV == 0);
> + }
> + { // value < 0
> + auto V = std::strong_ordering::less;
> + std::weak_ordering WV = V;
> + assert(WV < 0);
> + }
> + { // value > 0
> + auto V = std::strong_ordering::greater;
> + std::weak_ordering WV = V;
> + assert(WV > 0);
> + }
> + return true;
> +}
> +
> +constexpr bool test_constexpr() {
> + auto& Eq = std::strong_ordering::equal;
> + auto& Equiv = std::strong_ordering::equivalent;
> + auto& Less = std::strong_ordering::less;
> + auto& Greater = std::strong_ordering::greater;
> + struct {
> + std::strong_ordering Value;
> + bool ExpectEq;
> + bool ExpectNeq;
> + bool ExpectLess;
> + bool ExpectGreater;
> + } TestCases[] = {
> + {Eq, true, false, false, false},
> + {Equiv, true, false, false, false},
> + {Less, false, true, true, false},
> + {Greater, false, true, false, true},
> + };
> + for (auto TC : TestCases) {
> + auto V = TC.Value;
> + assert((V == 0) == TC.ExpectEq);
> + assert((0 == V) == TC.ExpectEq);
> + assert((V != 0) == TC.ExpectNeq);
> + assert((0 != V) == TC.ExpectNeq);
> +
> + assert((V < 0) == TC.ExpectLess);
> + assert((V > 0) == TC.ExpectGreater);
> + assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
> + assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
> +
> + assert((0 < V) == TC.ExpectGreater);
> + assert((0 > V) == TC.ExpectLess);
> + assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
> + assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
> + }
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + {
> + std::strong_ordering res = (Eq <=> 0);
> + ((void)res);
> + res = (0 <=> Eq);
> + ((void)res);
> + }
> + enum ExpectRes {
> + ER_Greater,
> + ER_Less,
> + ER_Equiv
> + };
> + struct {
> + std::strong_ordering Value;
> + ExpectRes Expect;
> + } SpaceshipTestCases[] = {
> + {std::strong_ordering::equivalent, ER_Equiv},
> + {std::strong_ordering::less, ER_Less},
> + {std::strong_ordering::greater, ER_Greater},
> + };
> + for (auto TC : SpaceshipTestCases)
> + {
> + std::strong_ordering Res = (0 <=> TC.Value);
> + switch (TC.Expect) {
> + case ER_Equiv:
> + assert(Res == 0);
> + assert(0 == Res);
> + break;
> + case ER_Less:
> + assert(Res < 0);
> + break;
> + case ER_Greater:
> + assert(Res > 0);
> + break;
> + }
> + }
> +#endif
> +
> + return true;
> +}
> +
> +int main() {
> + test_static_members();
> + test_signatures();
> + static_assert(test_conversion(), "conversion test failed");
> + static_assert(test_constexpr(), "constexpr test failed");
> +}
>
> Added: libcxx/trunk/test/std/language.support/cmp/cmp.
> weakeq/cmp.weakeq.pass.cpp
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/
> language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp?rev=329460&view=auto
> ============================================================
> ==================
> --- libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
> (added)
> +++ libcxx/trunk/test/std/language.support/cmp/cmp.weakeq/cmp.weakeq.pass.cpp
> Fri Apr 6 14:37:23 2018
> @@ -0,0 +1,70 @@
> +//===------------------------------------------------------
> ----------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===------------------------------------------------------
> ----------------===//
> +
> +// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
> +
> +// <compare>
> +
> +// class weak_equality
> +
> +
> +#include <compare>
> +#include <cassert>
> +#include "test_macros.h"
> +
> +const volatile void* volatile sink;
> +
> +void test_static_members() {
> + DoNotOptimize(&std::weak_equality::equivalent);
> + DoNotOptimize(&std::weak_equality::nonequivalent);
> +}
> +
> +void test_signatures() {
> + auto& Eq = std::weak_equality::equivalent;
> +
> + ASSERT_NOEXCEPT(Eq == 0);
> + ASSERT_NOEXCEPT(0 == Eq);
> + ASSERT_NOEXCEPT(Eq != 0);
> + ASSERT_NOEXCEPT(0 != Eq);
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + ASSERT_NOEXCEPT(0 <=> Eq);
> + ASSERT_NOEXCEPT(Eq <=> 0);
> + ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::weak_equality);
> + ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::weak_equality);
> +#endif
> +}
> +
> +constexpr bool test_constexpr() {
> + auto& Eq = std::weak_equality::equivalent;
> + auto& NEq = std::weak_equality::nonequivalent;
> + assert((Eq == 0) == true);
> + assert((0 == Eq) == true);
> + assert((NEq == 0) == false);
> + assert((0 == NEq) == false);
> +
> + assert((Eq != 0) == false);
> + assert((0 != Eq) == false);
> + assert((NEq != 0) == true);
> + assert((0 != NEq) == true);
> +
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + std::weak_equality res = (Eq <=> 0);
> + ((void)res);
> + res = (0 <=> Eq);
> + ((void)res);
> +#endif
> +
> + return true;
> +}
> +
> +int main() {
> + test_static_members();
> + test_signatures();
> + static_assert(test_constexpr(), "constexpr test failed");
> +}
>
> Added: libcxx/trunk/test/std/language.support/cmp/cmp.
> weakord/weakord.pass.cpp
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/
> language.support/cmp/cmp.weakord/weakord.pass.cpp?rev=329460&view=auto
> ============================================================
> ==================
> --- libcxx/trunk/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
> (added)
> +++ libcxx/trunk/test/std/language.support/cmp/cmp.weakord/weakord.pass.cpp
> Fri Apr 6 14:37:23 2018
> @@ -0,0 +1,169 @@
> +//===------------------------------------------------------
> ----------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is dual licensed under the MIT and the University of
> Illinois Open
> +// Source Licenses. See LICENSE.TXT for details.
> +//
> +//===------------------------------------------------------
> ----------------===//
> +
> +// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
> +
> +// <compare>
> +
> +// class weak_ordering
> +
> +
> +#include <compare>
> +#include <type_traits>
> +#include <cassert>
> +
> +#include "test_macros.h"
> +
> +const volatile void* volatile sink;
> +
> +void test_static_members() {
> + DoNotOptimize(&std::weak_ordering::less);
> + DoNotOptimize(&std::weak_ordering::equivalent);
> + DoNotOptimize(&std::weak_ordering::greater);
> +}
> +
> +void test_signatures() {
> + auto& Eq = std::weak_ordering::equivalent;
> +
> + ASSERT_NOEXCEPT(Eq == 0);
> + ASSERT_NOEXCEPT(0 == Eq);
> + ASSERT_NOEXCEPT(Eq != 0);
> + ASSERT_NOEXCEPT(0 != Eq);
> + ASSERT_NOEXCEPT(0 < Eq);
> + ASSERT_NOEXCEPT(Eq < 0);
> + ASSERT_NOEXCEPT(0 <= Eq);
> + ASSERT_NOEXCEPT(Eq <= 0);
> + ASSERT_NOEXCEPT(0 > Eq);
> + ASSERT_NOEXCEPT(Eq > 0);
> + ASSERT_NOEXCEPT(0 >= Eq);
> + ASSERT_NOEXCEPT(Eq >= 0);
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + ASSERT_NOEXCEPT(0 <=> Eq);
> + ASSERT_NOEXCEPT(Eq <=> 0);
> + ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::weak_ordering);
> + ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::weak_ordering);
> +#endif
> +}
> +
> +constexpr bool test_conversion() {
> + static_assert(std::is_convertible<const std::weak_ordering&,
> + std::weak_equality>::value, "");
> + { // value == 0
> + auto V = std::weak_ordering::equivalent;
> + std::weak_equality WV = V;
> + assert(WV == 0);
> + }
> + std::weak_ordering WeakTestCases[] = {
> + std::weak_ordering::less,
> + std::weak_ordering::greater,
> + };
> + for (auto V : WeakTestCases)
> + { // value != 0
> + std::weak_equality WV = V;
> + assert(WV != 0);
> + }
> + static_assert(std::is_convertible<const std::weak_ordering&,
> + std::partial_ordering>::value, "");
> + { // value == 0
> + auto V = std::weak_ordering::equivalent;
> + std::partial_ordering WV = V;
> + assert(WV == 0);
> + }
> + { // value < 0
> + auto V = std::weak_ordering::less;
> + std::partial_ordering WV = V;
> + assert(WV < 0);
> + }
> + { // value > 0
> + auto V = std::weak_ordering::greater;
> + std::partial_ordering WV = V;
> + assert(WV > 0);
> + }
> + return true;
> +}
> +
> +constexpr bool test_constexpr() {
> + auto& Eq = std::weak_ordering::equivalent;
> + auto& Less = std::weak_ordering::less;
> + auto& Greater = std::weak_ordering::greater;
> + struct {
> + std::weak_ordering Value;
> + bool ExpectEq;
> + bool ExpectNeq;
> + bool ExpectLess;
> + bool ExpectGreater;
> + } TestCases[] = {
> + {Eq, true, false, false, false},
> + {Less, false, true, true, false},
> + {Greater, false, true, false, true},
> + };
> + for (auto TC : TestCases) {
> + auto V = TC.Value;
> + assert((V == 0) == TC.ExpectEq);
> + assert((0 == V) == TC.ExpectEq);
> + assert((V != 0) == TC.ExpectNeq);
> + assert((0 != V) == TC.ExpectNeq);
> +
> + assert((V < 0) == TC.ExpectLess);
> + assert((V > 0) == TC.ExpectGreater);
> + assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
> + assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
> +
> + assert((0 < V) == TC.ExpectGreater);
> + assert((0 > V) == TC.ExpectLess);
> + assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
> + assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
> + }
> +#ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
> + {
> + std::weak_ordering res = (Eq <=> 0);
> + ((void)res);
> + res = (0 <=> Eq);
> + ((void)res);
> + }
> + enum ExpectRes {
> + ER_Greater,
> + ER_Less,
> + ER_Equiv
> + };
> + struct {
> + std::weak_ordering Value;
> + ExpectRes Expect;
> + } SpaceshipTestCases[] = {
> + {std::weak_ordering::equivalent, ER_Equiv},
> + {std::weak_ordering::less, ER_Less},
> + {std::weak_ordering::greater, ER_Greater},
> + };
> + for (auto TC : SpaceshipTestCases)
> + {
> + std::weak_ordering Res = (0 <=> TC.Value);
> + switch (TC.Expect) {
> + case ER_Equiv:
> + assert(Res == 0);
> + assert(0 == Res);
> + break;
> + case ER_Less:
> + assert(Res < 0);
> + break;
> + case ER_Greater:
> + assert(Res > 0);
> + break;
> + }
> + }
> +#endif
> +
> + return true;
> +}
> +
> +int main() {
> + test_static_members();
> + test_signatures();
> + static_assert(test_conversion(), "conversion test failed");
> + static_assert(test_constexpr(), "constexpr test failed");
> +}
>
> Modified: libcxx/trunk/test/support/test_macros.h
> URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/
> support/test_macros.h?rev=329460&r1=329459&r2=329460&view=diff
> ============================================================
> ==================
> --- libcxx/trunk/test/support/test_macros.h (original)
> +++ libcxx/trunk/test/support/test_macros.h Fri Apr 6 14:37:23 2018
> @@ -169,6 +169,11 @@
> #define TEST_SAFE_STATIC
> #endif
>
> +// FIXME: Fix this feature check when either (A) a compiler provides a
> complete
> +// implementation, or (b) a feature check macro is specified
> +#define TEST_HAS_NO_SPACESHIP_OPERATOR
> +
> +
> #if TEST_STD_VER < 11
> #define ASSERT_NOEXCEPT(...)
> #define ASSERT_NOT_NOEXCEPT(...)
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20180406/6db52392/attachment-0001.html>
More information about the cfe-commits
mailing list