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 27 int comparison_count = 0; 28 template <typename T> 29 bool counting_equals ( const T &a, const T &b ) { 30 ++comparison_count; 31 return a == b; 32 } 33 34 35 int 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
