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 // UNSUPPORTED: libcpp-has-no-incomplete-ranges 11 12 // template <input_iterator I1, sentinel_for<_I1> S1, input_iterator I2, sentinel_for<_I2> S2, 13 // class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 14 // requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2> 15 // constexpr mismatch_result<_I1, _I2> 16 // ranges::mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) 17 18 // template <input_range R1, input_range R2, 19 // class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> 20 // requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2> 21 // constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>> 22 // ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) 23 24 #include <algorithm> 25 #include <array> 26 #include <cassert> 27 #include <functional> 28 #include <ranges> 29 30 #include "test_iterators.h" 31 32 template <class Iter1, class Iter2> 33 constexpr void test_iterators(Iter1 begin1, Iter1 end1, Iter2 begin2, Iter2 end2, int* expected1, int* expected2) { 34 using Expected = std::ranges::mismatch_result<Iter1, Iter2>; 35 std::same_as<Expected> auto ret = std::ranges::mismatch(std::move(begin1), sentinel_wrapper<Iter1>(std::move(end1)), 36 std::move(begin2), sentinel_wrapper<Iter2>(std::move(end2))); 37 assert(base(ret.in1) == expected1); 38 assert(base(ret.in2) == expected2); 39 } 40 41 template <class Iter1, class Iter2> 42 constexpr void test_iters() { 43 int a[] = {1, 2, 3, 4, 5}; 44 int b[] = {1, 2, 3, 5, 4}; 45 46 test_iterators(Iter1(a), Iter1(a + 5), Iter2(b), Iter2(b + 5), a + 3, b + 3); 47 } 48 49 constexpr bool test() { 50 test_iters<cpp17_input_iterator<int*>, cpp17_input_iterator<int*>>(); 51 test_iters<cpp17_input_iterator<int*>, cpp20_input_iterator<int*>>(); 52 test_iters<cpp17_input_iterator<int*>, forward_iterator<int*>>(); 53 test_iters<cpp17_input_iterator<int*>, bidirectional_iterator<int*>>(); 54 test_iters<cpp17_input_iterator<int*>, random_access_iterator<int*>>(); 55 test_iters<cpp17_input_iterator<int*>, contiguous_iterator<int*>>(); 56 test_iters<cpp17_input_iterator<int*>, int*>(); 57 58 test_iters<cpp20_input_iterator<int*>, cpp17_input_iterator<int*>>(); 59 test_iters<cpp20_input_iterator<int*>, cpp20_input_iterator<int*>>(); 60 test_iters<cpp20_input_iterator<int*>, forward_iterator<int*>>(); 61 test_iters<cpp20_input_iterator<int*>, bidirectional_iterator<int*>>(); 62 test_iters<cpp20_input_iterator<int*>, random_access_iterator<int*>>(); 63 test_iters<cpp20_input_iterator<int*>, contiguous_iterator<int*>>(); 64 test_iters<cpp20_input_iterator<int*>, int*>(); 65 66 test_iters<forward_iterator<int*>, cpp17_input_iterator<int*>>(); 67 test_iters<forward_iterator<int*>, cpp20_input_iterator<int*>>(); 68 test_iters<forward_iterator<int*>, forward_iterator<int*>>(); 69 test_iters<forward_iterator<int*>, bidirectional_iterator<int*>>(); 70 test_iters<forward_iterator<int*>, random_access_iterator<int*>>(); 71 test_iters<forward_iterator<int*>, contiguous_iterator<int*>>(); 72 test_iters<forward_iterator<int*>, int*>(); 73 74 test_iters<bidirectional_iterator<int*>, cpp17_input_iterator<int*>>(); 75 test_iters<bidirectional_iterator<int*>, cpp20_input_iterator<int*>>(); 76 test_iters<bidirectional_iterator<int*>, forward_iterator<int*>>(); 77 test_iters<bidirectional_iterator<int*>, bidirectional_iterator<int*>>(); 78 test_iters<bidirectional_iterator<int*>, random_access_iterator<int*>>(); 79 test_iters<bidirectional_iterator<int*>, contiguous_iterator<int*>>(); 80 test_iters<bidirectional_iterator<int*>, int*>(); 81 82 test_iters<random_access_iterator<int*>, cpp17_input_iterator<int*>>(); 83 test_iters<random_access_iterator<int*>, cpp20_input_iterator<int*>>(); 84 test_iters<random_access_iterator<int*>, forward_iterator<int*>>(); 85 test_iters<random_access_iterator<int*>, bidirectional_iterator<int*>>(); 86 test_iters<random_access_iterator<int*>, random_access_iterator<int*>>(); 87 test_iters<random_access_iterator<int*>, contiguous_iterator<int*>>(); 88 test_iters<random_access_iterator<int*>, int*>(); 89 90 test_iters<contiguous_iterator<int*>, cpp17_input_iterator<int*>>(); 91 test_iters<contiguous_iterator<int*>, cpp20_input_iterator<int*>>(); 92 test_iters<contiguous_iterator<int*>, forward_iterator<int*>>(); 93 test_iters<contiguous_iterator<int*>, bidirectional_iterator<int*>>(); 94 test_iters<contiguous_iterator<int*>, random_access_iterator<int*>>(); 95 test_iters<contiguous_iterator<int*>, contiguous_iterator<int*>>(); 96 test_iters<contiguous_iterator<int*>, int*>(); 97 98 test_iters<int*, cpp17_input_iterator<int*>>(); 99 test_iters<int*, cpp20_input_iterator<int*>>(); 100 test_iters<int*, forward_iterator<int*>>(); 101 test_iters<int*, bidirectional_iterator<int*>>(); 102 test_iters<int*, random_access_iterator<int*>>(); 103 test_iters<int*, contiguous_iterator<int*>>(); 104 test_iters<int*, int*>(); 105 106 { // test with a range 107 std::array<int, 5> a = {1, 2, 3, 4, 5}; 108 std::array<int, 5> b = {1, 2, 3, 5, 4}; 109 using Expected = std::ranges::mismatch_result<int*, int*>; 110 std::same_as<Expected> auto ret = std::ranges::mismatch(a, b); 111 assert(ret.in1 == a.begin() + 3); 112 assert(ret.in2 == b.begin() + 3); 113 } 114 115 { // test with non-iterator sentinel 116 int a[] = {1, 2, 3, 4, 5}; 117 int b[] = {1, 2, 3, 5, 4}; 118 119 using Iter = int*; 120 using Sentinel = sentinel_wrapper<Iter>; 121 using Expected = std::ranges::mismatch_result<Iter, Iter>; 122 123 std::same_as<Expected> auto r = std::ranges::mismatch(Iter(a), Sentinel(a + 5), Iter(b), Sentinel(b + 5)); 124 assert(r.in1 == a + 3); 125 assert(r.in2 == b + 3); 126 } 127 128 { // test with different array sizes 129 { 130 int a[] = {1, 2, 3}; 131 int b[] = {1, 2}; 132 test_iterators(a, a + 3, b, b + 2, a + 2, b + 2); 133 using Expected = std::ranges::mismatch_result<int*, int*>; 134 std::same_as<Expected> auto ret = std::ranges::mismatch(a, b); 135 assert(ret.in1 == a + 2); 136 assert(ret.in2 == b + 2); 137 } 138 { 139 int a[] = {1, 2}; 140 int b[] = {1, 2, 3}; 141 test_iterators(a, a + 2, b, b + 3, a + 2, b + 2); 142 using Expected = std::ranges::mismatch_result<int*, int*>; 143 std::same_as<Expected> auto ret = std::ranges::mismatch(a, b); 144 assert(ret.in1 == a + 2); 145 assert(ret.in2 == b + 2); 146 } 147 } 148 149 { // test with borrowed ranges 150 int r1[] = {1, 2, 3, 4, 5}; 151 int r2[] = {1, 2, 3, 5, 4}; 152 153 using Expected = std::ranges::mismatch_result<int*, int*>; 154 { 155 std::same_as<Expected> auto ret = std::ranges::mismatch(r1, std::views::all(r2)); 156 assert(ret.in1 == r1 + 3); 157 assert(ret.in2 == r2 + 3); 158 } 159 { 160 std::same_as<Expected> auto ret = std::ranges::mismatch(std::views::all(r1), r2); 161 assert(ret.in1 == r1 + 3); 162 assert(ret.in2 == r2 + 3); 163 } 164 { 165 std::same_as<Expected> auto ret = std::ranges::mismatch(std::views::all(r1), std::views::all(r2)); 166 assert(ret.in1 == r1 + 3); 167 assert(ret.in2 == r2 + 3); 168 } 169 } 170 171 { // test structured bindings 172 int a[] = {1, 2, 3, 4}; 173 int b[] = {1, 2, 4, 8, 16}; 174 auto [ai, bi] = std::ranges::mismatch(a, b); 175 assert(ai == a + 2); 176 assert(bi == b + 2); 177 auto [aj, bj] = std::ranges::mismatch(a, a+4, b, b+5); 178 assert(aj == a + 2); 179 assert(bj == b + 2); 180 } 181 182 { // test predicate 183 { 184 int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; 185 int b[] = {6, 5, 8, 2, 5, 1, 2, 4}; 186 auto ret = std::ranges::mismatch(a, a + 8, b, b + 8, std::ranges::greater{}); 187 assert(ret.in1 == a + 4); 188 assert(ret.in2 == b + 4); 189 assert(*ret.in1 == 5); 190 assert(*ret.in2 == 5); 191 } 192 193 { 194 int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; 195 int b[] = {6, 5, 8, 2, 5, 1, 2, 4}; 196 auto ret = std::ranges::mismatch(a, b, std::ranges::greater{}); 197 assert(ret.in1 == a + 4); 198 assert(ret.in2 == b + 4); 199 assert(*ret.in1 == 5); 200 assert(*ret.in2 == 5); 201 } 202 } 203 204 { // test projection 205 { 206 int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; 207 int b[] = {6, 5, 8, 2, 5, 1, 2, 4}; 208 auto ret = std::ranges::mismatch(a, b, 209 std::ranges::greater{}, 210 [](int i) { return i == 5 ? +100 : i; }, 211 [](int i) { return i == 5 ? -100 : i; }); 212 assert(ret.in1 == a + 5); 213 assert(ret.in2 == b + 5); 214 assert(*ret.in1 == 1); 215 assert(*ret.in2 == 1); 216 } 217 { 218 int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; 219 auto ret = std::ranges::mismatch(a, a, 220 std::less<double>{}, 221 [](int i) { return i * 1.01; }, 222 [c = 0](int i) mutable { return c++ < 5 ? i * 1.02 : i; }); 223 assert(ret.in1 == a + 5); 224 assert(ret.in2 == a + 5); 225 assert(*ret.in1 == 1); 226 assert(*ret.in2 == 1); 227 } 228 { 229 int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; 230 int b[] = {6, 5, 8, 2, 5, 1, 2, 4}; 231 auto ret = std::ranges::mismatch(a, a + 8, b, b + 8, 232 std::ranges::greater{}, 233 [](int i) { return i == 5 ? +100 : i; }, 234 [](int i) { return i == 5 ? -100 : i; }); 235 assert(ret.in1 == a + 5); 236 assert(ret.in2 == b + 5); 237 assert(*ret.in1 == 1); 238 assert(*ret.in2 == 1); 239 } 240 { 241 int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; 242 auto ret = std::ranges::mismatch(a, a + 8, a, a + 8, 243 std::less<double>{}, 244 [](int i) { return i * 1.01; }, 245 [c = 0](int i) mutable { return c++ < 5 ? i * 1.02 : i; }); 246 assert(ret.in1 == a + 5); 247 assert(ret.in2 == a + 5); 248 assert(*ret.in1 == 1); 249 assert(*ret.in2 == 1); 250 } 251 } 252 253 { // test predicate and projection call count 254 { 255 int pred_count = 0; 256 int proj1_count = 0; 257 int proj2_count = 0; 258 int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; 259 auto ret = std::ranges::mismatch(a, a, 260 [&](int lhs, int rhs) { ++pred_count; return lhs == rhs; }, 261 [&](int i) { ++proj1_count; return i; }, 262 [&](int i) { ++proj2_count; return i; }); 263 assert(ret.in1 == a + 8); 264 assert(ret.in2 == a + 8); 265 assert(pred_count == 8); 266 assert(proj1_count == 8); 267 assert(proj2_count == 8); 268 } 269 { 270 int pred_count = 0; 271 int proj1_count = 0; 272 int proj2_count = 0; 273 int a[] = {7, 6, 9, 3, 5, 1, 2, 4}; 274 auto ret = std::ranges::mismatch(a, a + 8, a, a + 8, 275 [&](int lhs, int rhs) { ++pred_count; return lhs == rhs; }, 276 [&](int i) { ++proj1_count; return i; }, 277 [&](int i) { ++proj2_count; return i; }); 278 assert(ret.in1 == a + 8); 279 assert(ret.in2 == a + 8); 280 assert(pred_count == 8); 281 assert(proj1_count == 8); 282 assert(proj2_count == 8); 283 } 284 } 285 286 return true; 287 } 288 289 int main(int, char**) { 290 test(); 291 static_assert(test()); 292 293 return 0; 294 } 295