1 // Range v3 library
2 //
3 // Copyright Eric Niebler 2014-present
4 //
5 // Use, modification and distribution is subject to the
6 // Boost Software License, Version 1.0. (See accompanying
7 // file LICENSE_1_0.txt or copy at
8 // http://www.boost.org/LICENSE_1_0.txt)
9 //
10 // Project home: https://github.com/ericniebler/range-v3
11 //
12 // Copyright 2005 - 2007 Adobe Systems Incorporated
13 // Distributed under the MIT License(see accompanying file LICENSE_1_0_0.txt
14 // or a copy at http://stlab.adobe.com/licenses.html)
15
16 //===----------------------------------------------------------------------===//
17 //
18 // The LLVM Compiler Infrastructure
19 //
20 // This file is dual licensed under the MIT and the University of Illinois Open
21 // Source Licenses. See LICENSE.TXT for details.
22 //
23 //===----------------------------------------------------------------------===//
24
25 #include <utility>
26 #include <range/v3/core.hpp>
27 #include <range/v3/algorithm/permutation.hpp>
28 #include "../simple_test.hpp"
29 #include "../test_utils.hpp"
30 #include "../test_iterators.hpp"
31
32 RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
33
34 int comparison_count = 0;
35
36 template<typename T>
counting_equals(T const & a,T const & b)37 bool counting_equals( T const &a, T const &b )
38 {
39 ++comparison_count;
40 return a == b;
41 }
42
43 struct S
44 {
45 int i;
46 };
47
48 struct T
49 {
50 int i;
51 };
52
main()53 int main()
54 {
55 {
56 const int ia[] = {0};
57 const int ib[] = {0};
58 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
59 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
60 ForwardIterator<const int*>(ia + 0),
61 ForwardIterator<const int*>(ib),
62 std::equal_to<const int>()) == true);
63 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
64 ForwardIterator<const int*>(ia + sa),
65 ForwardIterator<const int*>(ib),
66 std::equal_to<const int>()) == true);
67
68 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
69 ForwardIterator<const int*>(ia + sa),
70 ForwardIterator<const int*>(ib),
71 ForwardIterator<const int*>(ib + sa),
72 std::equal_to<const int>()) == true);
73 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
74 ForwardIterator<const int*>(ia + sa),
75 ForwardIterator<const int*>(ib),
76 ForwardIterator<const int*>(ib + sa - 1),
77 std::equal_to<const int>()) == false);
78 }
79 {
80 const int ia[] = {0};
81 const int ib[] = {1};
82 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
83 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
84 ForwardIterator<const int*>(ia + sa),
85 ForwardIterator<const int*>(ib),
86 std::equal_to<const int>()) == false);
87
88 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
89 ForwardIterator<const int*>(ia + sa),
90 ForwardIterator<const int*>(ib),
91 ForwardIterator<const int*>(ib + sa),
92 std::equal_to<const int>()) == false);
93 }
94
95 {
96 const int ia[] = {0, 0};
97 const int ib[] = {0, 0};
98 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
99 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
100 ForwardIterator<const int*>(ia + sa),
101 ForwardIterator<const int*>(ib),
102 std::equal_to<const int>()) == true);
103
104 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
105 ForwardIterator<const int*>(ia + sa),
106 ForwardIterator<const int*>(ib),
107 ForwardIterator<const int*>(ib + sa),
108 std::equal_to<const int>()) == true);
109 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
110 ForwardIterator<const int*>(ia + sa),
111 ForwardIterator<const int*>(ib),
112 ForwardIterator<const int*>(ib + sa - 1),
113 std::equal_to<const int>()) == false);
114 }
115 {
116 const int ia[] = {0, 0};
117 const int ib[] = {0, 1};
118 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
119 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
120 ForwardIterator<const int*>(ia + sa),
121 ForwardIterator<const int*>(ib),
122 std::equal_to<const int>()) == false);
123
124 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
125 ForwardIterator<const int*>(ia + sa),
126 ForwardIterator<const int*>(ib),
127 ForwardIterator<const int*>(ib + sa),
128 std::equal_to<const int>()) == false);
129 }
130 {
131 const int ia[] = {0, 0};
132 const int ib[] = {1, 0};
133 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
134 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
135 ForwardIterator<const int*>(ia + sa),
136 ForwardIterator<const int*>(ib),
137 std::equal_to<const int>()) == false);
138
139 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
140 ForwardIterator<const int*>(ia + sa),
141 ForwardIterator<const int*>(ib),
142 ForwardIterator<const int*>(ib + sa),
143 std::equal_to<const int>()) == false);
144 }
145 {
146 const int ia[] = {0, 0};
147 const int ib[] = {1, 1};
148 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
149 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
150 ForwardIterator<const int*>(ia + sa),
151 ForwardIterator<const int*>(ib),
152 std::equal_to<const int>()) == false);
153
154 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
155 ForwardIterator<const int*>(ia + sa),
156 ForwardIterator<const int*>(ib),
157 ForwardIterator<const int*>(ib + sa),
158 std::equal_to<const int>()) == false);
159 }
160 {
161 const int ia[] = {0, 1};
162 const int ib[] = {0, 0};
163 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
164 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
165 ForwardIterator<const int*>(ia + sa),
166 ForwardIterator<const int*>(ib),
167 std::equal_to<const int>()) == false);
168
169 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
170 ForwardIterator<const int*>(ia + sa),
171 ForwardIterator<const int*>(ib),
172 ForwardIterator<const int*>(ib + sa),
173 std::equal_to<const int>()) == false);
174 }
175 {
176 const int ia[] = {0, 1};
177 const int ib[] = {0, 1};
178 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
179 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
180 ForwardIterator<const int*>(ia + sa),
181 ForwardIterator<const int*>(ib),
182 std::equal_to<const int>()) == true);
183
184 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
185 ForwardIterator<const int*>(ia + sa),
186 ForwardIterator<const int*>(ib),
187 ForwardIterator<const int*>(ib + sa),
188 std::equal_to<const int>()) == true);
189 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
190 ForwardIterator<const int*>(ia + sa),
191 ForwardIterator<const int*>(ib),
192 ForwardIterator<const int*>(ib + sa - 1),
193 std::equal_to<const int>()) == false);
194 }
195 {
196 const int ia[] = {0, 1};
197 const int ib[] = {1, 0};
198 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
199 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
200 ForwardIterator<const int*>(ia + sa),
201 ForwardIterator<const int*>(ib),
202 std::equal_to<const int>()) == true);
203
204 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
205 ForwardIterator<const int*>(ia + sa),
206 ForwardIterator<const int*>(ib),
207 ForwardIterator<const int*>(ib + sa),
208 std::equal_to<const int>()) == true);
209 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
210 ForwardIterator<const int*>(ia + sa),
211 ForwardIterator<const int*>(ib),
212 ForwardIterator<const int*>(ib + sa - 1),
213 std::equal_to<const int>()) == false);
214 }
215 {
216 const int ia[] = {0, 1};
217 const int ib[] = {1, 1};
218 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
219 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
220 ForwardIterator<const int*>(ia + sa),
221 ForwardIterator<const int*>(ib),
222 std::equal_to<const int>()) == false);
223
224 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
225 ForwardIterator<const int*>(ia + sa),
226 ForwardIterator<const int*>(ib),
227 ForwardIterator<const int*>(ib + sa),
228 std::equal_to<const int>()) == false);
229 }
230 {
231 const int ia[] = {1, 0};
232 const int ib[] = {0, 0};
233 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
234 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
235 ForwardIterator<const int*>(ia + sa),
236 ForwardIterator<const int*>(ib),
237 std::equal_to<const int>()) == false);
238
239 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
240 ForwardIterator<const int*>(ia + sa),
241 ForwardIterator<const int*>(ib),
242 ForwardIterator<const int*>(ib + sa),
243 std::equal_to<const int>()) == false);
244 }
245 {
246 const int ia[] = {1, 0};
247 const int ib[] = {0, 1};
248 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
249 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
250 ForwardIterator<const int*>(ia + sa),
251 ForwardIterator<const int*>(ib),
252 std::equal_to<const int>()) == true);
253
254 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
255 ForwardIterator<const int*>(ia + sa),
256 ForwardIterator<const int*>(ib),
257 ForwardIterator<const int*>(ib + sa),
258 std::equal_to<const int>()) == true);
259 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
260 ForwardIterator<const int*>(ia + sa),
261 ForwardIterator<const int*>(ib),
262 ForwardIterator<const int*>(ib + sa - 1),
263 std::equal_to<const int>()) == false);
264 }
265 {
266 const int ia[] = {1, 0};
267 const int ib[] = {1, 0};
268 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
269 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
270 ForwardIterator<const int*>(ia + sa),
271 ForwardIterator<const int*>(ib),
272 std::equal_to<const int>()) == true);
273
274 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
275 ForwardIterator<const int*>(ia + sa),
276 ForwardIterator<const int*>(ib),
277 ForwardIterator<const int*>(ib + sa),
278 std::equal_to<const int>()) == true);
279 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
280 ForwardIterator<const int*>(ia + sa),
281 ForwardIterator<const int*>(ib),
282 ForwardIterator<const int*>(ib + sa - 1),
283 std::equal_to<const int>()) == false);
284 }
285 {
286 const int ia[] = {1, 0};
287 const int ib[] = {1, 1};
288 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
289 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
290 ForwardIterator<const int*>(ia + sa),
291 ForwardIterator<const int*>(ib),
292 std::equal_to<const int>()) == false);
293
294 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
295 ForwardIterator<const int*>(ia + sa),
296 ForwardIterator<const int*>(ib),
297 ForwardIterator<const int*>(ib + sa),
298 std::equal_to<const int>()) == false);
299 }
300 {
301 const int ia[] = {1, 1};
302 const int ib[] = {0, 0};
303 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
304 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
305 ForwardIterator<const int*>(ia + sa),
306 ForwardIterator<const int*>(ib),
307 std::equal_to<const int>()) == false);
308
309 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
310 ForwardIterator<const int*>(ia + sa),
311 ForwardIterator<const int*>(ib),
312 ForwardIterator<const int*>(ib + sa),
313 std::equal_to<const int>()) == false);
314 }
315 {
316 const int ia[] = {1, 1};
317 const int ib[] = {0, 1};
318 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
319 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
320 ForwardIterator<const int*>(ia + sa),
321 ForwardIterator<const int*>(ib),
322 std::equal_to<const int>()) == false);
323
324 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
325 ForwardIterator<const int*>(ia + sa),
326 ForwardIterator<const int*>(ib),
327 ForwardIterator<const int*>(ib + sa),
328 std::equal_to<const int>()) == false);
329 }
330 {
331 const int ia[] = {1, 1};
332 const int ib[] = {1, 0};
333 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
334 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
335 ForwardIterator<const int*>(ia + sa),
336 ForwardIterator<const int*>(ib),
337 std::equal_to<const int>()) == false);
338
339 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
340 ForwardIterator<const int*>(ia + sa),
341 ForwardIterator<const int*>(ib),
342 ForwardIterator<const int*>(ib + sa),
343 std::equal_to<const int>()) == false);
344 }
345 {
346 const int ia[] = {1, 1};
347 const int ib[] = {1, 1};
348 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
349 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
350 ForwardIterator<const int*>(ia + sa),
351 ForwardIterator<const int*>(ib),
352 std::equal_to<const int>()) == true);
353
354 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
355 ForwardIterator<const int*>(ia + sa),
356 ForwardIterator<const int*>(ib),
357 ForwardIterator<const int*>(ib + sa),
358 std::equal_to<const int>()) == true);
359 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
360 ForwardIterator<const int*>(ia + sa),
361 ForwardIterator<const int*>(ib),
362 ForwardIterator<const int*>(ib + sa - 1),
363 std::equal_to<const int>()) == false);
364 }
365
366 {
367 const int ia[] = {0, 0, 0};
368 const int ib[] = {1, 0, 0};
369 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
370 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
371 ForwardIterator<const int*>(ia + sa),
372 ForwardIterator<const int*>(ib),
373 std::equal_to<const int>()) == false);
374
375 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
376 ForwardIterator<const int*>(ia + sa),
377 ForwardIterator<const int*>(ib),
378 ForwardIterator<const int*>(ib + sa),
379 std::equal_to<const int>()) == false);
380 }
381 {
382 const int ia[] = {0, 0, 0};
383 const int ib[] = {1, 0, 1};
384 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
385 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
386 ForwardIterator<const int*>(ia + sa),
387 ForwardIterator<const int*>(ib),
388 std::equal_to<const int>()) == false);
389
390 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
391 ForwardIterator<const int*>(ia + sa),
392 ForwardIterator<const int*>(ib),
393 ForwardIterator<const int*>(ib + sa),
394 std::equal_to<const int>()) == false);
395 }
396 {
397 const int ia[] = {0, 0, 0};
398 const int ib[] = {1, 0, 2};
399 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
400 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
401 ForwardIterator<const int*>(ia + sa),
402 ForwardIterator<const int*>(ib),
403 std::equal_to<const int>()) == false);
404
405 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
406 ForwardIterator<const int*>(ia + sa),
407 ForwardIterator<const int*>(ib),
408 ForwardIterator<const int*>(ib + sa),
409 std::equal_to<const int>()) == false);
410 }
411 {
412 const int ia[] = {0, 0, 0};
413 const int ib[] = {1, 1, 0};
414 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
415 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
416 ForwardIterator<const int*>(ia + sa),
417 ForwardIterator<const int*>(ib),
418 std::equal_to<const int>()) == false);
419
420 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
421 ForwardIterator<const int*>(ia + sa),
422 ForwardIterator<const int*>(ib),
423 ForwardIterator<const int*>(ib + sa),
424 std::equal_to<const int>()) == false);
425 }
426 {
427 const int ia[] = {0, 0, 0};
428 const int ib[] = {1, 1, 1};
429 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
430 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
431 ForwardIterator<const int*>(ia + sa),
432 ForwardIterator<const int*>(ib),
433 std::equal_to<const int>()) == false);
434
435 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
436 ForwardIterator<const int*>(ia + sa),
437 ForwardIterator<const int*>(ib),
438 ForwardIterator<const int*>(ib + sa),
439 std::equal_to<const int>()) == false);
440 }
441 {
442 const int ia[] = {0, 0, 0};
443 const int ib[] = {1, 1, 2};
444 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
445 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
446 ForwardIterator<const int*>(ia + sa),
447 ForwardIterator<const int*>(ib),
448 std::equal_to<const int>()) == false);
449
450 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
451 ForwardIterator<const int*>(ia + sa),
452 ForwardIterator<const int*>(ib),
453 ForwardIterator<const int*>(ib + sa),
454 std::equal_to<const int>()) == false);
455 }
456 {
457 const int ia[] = {0, 0, 0};
458 const int ib[] = {1, 2, 0};
459 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
460 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
461 ForwardIterator<const int*>(ia + sa),
462 ForwardIterator<const int*>(ib),
463 std::equal_to<const int>()) == false);
464
465 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
466 ForwardIterator<const int*>(ia + sa),
467 ForwardIterator<const int*>(ib),
468 ForwardIterator<const int*>(ib + sa),
469 std::equal_to<const int>()) == false);
470 }
471 {
472 const int ia[] = {0, 0, 0};
473 const int ib[] = {1, 2, 1};
474 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
475 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
476 ForwardIterator<const int*>(ia + sa),
477 ForwardIterator<const int*>(ib),
478 std::equal_to<const int>()) == false);
479
480 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
481 ForwardIterator<const int*>(ia + sa),
482 ForwardIterator<const int*>(ib),
483 ForwardIterator<const int*>(ib + sa),
484 std::equal_to<const int>()) == false);
485 }
486 {
487 const int ia[] = {0, 0, 0};
488 const int ib[] = {1, 2, 2};
489 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
490 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
491 ForwardIterator<const int*>(ia + sa),
492 ForwardIterator<const int*>(ib),
493 std::equal_to<const int>()) == false);
494
495 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
496 ForwardIterator<const int*>(ia + sa),
497 ForwardIterator<const int*>(ib),
498 ForwardIterator<const int*>(ib + sa),
499 std::equal_to<const int>()) == false);
500 }
501 {
502 const int ia[] = {0, 0, 1};
503 const int ib[] = {1, 0, 0};
504 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
505 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
506 ForwardIterator<const int*>(ia + sa),
507 ForwardIterator<const int*>(ib),
508 std::equal_to<const int>()) == true);
509
510 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
511 ForwardIterator<const int*>(ia + sa),
512 ForwardIterator<const int*>(ib),
513 ForwardIterator<const int*>(ib + sa),
514 std::equal_to<const int>()) == true);
515 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
516 ForwardIterator<const int*>(ia + sa),
517 ForwardIterator<const int*>(ib),
518 ForwardIterator<const int*>(ib + sa - 1),
519 std::equal_to<const int>()) == false);
520 }
521 {
522 const int ia[] = {0, 0, 1};
523 const int ib[] = {1, 0, 1};
524 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
525 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
526 ForwardIterator<const int*>(ia + sa),
527 ForwardIterator<const int*>(ib),
528 std::equal_to<const int>()) == false);
529
530 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
531 ForwardIterator<const int*>(ia + sa),
532 ForwardIterator<const int*>(ib),
533 ForwardIterator<const int*>(ib + sa),
534 std::equal_to<const int>()) == false);
535 }
536 {
537 const int ia[] = {0, 1, 2};
538 const int ib[] = {1, 0, 2};
539 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
540 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
541 ForwardIterator<const int*>(ia + sa),
542 ForwardIterator<const int*>(ib),
543 std::equal_to<const int>()) == true);
544
545 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
546 ForwardIterator<const int*>(ia + sa),
547 ForwardIterator<const int*>(ib),
548 ForwardIterator<const int*>(ib + sa),
549 std::equal_to<const int>()) == true);
550 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
551 ForwardIterator<const int*>(ia + sa),
552 ForwardIterator<const int*>(ib),
553 ForwardIterator<const int*>(ib + sa - 1),
554 std::equal_to<const int>()) == false);
555 }
556 {
557 const int ia[] = {0, 1, 2};
558 const int ib[] = {1, 2, 0};
559 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
560 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
561 ForwardIterator<const int*>(ia + sa),
562 ForwardIterator<const int*>(ib),
563 std::equal_to<const int>()) == true);
564
565 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
566 ForwardIterator<const int*>(ia + sa),
567 ForwardIterator<const int*>(ib),
568 ForwardIterator<const int*>(ib + sa),
569 std::equal_to<const int>()) == true);
570 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
571 ForwardIterator<const int*>(ia + sa),
572 ForwardIterator<const int*>(ib),
573 ForwardIterator<const int*>(ib + sa - 1),
574 std::equal_to<const int>()) == false);
575 }
576 {
577 const int ia[] = {0, 1, 2};
578 const int ib[] = {2, 1, 0};
579 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
580 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
581 ForwardIterator<const int*>(ia + sa),
582 ForwardIterator<const int*>(ib),
583 std::equal_to<const int>()) == true);
584
585 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
586 ForwardIterator<const int*>(ia + sa),
587 ForwardIterator<const int*>(ib),
588 ForwardIterator<const int*>(ib + sa),
589 std::equal_to<const int>()) == true);
590 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
591 ForwardIterator<const int*>(ia + sa),
592 ForwardIterator<const int*>(ib),
593 ForwardIterator<const int*>(ib + sa - 1),
594 std::equal_to<const int>()) == false);
595 }
596 {
597 const int ia[] = {0, 1, 2};
598 const int ib[] = {2, 0, 1};
599 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
600 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
601 ForwardIterator<const int*>(ia + sa),
602 ForwardIterator<const int*>(ib),
603 std::equal_to<const int>()) == true);
604
605 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
606 ForwardIterator<const int*>(ia + sa),
607 ForwardIterator<const int*>(ib),
608 ForwardIterator<const int*>(ib + sa),
609 std::equal_to<const int>()) == true);
610 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
611 ForwardIterator<const int*>(ia + sa),
612 ForwardIterator<const int*>(ib),
613 ForwardIterator<const int*>(ib + sa - 1),
614 std::equal_to<const int>()) == false);
615 }
616 {
617 const int ia[] = {0, 0, 1};
618 const int ib[] = {1, 0, 1};
619 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
620 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
621 ForwardIterator<const int*>(ia + sa),
622 ForwardIterator<const int*>(ib),
623 std::equal_to<const int>()) == false);
624
625 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
626 ForwardIterator<const int*>(ia + sa),
627 ForwardIterator<const int*>(ib),
628 ForwardIterator<const int*>(ib + sa),
629 std::equal_to<const int>()) == false);
630 }
631 {
632 const int ia[] = {0, 0, 1};
633 const int ib[] = {1, 0, 0};
634 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
635 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
636 ForwardIterator<const int*>(ia + sa),
637 ForwardIterator<const int*>(ib),
638 std::equal_to<const int>()) == true);
639
640 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
641 ForwardIterator<const int*>(ia + sa),
642 ForwardIterator<const int*>(ib),
643 ForwardIterator<const int*>(ib + sa),
644 std::equal_to<const int>()) == true);
645 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
646 ForwardIterator<const int*>(ia + sa),
647 ForwardIterator<const int*>(ib + 1),
648 ForwardIterator<const int*>(ib + sa),
649 std::equal_to<const int>()) == false);
650 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
651 ForwardIterator<const int*>(ia + sa),
652 ForwardIterator<const int*>(ib),
653 ForwardIterator<const int*>(ib + sa - 1),
654 std::equal_to<const int>()) == false);
655 }
656 {
657 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
658 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
659 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
660 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
661 ForwardIterator<const int*>(ia + sa),
662 ForwardIterator<const int*>(ib),
663 std::equal_to<const int>()) == true);
664
665 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
666 ForwardIterator<const int*>(ia + sa),
667 ForwardIterator<const int*>(ib),
668 ForwardIterator<const int*>(ib + sa),
669 std::equal_to<const int>()) == true);
670 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
671 ForwardIterator<const int*>(ia + sa),
672 ForwardIterator<const int*>(ib + 1),
673 ForwardIterator<const int*>(ib + sa),
674 std::equal_to<const int>()) == false);
675 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
676 ForwardIterator<const int*>(ia + sa),
677 ForwardIterator<const int*>(ib),
678 ForwardIterator<const int*>(ib + sa - 1),
679 std::equal_to<const int>()) == false);
680 comparison_count = 0;
681 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
682 ForwardIterator<const int*>(ia + sa),
683 ForwardIterator<const int*>(ib),
684 ForwardIterator<const int*>(ib + sa - 1),
685 counting_equals<const int>) == false);
686 CHECK( comparison_count > 0 );
687 comparison_count = 0;
688 CHECK(ranges::is_permutation(RandomAccessIterator<const int*>(ia),
689 RandomAccessIterator<const int*>(ia + sa),
690 RandomAccessIterator<const int*>(ib),
691 RandomAccessIterator<const int*>(ib + sa - 1),
692 counting_equals<const int>) == false);
693 CHECK ( comparison_count == 0 );
694 }
695 {
696 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
697 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0};
698 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
699 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
700 ForwardIterator<const int*>(ia + sa),
701 ForwardIterator<const int*>(ib),
702 std::equal_to<const int>()) == false);
703
704 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
705 ForwardIterator<const int*>(ia + sa),
706 ForwardIterator<const int*>(ib),
707 ForwardIterator<const int*>(ib + sa),
708 std::equal_to<const int>()) == false);
709 }
710
711 // Iterator tests, without predicate:
712 {
713 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
714 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
715 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
716 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
717 ForwardIterator<const int*>(ia + sa),
718 ForwardIterator<const int*>(ib)) == true);
719
720 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
721 ForwardIterator<const int*>(ia + sa),
722 ForwardIterator<const int*>(ib),
723 ForwardIterator<const int*>(ib + sa)) == true);
724 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
725 ForwardIterator<const int*>(ia + sa),
726 ForwardIterator<const int*>(ib + 1),
727 ForwardIterator<const int*>(ib + sa)) == false);
728 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
729 ForwardIterator<const int*>(ia + sa),
730 ForwardIterator<const int*>(ib),
731 ForwardIterator<const int*>(ib + sa - 1)) == false);
732 }
733
734 // Iterator tests, with sentinels:
735 {
736 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
737 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
738 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
739 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
740 Sentinel<const int*>(ia + sa),
741 ForwardIterator<const int*>(ib)) == true);
742
743 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
744 Sentinel<const int*>(ia + sa),
745 ForwardIterator<const int*>(ib),
746 Sentinel<const int*>(ib + sa)) == true);
747 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
748 Sentinel<const int*>(ia + sa),
749 ForwardIterator<const int*>(ib + 1),
750 Sentinel<const int*>(ib + sa)) == false);
751 CHECK(ranges::is_permutation(ForwardIterator<const int*>(ia),
752 Sentinel<const int*>(ia + sa),
753 ForwardIterator<const int*>(ib),
754 Sentinel<const int*>(ib + sa - 1)) == false);
755 }
756
757 // common_range tests, with sentinels:
758 {
759 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
760 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
761 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
762 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
763 Sentinel<const int*>(ia + sa)),
764 ForwardIterator<const int*>(ib)) == true);
765
766 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
767 Sentinel<const int*>(ia + sa)),
768 ranges::make_subrange(ForwardIterator<const int*>(ib),
769 Sentinel<const int*>(ib + sa))) == true);
770 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
771 Sentinel<const int*>(ia + sa)),
772 ranges::make_subrange(ForwardIterator<const int*>(ib + 1),
773 Sentinel<const int*>(ib + sa))) == false);
774 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
775 Sentinel<const int*>(ia + sa)),
776 ranges::make_subrange(ForwardIterator<const int*>(ib),
777 Sentinel<const int*>(ib + sa - 1))) == false);
778 }
779
780 // common_range tests, with sentinels, with predicate:
781 {
782 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
783 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
784 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
785 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
786 Sentinel<const int*>(ia + sa)),
787 ForwardIterator<const int*>(ib),
788 std::equal_to<int const>()) == true);
789
790 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
791 Sentinel<const int*>(ia + sa)),
792 ranges::make_subrange(ForwardIterator<const int*>(ib),
793 Sentinel<const int*>(ib + sa)),
794 std::equal_to<int const>()) == true);
795 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
796 Sentinel<const int*>(ia + sa)),
797 ranges::make_subrange(ForwardIterator<const int*>(ib + 1),
798 Sentinel<const int*>(ib + sa)),
799 std::equal_to<int const>()) == false);
800 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const int*>(ia),
801 Sentinel<const int*>(ia + sa)),
802 ranges::make_subrange(ForwardIterator<const int*>(ib),
803 Sentinel<const int*>(ib + sa - 1)),
804 std::equal_to<int const>()) == false);
805 }
806
807 // common_range tests, with sentinels, with predicate and projections:
808 {
809 const S ia[] = {{0}, {1}, {2}, {3}, {0}, {5}, {6}, {2}, {4}, {4}};
810 const T ib[] = {{4}, {2}, {3}, {0}, {1}, {4}, {0}, {5}, {6}, {2}};
811 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
812 CHECK(ranges::is_permutation(ia, &ib[0], std::equal_to<int const>(), &S::i, &T::i) == true);
813 CHECK(ranges::is_permutation(ia, ib, std::equal_to<int const>(), &S::i, &T::i) == true);
814 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const S*>(ia),
815 Sentinel<const S*>(ia + sa)),
816 ranges::make_subrange(ForwardIterator<const T*>(ib + 1),
817 Sentinel<const T*>(ib + sa)),
818 std::equal_to<int const>(), &S::i, &T::i) == false);
819 CHECK(ranges::is_permutation(ranges::make_subrange(ForwardIterator<const S*>(ia),
820 Sentinel<const S*>(ia + sa)),
821 ranges::make_subrange(ForwardIterator<const T*>(ib),
822 Sentinel<const T*>(ib + sa - 1)),
823 std::equal_to<int const>(), &S::i, &T::i) == false);
824 }
825
826 // Iterator tests, with sentinels, with predicate and projections:
827 {
828 const S ia[] = {{0}, {1}, {2}, {3}, {0}, {5}, {6}, {2}, {4}, {4}};
829 const T ib[] = {{4}, {2}, {3}, {0}, {1}, {4}, {0}, {5}, {6}, {2}};
830 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
831 CHECK(ranges::is_permutation(ForwardIterator<const S*>(ia),
832 Sentinel<const S*>(ia + sa),
833 ForwardIterator<const T*>(ib),
834 std::equal_to<int const>(), &S::i, &T::i) == true);
835
836 CHECK(ranges::is_permutation(ForwardIterator<const S*>(ia),
837 Sentinel<const S*>(ia + sa),
838 ForwardIterator<const T*>(ib),
839 Sentinel<const T*>(ib + sa),
840 std::equal_to<int const>(), &S::i, &T::i) == true);
841 CHECK(ranges::is_permutation(ForwardIterator<const S*>(ia),
842 Sentinel<const S*>(ia + sa),
843 ForwardIterator<const T*>(ib + 1),
844 Sentinel<const T*>(ib + sa),
845 std::equal_to<int const>(), &S::i, &T::i) == false);
846 CHECK(ranges::is_permutation(ForwardIterator<const S*>(ia),
847 Sentinel<const S*>(ia + sa),
848 ForwardIterator<const T*>(ib),
849 Sentinel<const T*>(ib + sa - 1),
850 std::equal_to<int const>(), &S::i, &T::i) == false);
851 }
852
853 return ::test_result();
854 }
855