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 // <algorithm>
10 
11 // template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
12 //   constexpr bool   // constexpr after C++17
13 //   is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
14 //                  ForwardIterator2 first2, BinaryPredicate pred);
15 
16 #include <algorithm>
17 #include <functional>
18 #include <cassert>
19 
20 #include "test_macros.h"
21 #include "test_iterators.h"
22 
23 int comparison_count = 0;
24 template <typename T>
25 bool counting_equals ( const T &a, const T &b ) {
26     ++comparison_count;
27     return a == b;
28     }
29 
30 #if TEST_STD_VER > 17
31 constexpr bool test_constexpr() {
32     int ia[] = {0, 0, 0};
33     int ib[] = {1, 1, 0};
34     int ic[] = {1, 0, 1};
35     int id[] = {1};
36     std::equal_to<int> c{};
37     return !std::is_permutation(std::begin(ia), std::end(ia), std::begin(ib)              , c)
38         && !std::is_permutation(std::begin(ia), std::end(ia), std::begin(ib), std::end(ib), c)
39         &&  std::is_permutation(std::begin(ib), std::end(ib), std::begin(ic)              , c)
40         &&  std::is_permutation(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic), c)
41         && !std::is_permutation(std::begin(ic), std::end(ic), std::begin(id), std::end(id), c)
42         ;
43     }
44 #endif
45 
46 
47 struct S {
48   S(int i) : i_(i) {}
49   bool operator==(const S& other) = delete;
50   int i_;
51 };
52 
53 struct eq {
54   bool operator()(const S& a, const S& b) const { return a.i_ == b.i_; }
55 };
56 
57 
58 int main(int, char**)
59 {
60     {
61         const int ia[] = {0};
62         const int ib[] = {0};
63         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
64         assert(std::is_permutation(forward_iterator<const int*>(ia),
65                                    forward_iterator<const int*>(ia + 0),
66                                    forward_iterator<const int*>(ib),
67                                    std::equal_to<const int>()) == true);
68         assert(std::is_permutation(forward_iterator<const int*>(ia),
69                                    forward_iterator<const int*>(ia + sa),
70                                    forward_iterator<const int*>(ib),
71                                    std::equal_to<const int>()) == true);
72 #if TEST_STD_VER >= 14
73         assert(std::is_permutation(forward_iterator<const int*>(ia),
74                                    forward_iterator<const int*>(ia + sa),
75                                    forward_iterator<const int*>(ib),
76                                    forward_iterator<const int*>(ib + sa),
77                                    std::equal_to<const int>()) == true);
78         assert(std::is_permutation(forward_iterator<const int*>(ia),
79                                    forward_iterator<const int*>(ia + sa),
80                                    forward_iterator<const int*>(ib),
81                                    forward_iterator<const int*>(ib + sa - 1),
82                                    std::equal_to<const int>()) == false);
83 #endif
84     }
85     {
86         const int ia[] = {0};
87         const int ib[] = {1};
88         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
89         assert(std::is_permutation(forward_iterator<const int*>(ia),
90                                    forward_iterator<const int*>(ia + sa),
91                                    forward_iterator<const int*>(ib),
92                                    std::equal_to<const int>()) == false);
93 #if TEST_STD_VER >= 14
94         assert(std::is_permutation(forward_iterator<const int*>(ia),
95                                    forward_iterator<const int*>(ia + sa),
96                                    forward_iterator<const int*>(ib),
97                                    forward_iterator<const int*>(ib + sa),
98                                    std::equal_to<const int>()) == false);
99 #endif
100     }
101 
102     {
103         const int ia[] = {0, 0};
104         const int ib[] = {0, 0};
105         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
106         assert(std::is_permutation(forward_iterator<const int*>(ia),
107                                    forward_iterator<const int*>(ia + sa),
108                                    forward_iterator<const int*>(ib),
109                                    std::equal_to<const int>()) == true);
110 #if TEST_STD_VER >= 14
111         assert(std::is_permutation(forward_iterator<const int*>(ia),
112                                    forward_iterator<const int*>(ia + sa),
113                                    forward_iterator<const int*>(ib),
114                                    forward_iterator<const int*>(ib + sa),
115                                    std::equal_to<const int>()) == true);
116         assert(std::is_permutation(forward_iterator<const int*>(ia),
117                                    forward_iterator<const int*>(ia + sa),
118                                    forward_iterator<const int*>(ib),
119                                    forward_iterator<const int*>(ib + sa - 1),
120                                    std::equal_to<const int>()) == false);
121 #endif
122     }
123     {
124         const int ia[] = {0, 0};
125         const int ib[] = {0, 1};
126         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
127         assert(std::is_permutation(forward_iterator<const int*>(ia),
128                                    forward_iterator<const int*>(ia + sa),
129                                    forward_iterator<const int*>(ib),
130                                    std::equal_to<const int>()) == false);
131 #if TEST_STD_VER >= 14
132         assert(std::is_permutation(forward_iterator<const int*>(ia),
133                                    forward_iterator<const int*>(ia + sa),
134                                    forward_iterator<const int*>(ib),
135                                    forward_iterator<const int*>(ib + sa),
136                                    std::equal_to<const int>()) == false);
137 #endif
138     }
139     {
140         const int ia[] = {0, 0};
141         const int ib[] = {1, 0};
142         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
143         assert(std::is_permutation(forward_iterator<const int*>(ia),
144                                    forward_iterator<const int*>(ia + sa),
145                                    forward_iterator<const int*>(ib),
146                                    std::equal_to<const int>()) == false);
147 #if TEST_STD_VER >= 14
148         assert(std::is_permutation(forward_iterator<const int*>(ia),
149                                    forward_iterator<const int*>(ia + sa),
150                                    forward_iterator<const int*>(ib),
151                                    forward_iterator<const int*>(ib + sa),
152                                    std::equal_to<const int>()) == false);
153 #endif
154     }
155     {
156         const int ia[] = {0, 0};
157         const int ib[] = {1, 1};
158         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
159         assert(std::is_permutation(forward_iterator<const int*>(ia),
160                                    forward_iterator<const int*>(ia + sa),
161                                    forward_iterator<const int*>(ib),
162                                    std::equal_to<const int>()) == false);
163 #if TEST_STD_VER >= 14
164         assert(std::is_permutation(forward_iterator<const int*>(ia),
165                                    forward_iterator<const int*>(ia + sa),
166                                    forward_iterator<const int*>(ib),
167                                    forward_iterator<const int*>(ib + sa),
168                                    std::equal_to<const int>()) == false);
169 #endif
170     }
171     {
172         const int ia[] = {0, 1};
173         const int ib[] = {0, 0};
174         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
175         assert(std::is_permutation(forward_iterator<const int*>(ia),
176                                    forward_iterator<const int*>(ia + sa),
177                                    forward_iterator<const int*>(ib),
178                                    std::equal_to<const int>()) == false);
179 #if TEST_STD_VER >= 14
180         assert(std::is_permutation(forward_iterator<const int*>(ia),
181                                    forward_iterator<const int*>(ia + sa),
182                                    forward_iterator<const int*>(ib),
183                                    forward_iterator<const int*>(ib + sa),
184                                    std::equal_to<const int>()) == false);
185 #endif
186     }
187     {
188         const int ia[] = {0, 1};
189         const int ib[] = {0, 1};
190         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
191         assert(std::is_permutation(forward_iterator<const int*>(ia),
192                                    forward_iterator<const int*>(ia + sa),
193                                    forward_iterator<const int*>(ib),
194                                    std::equal_to<const int>()) == true);
195 #if TEST_STD_VER >= 14
196         assert(std::is_permutation(forward_iterator<const int*>(ia),
197                                    forward_iterator<const int*>(ia + sa),
198                                    forward_iterator<const int*>(ib),
199                                    forward_iterator<const int*>(ib + sa),
200                                    std::equal_to<const int>()) == true);
201         assert(std::is_permutation(forward_iterator<const int*>(ia),
202                                    forward_iterator<const int*>(ia + sa),
203                                    forward_iterator<const int*>(ib),
204                                    forward_iterator<const int*>(ib + sa - 1),
205                                    std::equal_to<const int>()) == false);
206 #endif
207     }
208     {
209         const int ia[] = {0, 1};
210         const int ib[] = {1, 0};
211         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
212         assert(std::is_permutation(forward_iterator<const int*>(ia),
213                                    forward_iterator<const int*>(ia + sa),
214                                    forward_iterator<const int*>(ib),
215                                    std::equal_to<const int>()) == true);
216 #if TEST_STD_VER >= 14
217         assert(std::is_permutation(forward_iterator<const int*>(ia),
218                                    forward_iterator<const int*>(ia + sa),
219                                    forward_iterator<const int*>(ib),
220                                    forward_iterator<const int*>(ib + sa),
221                                    std::equal_to<const int>()) == true);
222         assert(std::is_permutation(forward_iterator<const int*>(ia),
223                                    forward_iterator<const int*>(ia + sa),
224                                    forward_iterator<const int*>(ib),
225                                    forward_iterator<const int*>(ib + sa - 1),
226                                    std::equal_to<const int>()) == false);
227 #endif
228     }
229     {
230         const int ia[] = {0, 1};
231         const int ib[] = {1, 1};
232         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
233         assert(std::is_permutation(forward_iterator<const int*>(ia),
234                                    forward_iterator<const int*>(ia + sa),
235                                    forward_iterator<const int*>(ib),
236                                    std::equal_to<const int>()) == false);
237 #if TEST_STD_VER >= 14
238         assert(std::is_permutation(forward_iterator<const int*>(ia),
239                                    forward_iterator<const int*>(ia + sa),
240                                    forward_iterator<const int*>(ib),
241                                    forward_iterator<const int*>(ib + sa),
242                                    std::equal_to<const int>()) == false);
243 #endif
244     }
245     {
246         const int ia[] = {1, 0};
247         const int ib[] = {0, 0};
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),
252                                    std::equal_to<const int>()) == false);
253 #if TEST_STD_VER >= 14
254         assert(std::is_permutation(forward_iterator<const int*>(ia),
255                                    forward_iterator<const int*>(ia + sa),
256                                    forward_iterator<const int*>(ib),
257                                    forward_iterator<const int*>(ib + sa),
258                                    std::equal_to<const int>()) == false);
259 #endif
260     }
261     {
262         const int ia[] = {1, 0};
263         const int ib[] = {0, 1};
264         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
265         assert(std::is_permutation(forward_iterator<const int*>(ia),
266                                    forward_iterator<const int*>(ia + sa),
267                                    forward_iterator<const int*>(ib),
268                                    std::equal_to<const int>()) == true);
269 #if TEST_STD_VER >= 14
270         assert(std::is_permutation(forward_iterator<const int*>(ia),
271                                    forward_iterator<const int*>(ia + sa),
272                                    forward_iterator<const int*>(ib),
273                                    forward_iterator<const int*>(ib + sa),
274                                    std::equal_to<const int>()) == true);
275         assert(std::is_permutation(forward_iterator<const int*>(ia),
276                                    forward_iterator<const int*>(ia + sa),
277                                    forward_iterator<const int*>(ib),
278                                    forward_iterator<const int*>(ib + sa - 1),
279                                    std::equal_to<const int>()) == false);
280 #endif
281     }
282     {
283         const int ia[] = {1, 0};
284         const int ib[] = {1, 0};
285         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
286         assert(std::is_permutation(forward_iterator<const int*>(ia),
287                                    forward_iterator<const int*>(ia + sa),
288                                    forward_iterator<const int*>(ib),
289                                    std::equal_to<const int>()) == true);
290 #if TEST_STD_VER >= 14
291         assert(std::is_permutation(forward_iterator<const int*>(ia),
292                                    forward_iterator<const int*>(ia + sa),
293                                    forward_iterator<const int*>(ib),
294                                    forward_iterator<const int*>(ib + sa),
295                                    std::equal_to<const int>()) == true);
296         assert(std::is_permutation(forward_iterator<const int*>(ia),
297                                    forward_iterator<const int*>(ia + sa),
298                                    forward_iterator<const int*>(ib),
299                                    forward_iterator<const int*>(ib + sa - 1),
300                                    std::equal_to<const int>()) == false);
301 #endif
302     }
303     {
304         const int ia[] = {1, 0};
305         const int ib[] = {1, 1};
306         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
307         assert(std::is_permutation(forward_iterator<const int*>(ia),
308                                    forward_iterator<const int*>(ia + sa),
309                                    forward_iterator<const int*>(ib),
310                                    std::equal_to<const int>()) == false);
311 #if TEST_STD_VER >= 14
312         assert(std::is_permutation(forward_iterator<const int*>(ia),
313                                    forward_iterator<const int*>(ia + sa),
314                                    forward_iterator<const int*>(ib),
315                                    forward_iterator<const int*>(ib + sa),
316                                    std::equal_to<const int>()) == false);
317 #endif
318     }
319     {
320         const int ia[] = {1, 1};
321         const int ib[] = {0, 0};
322         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
323         assert(std::is_permutation(forward_iterator<const int*>(ia),
324                                    forward_iterator<const int*>(ia + sa),
325                                    forward_iterator<const int*>(ib),
326                                    std::equal_to<const int>()) == false);
327 #if TEST_STD_VER >= 14
328         assert(std::is_permutation(forward_iterator<const int*>(ia),
329                                    forward_iterator<const int*>(ia + sa),
330                                    forward_iterator<const int*>(ib),
331                                    forward_iterator<const int*>(ib + sa),
332                                    std::equal_to<const int>()) == false);
333 #endif
334     }
335     {
336         const int ia[] = {1, 1};
337         const int ib[] = {0, 1};
338         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
339         assert(std::is_permutation(forward_iterator<const int*>(ia),
340                                    forward_iterator<const int*>(ia + sa),
341                                    forward_iterator<const int*>(ib),
342                                    std::equal_to<const int>()) == false);
343 #if TEST_STD_VER >= 14
344         assert(std::is_permutation(forward_iterator<const int*>(ia),
345                                    forward_iterator<const int*>(ia + sa),
346                                    forward_iterator<const int*>(ib),
347                                    forward_iterator<const int*>(ib + sa),
348                                    std::equal_to<const int>()) == false);
349 #endif
350     }
351     {
352         const int ia[] = {1, 1};
353         const int ib[] = {1, 0};
354         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
355         assert(std::is_permutation(forward_iterator<const int*>(ia),
356                                    forward_iterator<const int*>(ia + sa),
357                                    forward_iterator<const int*>(ib),
358                                    std::equal_to<const int>()) == false);
359 #if TEST_STD_VER >= 14
360         assert(std::is_permutation(forward_iterator<const int*>(ia),
361                                    forward_iterator<const int*>(ia + sa),
362                                    forward_iterator<const int*>(ib),
363                                    forward_iterator<const int*>(ib + sa),
364                                    std::equal_to<const int>()) == false);
365 #endif
366     }
367     {
368         const int ia[] = {1, 1};
369         const int ib[] = {1, 1};
370         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
371         assert(std::is_permutation(forward_iterator<const int*>(ia),
372                                    forward_iterator<const int*>(ia + sa),
373                                    forward_iterator<const int*>(ib),
374                                    std::equal_to<const int>()) == true);
375 #if TEST_STD_VER >= 14
376         assert(std::is_permutation(forward_iterator<const int*>(ia),
377                                    forward_iterator<const int*>(ia + sa),
378                                    forward_iterator<const int*>(ib),
379                                    forward_iterator<const int*>(ib + sa),
380                                    std::equal_to<const int>()) == true);
381         assert(std::is_permutation(forward_iterator<const int*>(ia),
382                                    forward_iterator<const int*>(ia + sa),
383                                    forward_iterator<const int*>(ib),
384                                    forward_iterator<const int*>(ib + sa - 1),
385                                    std::equal_to<const int>()) == false);
386 #endif
387     }
388 
389     {
390         const int ia[] = {0, 0, 0};
391         const int ib[] = {1, 0, 0};
392         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
393         assert(std::is_permutation(forward_iterator<const int*>(ia),
394                                    forward_iterator<const int*>(ia + sa),
395                                    forward_iterator<const int*>(ib),
396                                    std::equal_to<const int>()) == false);
397 #if TEST_STD_VER >= 14
398         assert(std::is_permutation(forward_iterator<const int*>(ia),
399                                    forward_iterator<const int*>(ia + sa),
400                                    forward_iterator<const int*>(ib),
401                                    forward_iterator<const int*>(ib + sa),
402                                    std::equal_to<const int>()) == false);
403 #endif
404     }
405     {
406         const int ia[] = {0, 0, 0};
407         const int ib[] = {1, 0, 1};
408         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
409         assert(std::is_permutation(forward_iterator<const int*>(ia),
410                                    forward_iterator<const int*>(ia + sa),
411                                    forward_iterator<const int*>(ib),
412                                    std::equal_to<const int>()) == false);
413 #if TEST_STD_VER >= 14
414         assert(std::is_permutation(forward_iterator<const int*>(ia),
415                                    forward_iterator<const int*>(ia + sa),
416                                    forward_iterator<const int*>(ib),
417                                    forward_iterator<const int*>(ib + sa),
418                                    std::equal_to<const int>()) == false);
419 #endif
420     }
421     {
422         const int ia[] = {0, 0, 0};
423         const int ib[] = {1, 0, 2};
424         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
425         assert(std::is_permutation(forward_iterator<const int*>(ia),
426                                    forward_iterator<const int*>(ia + sa),
427                                    forward_iterator<const int*>(ib),
428                                    std::equal_to<const int>()) == false);
429 #if TEST_STD_VER >= 14
430         assert(std::is_permutation(forward_iterator<const int*>(ia),
431                                    forward_iterator<const int*>(ia + sa),
432                                    forward_iterator<const int*>(ib),
433                                    forward_iterator<const int*>(ib + sa),
434                                    std::equal_to<const int>()) == false);
435 #endif
436     }
437     {
438         const int ia[] = {0, 0, 0};
439         const int ib[] = {1, 1, 0};
440         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
441         assert(std::is_permutation(forward_iterator<const int*>(ia),
442                                    forward_iterator<const int*>(ia + sa),
443                                    forward_iterator<const int*>(ib),
444                                    std::equal_to<const int>()) == false);
445 #if TEST_STD_VER >= 14
446         assert(std::is_permutation(forward_iterator<const int*>(ia),
447                                    forward_iterator<const int*>(ia + sa),
448                                    forward_iterator<const int*>(ib),
449                                    forward_iterator<const int*>(ib + sa),
450                                    std::equal_to<const int>()) == false);
451 #endif
452     }
453     {
454         const int ia[] = {0, 0, 0};
455         const int ib[] = {1, 1, 1};
456         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
457         assert(std::is_permutation(forward_iterator<const int*>(ia),
458                                    forward_iterator<const int*>(ia + sa),
459                                    forward_iterator<const int*>(ib),
460                                    std::equal_to<const int>()) == false);
461 #if TEST_STD_VER >= 14
462         assert(std::is_permutation(forward_iterator<const int*>(ia),
463                                    forward_iterator<const int*>(ia + sa),
464                                    forward_iterator<const int*>(ib),
465                                    forward_iterator<const int*>(ib + sa),
466                                    std::equal_to<const int>()) == false);
467 #endif
468     }
469     {
470         const int ia[] = {0, 0, 0};
471         const int ib[] = {1, 1, 2};
472         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
473         assert(std::is_permutation(forward_iterator<const int*>(ia),
474                                    forward_iterator<const int*>(ia + sa),
475                                    forward_iterator<const int*>(ib),
476                                    std::equal_to<const int>()) == false);
477 #if TEST_STD_VER >= 14
478         assert(std::is_permutation(forward_iterator<const int*>(ia),
479                                    forward_iterator<const int*>(ia + sa),
480                                    forward_iterator<const int*>(ib),
481                                    forward_iterator<const int*>(ib + sa),
482                                    std::equal_to<const int>()) == false);
483 #endif
484     }
485     {
486         const int ia[] = {0, 0, 0};
487         const int ib[] = {1, 2, 0};
488         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
489         assert(std::is_permutation(forward_iterator<const int*>(ia),
490                                    forward_iterator<const int*>(ia + sa),
491                                    forward_iterator<const int*>(ib),
492                                    std::equal_to<const int>()) == false);
493 #if TEST_STD_VER >= 14
494         assert(std::is_permutation(forward_iterator<const int*>(ia),
495                                    forward_iterator<const int*>(ia + sa),
496                                    forward_iterator<const int*>(ib),
497                                    forward_iterator<const int*>(ib + sa),
498                                    std::equal_to<const int>()) == false);
499 #endif
500     }
501     {
502         const int ia[] = {0, 0, 0};
503         const int ib[] = {1, 2, 1};
504         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
505         assert(std::is_permutation(forward_iterator<const int*>(ia),
506                                    forward_iterator<const int*>(ia + sa),
507                                    forward_iterator<const int*>(ib),
508                                    std::equal_to<const int>()) == false);
509 #if TEST_STD_VER >= 14
510         assert(std::is_permutation(forward_iterator<const int*>(ia),
511                                    forward_iterator<const int*>(ia + sa),
512                                    forward_iterator<const int*>(ib),
513                                    forward_iterator<const int*>(ib + sa),
514                                    std::equal_to<const int>()) == false);
515 #endif
516     }
517     {
518         const int ia[] = {0, 0, 0};
519         const int ib[] = {1, 2, 2};
520         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
521         assert(std::is_permutation(forward_iterator<const int*>(ia),
522                                    forward_iterator<const int*>(ia + sa),
523                                    forward_iterator<const int*>(ib),
524                                    std::equal_to<const int>()) == false);
525 #if TEST_STD_VER >= 14
526         assert(std::is_permutation(forward_iterator<const int*>(ia),
527                                    forward_iterator<const int*>(ia + sa),
528                                    forward_iterator<const int*>(ib),
529                                    forward_iterator<const int*>(ib + sa),
530                                    std::equal_to<const int>()) == false);
531 #endif
532     }
533     {
534         const int ia[] = {0, 0, 1};
535         const int ib[] = {1, 0, 0};
536         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
537         assert(std::is_permutation(forward_iterator<const int*>(ia),
538                                    forward_iterator<const int*>(ia + sa),
539                                    forward_iterator<const int*>(ib),
540                                    std::equal_to<const int>()) == true);
541 #if TEST_STD_VER >= 14
542         assert(std::is_permutation(forward_iterator<const int*>(ia),
543                                    forward_iterator<const int*>(ia + sa),
544                                    forward_iterator<const int*>(ib),
545                                    forward_iterator<const int*>(ib + sa),
546                                    std::equal_to<const int>()) == true);
547         assert(std::is_permutation(forward_iterator<const int*>(ia),
548                                    forward_iterator<const int*>(ia + sa),
549                                    forward_iterator<const int*>(ib),
550                                    forward_iterator<const int*>(ib + sa - 1),
551                                    std::equal_to<const int>()) == false);
552 #endif
553     }
554     {
555         const int ia[] = {0, 0, 1};
556         const int ib[] = {1, 0, 1};
557         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
558         assert(std::is_permutation(forward_iterator<const int*>(ia),
559                                    forward_iterator<const int*>(ia + sa),
560                                    forward_iterator<const int*>(ib),
561                                    std::equal_to<const int>()) == false);
562 #if TEST_STD_VER >= 14
563         assert(std::is_permutation(forward_iterator<const int*>(ia),
564                                    forward_iterator<const int*>(ia + sa),
565                                    forward_iterator<const int*>(ib),
566                                    forward_iterator<const int*>(ib + sa),
567                                    std::equal_to<const int>()) == false);
568 #endif
569     }
570     {
571         const int ia[] = {0, 1, 2};
572         const int ib[] = {1, 0, 2};
573         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
574         assert(std::is_permutation(forward_iterator<const int*>(ia),
575                                    forward_iterator<const int*>(ia + sa),
576                                    forward_iterator<const int*>(ib),
577                                    std::equal_to<const int>()) == true);
578 #if TEST_STD_VER >= 14
579         assert(std::is_permutation(forward_iterator<const int*>(ia),
580                                    forward_iterator<const int*>(ia + sa),
581                                    forward_iterator<const int*>(ib),
582                                    forward_iterator<const int*>(ib + sa),
583                                    std::equal_to<const int>()) == true);
584         assert(std::is_permutation(forward_iterator<const int*>(ia),
585                                    forward_iterator<const int*>(ia + sa),
586                                    forward_iterator<const int*>(ib),
587                                    forward_iterator<const int*>(ib + sa - 1),
588                                    std::equal_to<const int>()) == false);
589 #endif
590     }
591     {
592         const int ia[] = {0, 1, 2};
593         const int ib[] = {1, 2, 0};
594         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
595         assert(std::is_permutation(forward_iterator<const int*>(ia),
596                                    forward_iterator<const int*>(ia + sa),
597                                    forward_iterator<const int*>(ib),
598                                    std::equal_to<const int>()) == true);
599 #if TEST_STD_VER >= 14
600         assert(std::is_permutation(forward_iterator<const int*>(ia),
601                                    forward_iterator<const int*>(ia + sa),
602                                    forward_iterator<const int*>(ib),
603                                    forward_iterator<const int*>(ib + sa),
604                                    std::equal_to<const int>()) == true);
605         assert(std::is_permutation(forward_iterator<const int*>(ia),
606                                    forward_iterator<const int*>(ia + sa),
607                                    forward_iterator<const int*>(ib),
608                                    forward_iterator<const int*>(ib + sa - 1),
609                                    std::equal_to<const int>()) == false);
610 #endif
611     }
612     {
613         const int ia[] = {0, 1, 2};
614         const int ib[] = {2, 1, 0};
615         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
616         assert(std::is_permutation(forward_iterator<const int*>(ia),
617                                    forward_iterator<const int*>(ia + sa),
618                                    forward_iterator<const int*>(ib),
619                                    std::equal_to<const int>()) == true);
620 #if TEST_STD_VER >= 14
621         assert(std::is_permutation(forward_iterator<const int*>(ia),
622                                    forward_iterator<const int*>(ia + sa),
623                                    forward_iterator<const int*>(ib),
624                                    forward_iterator<const int*>(ib + sa),
625                                    std::equal_to<const int>()) == true);
626         assert(std::is_permutation(forward_iterator<const int*>(ia),
627                                    forward_iterator<const int*>(ia + sa),
628                                    forward_iterator<const int*>(ib),
629                                    forward_iterator<const int*>(ib + sa - 1),
630                                    std::equal_to<const int>()) == false);
631 #endif
632     }
633     {
634         const int ia[] = {0, 1, 2};
635         const int ib[] = {2, 0, 1};
636         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
637         assert(std::is_permutation(forward_iterator<const int*>(ia),
638                                    forward_iterator<const int*>(ia + sa),
639                                    forward_iterator<const int*>(ib),
640                                    std::equal_to<const int>()) == true);
641 #if TEST_STD_VER >= 14
642         assert(std::is_permutation(forward_iterator<const int*>(ia),
643                                    forward_iterator<const int*>(ia + sa),
644                                    forward_iterator<const int*>(ib),
645                                    forward_iterator<const int*>(ib + sa),
646                                    std::equal_to<const int>()) == true);
647         assert(std::is_permutation(forward_iterator<const int*>(ia),
648                                    forward_iterator<const int*>(ia + sa),
649                                    forward_iterator<const int*>(ib),
650                                    forward_iterator<const int*>(ib + sa - 1),
651                                    std::equal_to<const int>()) == false);
652 #endif
653     }
654     {
655         const int ia[] = {0, 0, 1};
656         const int ib[] = {1, 0, 1};
657         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
658         assert(std::is_permutation(forward_iterator<const int*>(ia),
659                                    forward_iterator<const int*>(ia + sa),
660                                    forward_iterator<const int*>(ib),
661                                    std::equal_to<const int>()) == false);
662 #if TEST_STD_VER >= 14
663         assert(std::is_permutation(forward_iterator<const int*>(ia),
664                                    forward_iterator<const int*>(ia + sa),
665                                    forward_iterator<const int*>(ib),
666                                    forward_iterator<const int*>(ib + sa),
667                                    std::equal_to<const int>()) == false);
668 #endif
669     }
670     {
671         const int ia[] = {0, 0, 1};
672         const int ib[] = {1, 0, 0};
673         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
674         assert(std::is_permutation(forward_iterator<const int*>(ia),
675                                    forward_iterator<const int*>(ia + sa),
676                                    forward_iterator<const int*>(ib),
677                                    std::equal_to<const int>()) == true);
678 #if TEST_STD_VER >= 14
679         assert(std::is_permutation(forward_iterator<const int*>(ia),
680                                    forward_iterator<const int*>(ia + sa),
681                                    forward_iterator<const int*>(ib),
682                                    forward_iterator<const int*>(ib + sa),
683                                    std::equal_to<const int>()) == true);
684         assert(std::is_permutation(forward_iterator<const int*>(ia),
685                                    forward_iterator<const int*>(ia + sa),
686                                    forward_iterator<const int*>(ib + 1),
687                                    forward_iterator<const int*>(ib + sa),
688                                    std::equal_to<const int>()) == false);
689         assert(std::is_permutation(forward_iterator<const int*>(ia),
690                                    forward_iterator<const int*>(ia + sa),
691                                    forward_iterator<const int*>(ib),
692                                    forward_iterator<const int*>(ib + sa - 1),
693                                    std::equal_to<const int>()) == false);
694 #endif
695     }
696     {
697         const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
698         const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2};
699         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
700         assert(std::is_permutation(forward_iterator<const int*>(ia),
701                                    forward_iterator<const int*>(ia + sa),
702                                    forward_iterator<const int*>(ib),
703                                    std::equal_to<const int>()) == true);
704 #if TEST_STD_VER >= 14
705         assert(std::is_permutation(forward_iterator<const int*>(ia),
706                                    forward_iterator<const int*>(ia + sa),
707                                    forward_iterator<const int*>(ib),
708                                    forward_iterator<const int*>(ib + sa),
709                                    std::equal_to<const int>()) == true);
710         assert(std::is_permutation(forward_iterator<const int*>(ia),
711                                    forward_iterator<const int*>(ia + sa),
712                                    forward_iterator<const int*>(ib + 1),
713                                    forward_iterator<const int*>(ib + sa),
714                                    std::equal_to<const int>()) == false);
715         assert(std::is_permutation(forward_iterator<const int*>(ia),
716                                    forward_iterator<const int*>(ia + sa),
717                                    forward_iterator<const int*>(ib),
718                                    forward_iterator<const int*>(ib + sa - 1),
719                                    std::equal_to<const int>()) == false);
720         comparison_count = 0;
721         assert(std::is_permutation(forward_iterator<const int*>(ia),
722                                    forward_iterator<const int*>(ia + sa),
723                                    forward_iterator<const int*>(ib),
724                                    forward_iterator<const int*>(ib + sa - 1),
725                                    counting_equals<const int>) == false);
726         assert ( comparison_count > 0 );
727         comparison_count = 0;
728         assert(std::is_permutation(random_access_iterator<const int*>(ia),
729                                    random_access_iterator<const int*>(ia + sa),
730                                    random_access_iterator<const int*>(ib),
731                                    random_access_iterator<const int*>(ib + sa - 1),
732                                    counting_equals<const int>) == false);
733         assert ( comparison_count == 0 );
734 #endif
735     }
736     {
737         const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4};
738         const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0};
739         const unsigned sa = sizeof(ia)/sizeof(ia[0]);
740         assert(std::is_permutation(forward_iterator<const int*>(ia),
741                                    forward_iterator<const int*>(ia + sa),
742                                    forward_iterator<const int*>(ib),
743                                    std::equal_to<const int>()) == false);
744 #if TEST_STD_VER >= 14
745         assert(std::is_permutation(forward_iterator<const int*>(ia),
746                                    forward_iterator<const int*>(ia + sa),
747                                    forward_iterator<const int*>(ib),
748                                    forward_iterator<const int*>(ib + sa),
749                                    std::equal_to<const int>()) == false);
750 #endif
751     }
752     {
753       const S a[] = {S(0), S(1)};
754       const S b[] = {S(1), S(0)};
755       const unsigned sa = sizeof(a)/sizeof(a[0]);
756       assert(std::is_permutation(forward_iterator<const S*>(a),
757                                  forward_iterator<const S*>(a + sa),
758                                  forward_iterator<const S*>(b),
759                                  eq()));
760 #if TEST_STD_VER >= 14
761       assert(std::is_permutation(forward_iterator<const S*>(a),
762                                  forward_iterator<const S*>(a + sa),
763                                  forward_iterator<const S*>(b),
764                                  forward_iterator<const S*>(b + sa),
765                                  eq()));
766 #endif
767     }
768 
769 #if TEST_STD_VER > 17
770     static_assert(test_constexpr());
771 #endif
772 
773   return 0;
774 }
775