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 | // template<class T> |
12 | // concept totally_ordered; |
13 | |
14 | #include <concepts> |
15 | |
16 | #include <array> |
17 | #include <cstddef> |
18 | #include <deque> |
19 | #include <forward_list> |
20 | #include <list> |
21 | #include <optional> |
22 | #include <set> |
23 | #include <unordered_map> |
24 | #include <unordered_set> |
25 | #include <vector> |
26 | |
27 | #include "compare_types.h" |
28 | #include "test_macros.h" |
29 | |
30 | // `models_totally_ordered` checks that `std::totally_ordered` subsumes |
31 | // `std::equality_comparable`. This overload should *never* be called. |
32 | template <std::equality_comparable T> |
33 | constexpr bool models_totally_ordered() noexcept { |
34 | return false; |
35 | } |
36 | |
37 | template <std::totally_ordered T> |
38 | constexpr bool models_totally_ordered() noexcept { |
39 | return true; |
40 | } |
41 | |
42 | namespace fundamentals { |
43 | static_assert(models_totally_ordered<int>()); |
44 | static_assert(models_totally_ordered<double>()); |
45 | static_assert(models_totally_ordered<void*>()); |
46 | static_assert(models_totally_ordered<char*>()); |
47 | static_assert(models_totally_ordered<char const*>()); |
48 | static_assert(models_totally_ordered<char volatile*>()); |
49 | static_assert(models_totally_ordered<char const volatile*>()); |
50 | static_assert(models_totally_ordered<wchar_t&>()); |
51 | static_assert(models_totally_ordered<char8_t const&>()); |
52 | static_assert(models_totally_ordered<char16_t volatile&>()); |
53 | static_assert(models_totally_ordered<char32_t const volatile&>()); |
54 | static_assert(models_totally_ordered<unsigned char&&>()); |
55 | static_assert(models_totally_ordered<unsigned short const&&>()); |
56 | static_assert(models_totally_ordered<unsigned int volatile&&>()); |
57 | static_assert(models_totally_ordered<unsigned long const volatile&&>()); |
58 | // Array comparisons are ill-formed in C++26 |
59 | #if TEST_STD_VER <= 23 |
60 | static_assert(models_totally_ordered<int[5]>()); |
61 | #endif |
62 | static_assert(models_totally_ordered<int (*)(int)>()); |
63 | static_assert(models_totally_ordered<int (&)(int)>()); |
64 | static_assert(models_totally_ordered<int (*)(int) noexcept>()); |
65 | static_assert(models_totally_ordered<int (&)(int) noexcept>()); |
66 | |
67 | #ifndef TEST_COMPILER_GCC |
68 | static_assert(!std::totally_ordered<std::nullptr_t>); |
69 | #endif |
70 | |
71 | struct S {}; |
72 | static_assert(!std::totally_ordered<S>); |
73 | static_assert(!std::totally_ordered<int S::*>); |
74 | static_assert(!std::totally_ordered<int (S::*)()>); |
75 | static_assert(!std::totally_ordered<int (S::*)() noexcept>); |
76 | static_assert(!std::totally_ordered<int (S::*)() &>); |
77 | static_assert(!std::totally_ordered<int (S::*)() & noexcept>); |
78 | static_assert(!std::totally_ordered<int (S::*)() &&>); |
79 | static_assert(!std::totally_ordered < int(S::*)() && noexcept >); |
80 | static_assert(!std::totally_ordered<int (S::*)() const>); |
81 | static_assert(!std::totally_ordered<int (S::*)() const noexcept>); |
82 | static_assert(!std::totally_ordered<int (S::*)() const&>); |
83 | static_assert(!std::totally_ordered<int (S::*)() const & noexcept>); |
84 | static_assert(!std::totally_ordered<int (S::*)() const&&>); |
85 | static_assert(!std::totally_ordered < int(S::*)() const&& noexcept >); |
86 | static_assert(!std::totally_ordered<int (S::*)() volatile>); |
87 | static_assert(!std::totally_ordered<int (S::*)() volatile noexcept>); |
88 | static_assert(!std::totally_ordered<int (S::*)() volatile&>); |
89 | static_assert(!std::totally_ordered<int (S::*)() volatile & noexcept>); |
90 | static_assert(!std::totally_ordered<int (S::*)() volatile&&>); |
91 | static_assert(!std::totally_ordered < int(S::*)() volatile && noexcept >); |
92 | static_assert(!std::totally_ordered<int (S::*)() const volatile>); |
93 | static_assert(!std::totally_ordered<int (S::*)() const volatile noexcept>); |
94 | static_assert(!std::totally_ordered<int (S::*)() const volatile&>); |
95 | static_assert(!std::totally_ordered<int (S::*)() const volatile & noexcept>); |
96 | static_assert(!std::totally_ordered<int (S::*)() const volatile&&>); |
97 | static_assert(!std::totally_ordered < int(S::*)() const volatile&& noexcept >); |
98 | |
99 | static_assert(!std::totally_ordered<void>); |
100 | } // namespace fundamentals |
101 | |
102 | namespace standard_types { |
103 | static_assert(models_totally_ordered<std::array<int, 10> >()); |
104 | static_assert(models_totally_ordered<std::deque<int> >()); |
105 | static_assert(models_totally_ordered<std::forward_list<int> >()); |
106 | static_assert(models_totally_ordered<std::list<int> >()); |
107 | static_assert(models_totally_ordered<std::optional<int> >()); |
108 | static_assert(models_totally_ordered<std::set<int> >()); |
109 | static_assert(models_totally_ordered<std::vector<bool> >()); |
110 | static_assert(models_totally_ordered<std::vector<int> >()); |
111 | |
112 | static_assert(!std::totally_ordered<std::unordered_map<int, void*> >); |
113 | static_assert(!std::totally_ordered<std::unordered_set<int> >); |
114 | |
115 | struct A {}; |
116 | static_assert(!std::totally_ordered<std::array<A, 10> >); |
117 | static_assert(!std::totally_ordered<std::deque<A> >); |
118 | static_assert(!std::totally_ordered<std::forward_list<A> >); |
119 | static_assert(!std::totally_ordered<std::list<A> >); |
120 | static_assert(!std::totally_ordered<std::set<A> >); |
121 | static_assert(!std::totally_ordered<std::vector<A> >); |
122 | } // namespace standard_types |
123 | |
124 | namespace types_fit_for_purpose { |
125 | static_assert(models_totally_ordered<member_three_way_comparable>()); |
126 | static_assert(models_totally_ordered<friend_three_way_comparable>()); |
127 | static_assert(models_totally_ordered<explicit_operators>()); |
128 | static_assert(models_totally_ordered<different_return_types>()); |
129 | static_assert(!std::totally_ordered<cxx20_member_eq>); |
130 | static_assert(!std::totally_ordered<cxx20_friend_eq>); |
131 | static_assert(!std::totally_ordered<one_member_one_friend>); |
132 | static_assert(!std::totally_ordered<equality_comparable_with_ec1>); |
133 | |
134 | static_assert(!std::totally_ordered<no_eq>); |
135 | static_assert(!std::totally_ordered<no_neq>); |
136 | static_assert(!std::totally_ordered<no_lt>); |
137 | static_assert(!std::totally_ordered<no_gt>); |
138 | static_assert(!std::totally_ordered<no_le>); |
139 | static_assert(!std::totally_ordered<no_ge>); |
140 | |
141 | static_assert(!std::totally_ordered<wrong_return_type_eq>); |
142 | static_assert(!std::totally_ordered<wrong_return_type_ne>); |
143 | static_assert(!std::totally_ordered<wrong_return_type_lt>); |
144 | static_assert(!std::totally_ordered<wrong_return_type_gt>); |
145 | static_assert(!std::totally_ordered<wrong_return_type_le>); |
146 | static_assert(!std::totally_ordered<wrong_return_type_ge>); |
147 | static_assert(!std::totally_ordered<wrong_return_type>); |
148 | |
149 | static_assert(!std::totally_ordered<cxx20_member_eq_operator_with_deleted_ne>); |
150 | static_assert(!std::totally_ordered<cxx20_friend_eq_operator_with_deleted_ne>); |
151 | static_assert(!std::totally_ordered<member_three_way_comparable_with_deleted_eq>); |
152 | static_assert(!std::totally_ordered<member_three_way_comparable_with_deleted_ne>); |
153 | static_assert(!std::totally_ordered<friend_three_way_comparable_with_deleted_eq>); |
154 | static_assert(!std::totally_ordered<friend_three_way_comparable_with_deleted_ne>); |
155 | |
156 | static_assert(!std::totally_ordered<eq_returns_explicit_bool>); |
157 | static_assert(!std::totally_ordered<ne_returns_explicit_bool>); |
158 | static_assert(!std::totally_ordered<lt_returns_explicit_bool>); |
159 | static_assert(!std::totally_ordered<gt_returns_explicit_bool>); |
160 | static_assert(!std::totally_ordered<le_returns_explicit_bool>); |
161 | static_assert(!std::totally_ordered<ge_returns_explicit_bool>); |
162 | static_assert(std::totally_ordered<returns_true_type>); |
163 | static_assert(std::totally_ordered<returns_int_ptr>); |
164 | |
165 | static_assert(std::totally_ordered<partial_ordering_totally_ordered_with>); |
166 | static_assert(std::totally_ordered<weak_ordering_totally_ordered_with>); |
167 | static_assert(std::totally_ordered<strong_ordering_totally_ordered_with>); |
168 | } // namespace types_fit_for_purpose |
169 | |