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