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 I2, sentinel_for<I> S2>
12// requires sentinel_for<S, I2>
13// friend bool operator==(
14// const common_iterator& x, const common_iterator<I2, S2>& y);
15// template<class I2, sentinel_for<I> S2>
16// requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
17// friend bool operator==(
18// const common_iterator& x, const common_iterator<I2, S2>& y);
19
20#include <iterator>
21#include <cassert>
22
23#include "test_macros.h"
24#include "types.h"
25
26void test() {
27 int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
28
29 {
30 auto iter1 = simple_iterator<int*>(buffer);
31 auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
32 auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
33
34 const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
35 const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
36
37 assert(commonIter1 != commonSent1);
38 assert(commonIter2 != commonSent2);
39 assert(commonSent1 != commonIter1);
40 assert(commonSent2 != commonIter2);
41
42 for (auto i = 1; commonIter1 != commonSent1; ++i) {
43 assert(*(commonIter1++) == i);
44 }
45 assert(commonIter1 == commonSent1);
46 assert(commonSent1 == commonIter1);
47 }
48 {
49 auto iter1 = value_iterator<int*>(buffer);
50 auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
51 auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
52
53 const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
54 const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
55
56 assert(commonIter1 != commonSent1);
57 assert(commonIter2 != commonSent2);
58 assert(commonSent1 != commonIter1);
59 assert(commonSent2 != commonIter2);
60
61 for (auto i = 1; commonIter1 != commonSent1; ++i) {
62 assert(*(commonIter1++) == i);
63 }
64 assert(commonIter1 == commonSent1);
65 assert(commonSent1 == commonIter1);
66 }
67 {
68 auto iter1 = simple_iterator<int*>(buffer);
69 auto iter2 = comparable_iterator<int*>(buffer);
70 auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
71 auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
72
73 const auto commonIter2 = std::common_iterator<decltype(iter2), sentinel_type<int*>>(iter2);
74 const auto commonSent2 = std::common_iterator<decltype(iter2), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
75
76 assert(commonIter1 == commonIter2);
77 assert(commonSent1 != commonIter2);
78 assert(commonSent1 == commonSent2);
79 assert(commonSent2 == commonSent1);
80
81 assert(commonIter1 != commonSent1);
82 assert(commonIter2 != commonSent2);
83 assert(commonSent1 != commonIter1);
84 assert(commonSent2 != commonIter2);
85
86 assert(commonIter1 == commonIter2);
87 assert(commonIter2 == commonIter1);
88
89 for (auto i = 1; commonIter1 != commonSent1; ++i) {
90 assert(*(commonIter1++) == i);
91 }
92 assert(commonIter1 == commonSent1);
93 assert(commonSent1 == commonIter1);
94
95 // This check may *seem* incorrect (our iterators point to two completely different
96 // elements of buffer). However, this is actually what the Standard wants.
97 // See https://eel.is/c++draft/iterators.common#common.iter.cmp-2.
98 assert(commonIter1 == commonIter2);
99 }
100 {
101 auto iter1 = cpp17_input_iterator<int*>(buffer);
102 auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
103 auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
104
105 const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
106 const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
107
108 assert(commonIter1 != commonSent1);
109 assert(commonIter2 != commonSent2);
110 assert(commonSent1 != commonIter1);
111 assert(commonSent2 != commonIter2);
112
113 for (auto i = 1; commonIter1 != commonSent1; ++i) {
114 assert(*(commonIter1++) == i);
115 }
116 assert(commonIter1 == commonSent1);
117 assert(commonSent1 == commonIter1);
118 }
119 {
120 auto iter1 = forward_iterator<int*>(buffer);
121 auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
122 auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
123
124 const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
125 const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
126
127 assert(commonIter1 != commonSent1);
128 assert(commonIter2 != commonSent2);
129 assert(commonSent1 != commonIter1);
130 assert(commonSent2 != commonIter2);
131
132 for (auto i = 1; commonIter1 != commonSent1; ++i) {
133 assert(*(commonIter1++) == i);
134 }
135 assert(commonIter1 == commonSent1);
136 assert(commonSent1 == commonIter1);
137 }
138 {
139 auto iter1 = random_access_iterator<int*>(buffer);
140 auto commonIter1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
141 auto commonSent1 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
142
143 const auto commonIter2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(iter1);
144 const auto commonSent2 = std::common_iterator<decltype(iter1), sentinel_type<int*>>(sentinel_type<int*>{buffer + 8});
145
146 assert(commonIter1 != commonSent1);
147 assert(commonIter2 != commonSent2);
148 assert(commonSent1 != commonIter1);
149 assert(commonSent2 != commonIter2);
150
151 assert(commonSent1 == commonSent2);
152 assert(commonSent2 == commonSent1);
153
154 for (auto i = 1; commonIter1 != commonSent1; ++i) {
155 assert(*(commonIter1++) == i);
156 }
157 assert(commonIter1 == commonSent1);
158 assert(commonSent1 == commonIter1);
159 }
160}
161
162int main(int, char**) {
163 test();
164
165 return 0;
166}
167

source code of libcxx/test/std/iterators/predef.iterators/iterators.common/eq.pass.cpp