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