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

source code of libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.compile.pass.cpp