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