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