test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp

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