1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <algorithm>
11
12 // template<class ForwardIterator1, class ForwardIterator2>
13 // constexpr bool // constexpr after C++17
14 // is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
15 // ForwardIterator2 first2);
16
17 #include <algorithm>
18 #include <cassert>
19
20 #include "test_iterators.h"
21
22 #include "test_macros.h"
23
24 #if TEST_STD_VER > 17
test_constexpr()25 TEST_CONSTEXPR bool test_constexpr() {
26 int ia[] = {0, 0, 0};
27 int ib[] = {1, 1, 0};
28 int ic[] = {1, 0, 1};
29 int id[] = {1};
30 return !std::is_permutation(std::begin(ia), std::end(ia), std::begin(ib))
31 && !std::is_permutation(std::begin(ia), std::end(ia), std::begin(ib), std::end(ib))
32 && std::is_permutation(std::begin(ib), std::end(ib), std::begin(ic))
33 && std::is_permutation(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic))
34 && !std::is_permutation(std::begin(ic), std::end(ic), std::begin(id), std::end(id))
35 ;
36 }
37 #endif
38
main()39 int main()
40 {
41 {
42 const int ia[] = {0};
43 const int ib[] = {0};
44 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
45 assert(std::is_permutation(forward_iterator<const int*>(ia),
46 forward_iterator<const int*>(ia + 0),
47 forward_iterator<const int*>(ib)) == true);
48 #if TEST_STD_VER >= 14
49 assert(std::is_permutation(forward_iterator<const int*>(ia),
50 forward_iterator<const int*>(ia + 0),
51 forward_iterator<const int*>(ib),
52 forward_iterator<const int*>(ib + 0)) == true);
53 #endif
54 assert(std::is_permutation(forward_iterator<const int*>(ia),
55 forward_iterator<const int*>(ia + sa),
56 forward_iterator<const int*>(ib)) == true);
57 #if TEST_STD_VER >= 14
58 assert(std::is_permutation(forward_iterator<const int*>(ia),
59 forward_iterator<const int*>(ia + sa),
60 forward_iterator<const int*>(ib),
61 forward_iterator<const int*>(ib + sa)) == true);
62 assert(std::is_permutation(forward_iterator<const int*>(ia),
63 forward_iterator<const int*>(ia + sa),
64 forward_iterator<const int*>(ib),
65 forward_iterator<const int*>(ib + sa - 1)) == false);
66 #endif
67 }
68 {
69 const int ia[] = {0};
70 const int ib[] = {1};
71 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
72 assert(std::is_permutation(forward_iterator<const int*>(ia),
73 forward_iterator<const int*>(ia + sa),
74 forward_iterator<const int*>(ib)) == false);
75 #if TEST_STD_VER >= 14
76 assert(std::is_permutation(forward_iterator<const int*>(ia),
77 forward_iterator<const int*>(ia + sa),
78 forward_iterator<const int*>(ib),
79 forward_iterator<const int*>(ib + sa)) == false);
80 #endif
81 }
82
83 {
84 const int ia[] = {0, 0};
85 const int ib[] = {0, 0};
86 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
87 assert(std::is_permutation(forward_iterator<const int*>(ia),
88 forward_iterator<const int*>(ia + sa),
89 forward_iterator<const int*>(ib)) == true);
90 #if TEST_STD_VER >= 14
91 assert(std::is_permutation(forward_iterator<const int*>(ia),
92 forward_iterator<const int*>(ia + sa),
93 forward_iterator<const int*>(ib),
94 forward_iterator<const int*>(ib + sa)) == true);
95 assert(std::is_permutation(forward_iterator<const int*>(ia),
96 forward_iterator<const int*>(ia + sa),
97 forward_iterator<const int*>(ib),
98 forward_iterator<const int*>(ib + sa - 1)) == false);
99 #endif
100 }
101 {
102 const int ia[] = {0, 0};
103 const int ib[] = {0, 1};
104 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
105 assert(std::is_permutation(forward_iterator<const int*>(ia),
106 forward_iterator<const int*>(ia + sa),
107 forward_iterator<const int*>(ib)) == false);
108 #if TEST_STD_VER >= 14
109 assert(std::is_permutation(forward_iterator<const int*>(ia),
110 forward_iterator<const int*>(ia + sa),
111 forward_iterator<const int*>(ib),
112 forward_iterator<const int*>(ib + sa)) == false);
113 #endif
114 }
115 {
116 const int ia[] = {0, 0};
117 const int ib[] = {1, 0};
118 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
119 assert(std::is_permutation(forward_iterator<const int*>(ia),
120 forward_iterator<const int*>(ia + sa),
121 forward_iterator<const int*>(ib)) == false);
122 #if TEST_STD_VER >= 14
123 assert(std::is_permutation(forward_iterator<const int*>(ia),
124 forward_iterator<const int*>(ia + sa),
125 forward_iterator<const int*>(ib),
126 forward_iterator<const int*>(ib + sa)) == false);
127 #endif
128 }
129 {
130 const int ia[] = {0, 0};
131 const int ib[] = {1, 1};
132 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
133 assert(std::is_permutation(forward_iterator<const int*>(ia),
134 forward_iterator<const int*>(ia + sa),
135 forward_iterator<const int*>(ib)) == false);
136 #if TEST_STD_VER >= 14
137 assert(std::is_permutation(forward_iterator<const int*>(ia),
138 forward_iterator<const int*>(ia + sa),
139 forward_iterator<const int*>(ib),
140 forward_iterator<const int*>(ib + sa)) == false);
141 #endif
142 }
143 {
144 const int ia[] = {0, 1};
145 const int ib[] = {0, 0};
146 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
147 assert(std::is_permutation(forward_iterator<const int*>(ia),
148 forward_iterator<const int*>(ia + sa),
149 forward_iterator<const int*>(ib)) == false);
150 #if TEST_STD_VER >= 14
151 assert(std::is_permutation(forward_iterator<const int*>(ia),
152 forward_iterator<const int*>(ia + sa),
153 forward_iterator<const int*>(ib),
154 forward_iterator<const int*>(ib + sa)) == false);
155 #endif
156 }
157 {
158 const int ia[] = {0, 1};
159 const int ib[] = {0, 1};
160 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
161 assert(std::is_permutation(forward_iterator<const int*>(ia),
162 forward_iterator<const int*>(ia + sa),
163 forward_iterator<const int*>(ib)) == true);
164 #if TEST_STD_VER >= 14
165 assert(std::is_permutation(forward_iterator<const int*>(ia),
166 forward_iterator<const int*>(ia + sa),
167 forward_iterator<const int*>(ib),
168 forward_iterator<const int*>(ib + sa)) == true);
169 assert(std::is_permutation(forward_iterator<const int*>(ia),
170 forward_iterator<const int*>(ia + sa),
171 forward_iterator<const int*>(ib),
172 forward_iterator<const int*>(ib + sa - 1)) == false);
173 #endif
174 }
175 {
176 const int ia[] = {0, 1};
177 const int ib[] = {1, 0};
178 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
179 assert(std::is_permutation(forward_iterator<const int*>(ia),
180 forward_iterator<const int*>(ia + sa),
181 forward_iterator<const int*>(ib)) == true);
182 #if TEST_STD_VER >= 14
183 assert(std::is_permutation(forward_iterator<const int*>(ia),
184 forward_iterator<const int*>(ia + sa),
185 forward_iterator<const int*>(ib),
186 forward_iterator<const int*>(ib + sa)) == true);
187 #endif
188 }
189 {
190 const int ia[] = {0, 1};
191 const int ib[] = {1, 1};
192 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
193 assert(std::is_permutation(forward_iterator<const int*>(ia),
194 forward_iterator<const int*>(ia + sa),
195 forward_iterator<const int*>(ib)) == false);
196 #if TEST_STD_VER >= 14
197 assert(std::is_permutation(forward_iterator<const int*>(ia),
198 forward_iterator<const int*>(ia + sa),
199 forward_iterator<const int*>(ib),
200 forward_iterator<const int*>(ib + sa)) == false);
201 #endif
202 }
203 {
204 const int ia[] = {1, 0};
205 const int ib[] = {0, 0};
206 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
207 assert(std::is_permutation(forward_iterator<const int*>(ia),
208 forward_iterator<const int*>(ia + sa),
209 forward_iterator<const int*>(ib)) == false);
210 #if TEST_STD_VER >= 14
211 assert(std::is_permutation(forward_iterator<const int*>(ia),
212 forward_iterator<const int*>(ia + sa),
213 forward_iterator<const int*>(ib),
214 forward_iterator<const int*>(ib + sa)) == false);
215 #endif
216 }
217 {
218 const int ia[] = {1, 0};
219 const int ib[] = {0, 1};
220 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
221 assert(std::is_permutation(forward_iterator<const int*>(ia),
222 forward_iterator<const int*>(ia + sa),
223 forward_iterator<const int*>(ib)) == true);
224 #if TEST_STD_VER >= 14
225 assert(std::is_permutation(forward_iterator<const int*>(ia),
226 forward_iterator<const int*>(ia + sa),
227 forward_iterator<const int*>(ib),
228 forward_iterator<const int*>(ib + sa)) == true);
229 #endif
230 }
231 {
232 const int ia[] = {1, 0};
233 const int ib[] = {1, 0};
234 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
235 assert(std::is_permutation(forward_iterator<const int*>(ia),
236 forward_iterator<const int*>(ia + sa),
237 forward_iterator<const int*>(ib)) == true);
238 #if TEST_STD_VER >= 14
239 assert(std::is_permutation(forward_iterator<const int*>(ia),
240 forward_iterator<const int*>(ia + sa),
241 forward_iterator<const int*>(ib),
242 forward_iterator<const int*>(ib + sa)) == true);
243 #endif
244 }
245 {
246 const int ia[] = {1, 0};
247 const int ib[] = {1, 1};
248 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
249 assert(std::is_permutation(forward_iterator<const int*>(ia),
250 forward_iterator<const int*>(ia + sa),
251 forward_iterator<const int*>(ib)) == false);
252 #if TEST_STD_VER >= 14
253 assert(std::is_permutation(forward_iterator<const int*>(ia),
254 forward_iterator<const int*>(ia + sa),
255 forward_iterator<const int*>(ib),
256 forward_iterator<const int*>(ib + sa)) == false);
257 #endif
258 }
259 {
260 const int ia[] = {1, 1};
261 const int ib[] = {0, 0};
262 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
263 assert(std::is_permutation(forward_iterator<const int*>(ia),
264 forward_iterator<const int*>(ia + sa),
265 forward_iterator<const int*>(ib)) == false);
266 #if TEST_STD_VER >= 14
267 assert(std::is_permutation(forward_iterator<const int*>(ia),
268 forward_iterator<const int*>(ia + sa),
269 forward_iterator<const int*>(ib),
270 forward_iterator<const int*>(ib + sa)) == false);
271 #endif
272 }
273 {
274 const int ia[] = {1, 1};
275 const int ib[] = {0, 1};
276 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
277 assert(std::is_permutation(forward_iterator<const int*>(ia),
278 forward_iterator<const int*>(ia + sa),
279 forward_iterator<const int*>(ib)) == false);
280 #if TEST_STD_VER >= 14
281 assert(std::is_permutation(forward_iterator<const int*>(ia),
282 forward_iterator<const int*>(ia + sa),
283 forward_iterator<const int*>(ib),
284 forward_iterator<const int*>(ib + sa)) == false);
285 #endif
286 }
287 {
288 const int ia[] = {1, 1};
289 const int ib[] = {1, 0};
290 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
291 assert(std::is_permutation(forward_iterator<const int*>(ia),
292 forward_iterator<const int*>(ia + sa),
293 forward_iterator<const int*>(ib)) == false);
294 #if TEST_STD_VER >= 14
295 assert(std::is_permutation(forward_iterator<const int*>(ia),
296 forward_iterator<const int*>(ia + sa),
297 forward_iterator<const int*>(ib),
298 forward_iterator<const int*>(ib + sa)) == false);
299 #endif
300 }
301 {
302 const int ia[] = {1, 1};
303 const int ib[] = {1, 1};
304 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
305 assert(std::is_permutation(forward_iterator<const int*>(ia),
306 forward_iterator<const int*>(ia + sa),
307 forward_iterator<const int*>(ib)) == true);
308 #if TEST_STD_VER >= 14
309 assert(std::is_permutation(forward_iterator<const int*>(ia),
310 forward_iterator<const int*>(ia + sa),
311 forward_iterator<const int*>(ib),
312 forward_iterator<const int*>(ib + sa)) == true);
313 #endif
314 }
315
316 {
317 const int ia[] = {0, 0, 0};
318 const int ib[] = {1, 0, 0};
319 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
320 assert(std::is_permutation(forward_iterator<const int*>(ia),
321 forward_iterator<const int*>(ia + sa),
322 forward_iterator<const int*>(ib)) == false);
323 #if TEST_STD_VER >= 14
324 assert(std::is_permutation(forward_iterator<const int*>(ia),
325 forward_iterator<const int*>(ia + sa),
326 forward_iterator<const int*>(ib),
327 forward_iterator<const int*>(ib + sa)) == false);
328 #endif
329 }
330 {
331 const int ia[] = {0, 0, 0};
332 const int ib[] = {1, 0, 1};
333 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
334 assert(std::is_permutation(forward_iterator<const int*>(ia),
335 forward_iterator<const int*>(ia + sa),
336 forward_iterator<const int*>(ib)) == false);
337 #if TEST_STD_VER >= 14
338 assert(std::is_permutation(forward_iterator<const int*>(ia),
339 forward_iterator<const int*>(ia + sa),
340 forward_iterator<const int*>(ib),
341 forward_iterator<const int*>(ib + sa)) == false);
342 #endif
343 }
344 {
345 const int ia[] = {0, 0, 0};
346 const int ib[] = {1, 0, 2};
347 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
348 assert(std::is_permutation(forward_iterator<const int*>(ia),
349 forward_iterator<const int*>(ia + sa),
350 forward_iterator<const int*>(ib)) == false);
351 #if TEST_STD_VER >= 14
352 assert(std::is_permutation(forward_iterator<const int*>(ia),
353 forward_iterator<const int*>(ia + sa),
354 forward_iterator<const int*>(ib),
355 forward_iterator<const int*>(ib + sa)) == false);
356 #endif
357 }
358 {
359 const int ia[] = {0, 0, 0};
360 const int ib[] = {1, 1, 0};
361 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
362 assert(std::is_permutation(forward_iterator<const int*>(ia),
363 forward_iterator<const int*>(ia + sa),
364 forward_iterator<const int*>(ib)) == false);
365 #if TEST_STD_VER >= 14
366 assert(std::is_permutation(forward_iterator<const int*>(ia),
367 forward_iterator<const int*>(ia + sa),
368 forward_iterator<const int*>(ib),
369 forward_iterator<const int*>(ib + sa)) == false);
370 #endif
371 }
372 {
373 const int ia[] = {0, 0, 0};
374 const int ib[] = {1, 1, 1};
375 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
376 assert(std::is_permutation(forward_iterator<const int*>(ia),
377 forward_iterator<const int*>(ia + sa),
378 forward_iterator<const int*>(ib)) == false);
379 #if TEST_STD_VER >= 14
380 assert(std::is_permutation(forward_iterator<const int*>(ia),
381 forward_iterator<const int*>(ia + sa),
382 forward_iterator<const int*>(ib),
383 forward_iterator<const int*>(ib + sa)) == false);
384 #endif
385 }
386 {
387 const int ia[] = {0, 0, 0};
388 const int ib[] = {1, 1, 2};
389 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
390 assert(std::is_permutation(forward_iterator<const int*>(ia),
391 forward_iterator<const int*>(ia + sa),
392 forward_iterator<const int*>(ib)) == false);
393 #if TEST_STD_VER >= 14
394 assert(std::is_permutation(forward_iterator<const int*>(ia),
395 forward_iterator<const int*>(ia + sa),
396 forward_iterator<const int*>(ib),
397 forward_iterator<const int*>(ib + sa)) == false);
398 #endif
399 }
400 {
401 const int ia[] = {0, 0, 0};
402 const int ib[] = {1, 2, 0};
403 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
404 assert(std::is_permutation(forward_iterator<const int*>(ia),
405 forward_iterator<const int*>(ia + sa),
406 forward_iterator<const int*>(ib)) == false);
407 #if TEST_STD_VER >= 14
408 assert(std::is_permutation(forward_iterator<const int*>(ia),
409 forward_iterator<const int*>(ia + sa),
410 forward_iterator<const int*>(ib),
411 forward_iterator<const int*>(ib + sa)) == false);
412 #endif
413 }
414 {
415 const int ia[] = {0, 0, 0};
416 const int ib[] = {1, 2, 1};
417 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
418 assert(std::is_permutation(forward_iterator<const int*>(ia),
419 forward_iterator<const int*>(ia + sa),
420 forward_iterator<const int*>(ib)) == false);
421 #if TEST_STD_VER >= 14
422 assert(std::is_permutation(forward_iterator<const int*>(ia),
423 forward_iterator<const int*>(ia + sa),
424 forward_iterator<const int*>(ib),
425 forward_iterator<const int*>(ib + sa)) == false);
426 #endif
427 }
428 {
429 const int ia[] = {0, 0, 0};
430 const int ib[] = {1, 2, 2};
431 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
432 assert(std::is_permutation(forward_iterator<const int*>(ia),
433 forward_iterator<const int*>(ia + sa),
434 forward_iterator<const int*>(ib)) == false);
435 #if TEST_STD_VER >= 14
436 assert(std::is_permutation(forward_iterator<const int*>(ia),
437 forward_iterator<const int*>(ia + sa),
438 forward_iterator<const int*>(ib),
439 forward_iterator<const int*>(ib + sa)) == false);
440 #endif
441 }
442 {
443 const int ia[] = {0, 0, 1};
444 const int ib[] = {1, 0, 0};
445 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
446 assert(std::is_permutation(forward_iterator<const int*>(ia),
447 forward_iterator<const int*>(ia + sa),
448 forward_iterator<const int*>(ib)) == true);
449 #if TEST_STD_VER >= 14
450 assert(std::is_permutation(forward_iterator<const int*>(ia),
451 forward_iterator<const int*>(ia + sa),
452 forward_iterator<const int*>(ib),
453 forward_iterator<const int*>(ib + sa)) == true);
454 assert(std::is_permutation(forward_iterator<const int*>(ia),
455 forward_iterator<const int*>(ia + sa),
456 forward_iterator<const int*>(ib),
457 forward_iterator<const int*>(ib + sa - 1)) == false);
458 #endif
459 }
460 {
461 const int ia[] = {0, 0, 1};
462 const int ib[] = {1, 0, 1};
463 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
464 assert(std::is_permutation(forward_iterator<const int*>(ia),
465 forward_iterator<const int*>(ia + sa),
466 forward_iterator<const int*>(ib)) == false);
467 #if TEST_STD_VER >= 14
468 assert(std::is_permutation(forward_iterator<const int*>(ia),
469 forward_iterator<const int*>(ia + sa),
470 forward_iterator<const int*>(ib),
471 forward_iterator<const int*>(ib + sa)) == false);
472 #endif
473 }
474 {
475 const int ia[] = {0, 1, 2};
476 const int ib[] = {1, 0, 2};
477 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
478 assert(std::is_permutation(forward_iterator<const int*>(ia),
479 forward_iterator<const int*>(ia + sa),
480 forward_iterator<const int*>(ib)) == true);
481 #if TEST_STD_VER >= 14
482 assert(std::is_permutation(forward_iterator<const int*>(ia),
483 forward_iterator<const int*>(ia + sa),
484 forward_iterator<const int*>(ib),
485 forward_iterator<const int*>(ib + sa)) == true);
486 assert(std::is_permutation(forward_iterator<const int*>(ia),
487 forward_iterator<const int*>(ia + sa),
488 forward_iterator<const int*>(ib),
489 forward_iterator<const int*>(ib + sa - 1)) == false);
490 #endif
491 }
492 {
493 const int ia[] = {0, 1, 2};
494 const int ib[] = {1, 2, 0};
495 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
496 assert(std::is_permutation(forward_iterator<const int*>(ia),
497 forward_iterator<const int*>(ia + sa),
498 forward_iterator<const int*>(ib)) == true);
499 #if TEST_STD_VER >= 14
500 assert(std::is_permutation(forward_iterator<const int*>(ia),
501 forward_iterator<const int*>(ia + sa),
502 forward_iterator<const int*>(ib),
503 forward_iterator<const int*>(ib + sa)) == true);
504 assert(std::is_permutation(forward_iterator<const int*>(ia),
505 forward_iterator<const int*>(ia + sa),
506 forward_iterator<const int*>(ib),
507 forward_iterator<const int*>(ib + sa - 1)) == false);
508 #endif
509 }
510 {
511 const int ia[] = {0, 1, 2};
512 const int ib[] = {2, 1, 0};
513 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
514 assert(std::is_permutation(forward_iterator<const int*>(ia),
515 forward_iterator<const int*>(ia + sa),
516 forward_iterator<const int*>(ib)) == true);
517 #if TEST_STD_VER >= 14
518 assert(std::is_permutation(forward_iterator<const int*>(ia),
519 forward_iterator<const int*>(ia + sa),
520 forward_iterator<const int*>(ib),
521 forward_iterator<const int*>(ib + sa)) == true);
522 assert(std::is_permutation(forward_iterator<const int*>(ia),
523 forward_iterator<const int*>(ia + sa),
524 forward_iterator<const int*>(ib),
525 forward_iterator<const int*>(ib + sa - 1)) == false);
526 #endif
527 }
528 {
529 const int ia[] = {0, 1, 2};
530 const int ib[] = {2, 0, 1};
531 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
532 assert(std::is_permutation(forward_iterator<const int*>(ia),
533 forward_iterator<const int*>(ia + sa),
534 forward_iterator<const int*>(ib)) == true);
535 #if TEST_STD_VER >= 14
536 assert(std::is_permutation(forward_iterator<const int*>(ia),
537 forward_iterator<const int*>(ia + sa),
538 forward_iterator<const int*>(ib),
539 forward_iterator<const int*>(ib + sa)) == true);
540 assert(std::is_permutation(forward_iterator<const int*>(ia),
541 forward_iterator<const int*>(ia + sa),
542 forward_iterator<const int*>(ib),
543 forward_iterator<const int*>(ib + sa - 1)) == false);
544 #endif
545 }
546 {
547 const int ia[] = {0, 0, 1};
548 const int ib[] = {1, 0, 1};
549 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
550 assert(std::is_permutation(forward_iterator<const int*>(ia),
551 forward_iterator<const int*>(ia + sa),
552 forward_iterator<const int*>(ib)) == false);
553 #if TEST_STD_VER >= 14
554 assert(std::is_permutation(forward_iterator<const int*>(ia),
555 forward_iterator<const int*>(ia + sa),
556 forward_iterator<const int*>(ib),
557 forward_iterator<const int*>(ib + sa)) == false);
558 #endif
559 }
560 {
561 const int ia[] = {0, 0, 1};
562 const int ib[] = {1, 0, 0};
563 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
564 assert(std::is_permutation(forward_iterator<const int*>(ia),
565 forward_iterator<const int*>(ia + sa),
566 forward_iterator<const int*>(ib)) == true);
567 #if TEST_STD_VER >= 14
568 assert(std::is_permutation(forward_iterator<const int*>(ia),
569 forward_iterator<const int*>(ia + sa),
570 forward_iterator<const int*>(ib),
571 forward_iterator<const int*>(ib + sa)) == true);
572 assert(std::is_permutation(forward_iterator<const int*>(ia),
573 forward_iterator<const int*>(ia + sa),
574 forward_iterator<const int*>(ib + 1),
575 forward_iterator<const int*>(ib + sa)) == false);
576 assert(std::is_permutation(forward_iterator<const int*>(ia),
577 forward_iterator<const int*>(ia + sa),
578 forward_iterator<const int*>(ib),
579 forward_iterator<const int*>(ib + sa - 1)) == false);
580 #endif
581 }
582 {
583 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
584 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
585 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
586 assert(std::is_permutation(forward_iterator<const int*>(ia),
587 forward_iterator<const int*>(ia + sa),
588 forward_iterator<const int*>(ib)) == true);
589 #if TEST_STD_VER >= 14
590 assert(std::is_permutation(forward_iterator<const int*>(ia),
591 forward_iterator<const int*>(ia + sa),
592 forward_iterator<const int*>(ib),
593 forward_iterator<const int*>(ib + sa)) == true);
594 assert(std::is_permutation(forward_iterator<const int*>(ia),
595 forward_iterator<const int*>(ia + sa),
596 forward_iterator<const int*>(ib + 1 ),
597 forward_iterator<const int*>(ib + sa)) == false);
598 assert(std::is_permutation(forward_iterator<const int*>(ia),
599 forward_iterator<const int*>(ia + sa),
600 forward_iterator<const int*>(ib),
601 forward_iterator<const int*>(ib + sa - 1)) == false);
602 #endif
603 }
604 {
605 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
606 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0};
607 const unsigned sa = sizeof(ia)/sizeof(ia[0]);
608 assert(std::is_permutation(forward_iterator<const int*>(ia),
609 forward_iterator<const int*>(ia + sa),
610 forward_iterator<const int*>(ib)) == false);
611 #if TEST_STD_VER >= 14
612 assert(std::is_permutation(forward_iterator<const int*>(ia),
613 forward_iterator<const int*>(ia + sa),
614 forward_iterator<const int*>(ib),
615 forward_iterator<const int*>(ib + sa)) == false);
616 #endif
617 }
618
619 #if TEST_STD_VER > 17
620 static_assert(test_constexpr());
621 #endif
622 }
623