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> 13 // bool 14 // is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, 15 // ForwardIterator2 first2); 16 17 #include <algorithm> 18 #include <cassert> 19 20 #include "test_iterators.h" 21 22 #if _LIBCPP_STD_VER > 11 23 #define HAS_FOUR_ITERATOR_VERSION 24 #endif 25 26 int main() 27 { 28 { 29 const int ia[] = {0}; 30 const int ib[] = {0}; 31 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 32 assert(std::is_permutation(forward_iterator<const int*>(ia), 33 forward_iterator<const int*>(ia + 0), 34 forward_iterator<const int*>(ib)) == true); 35 #ifdef HAS_FOUR_ITERATOR_VERSION 36 assert(std::is_permutation(forward_iterator<const int*>(ia), 37 forward_iterator<const int*>(ia + 0), 38 forward_iterator<const int*>(ib), 39 forward_iterator<const int*>(ib + 0)) == true); 40 #endif 41 assert(std::is_permutation(forward_iterator<const int*>(ia), 42 forward_iterator<const int*>(ia + sa), 43 forward_iterator<const int*>(ib)) == true); 44 #ifdef HAS_FOUR_ITERATOR_VERSION 45 assert(std::is_permutation(forward_iterator<const int*>(ia), 46 forward_iterator<const int*>(ia + sa), 47 forward_iterator<const int*>(ib), 48 forward_iterator<const int*>(ib + sa)) == true); 49 assert(std::is_permutation(forward_iterator<const int*>(ia), 50 forward_iterator<const int*>(ia + sa), 51 forward_iterator<const int*>(ib), 52 forward_iterator<const int*>(ib + sa - 1)) == false); 53 #endif 54 } 55 { 56 const int ia[] = {0}; 57 const int ib[] = {1}; 58 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 59 assert(std::is_permutation(forward_iterator<const int*>(ia), 60 forward_iterator<const int*>(ia + sa), 61 forward_iterator<const int*>(ib)) == false); 62 #ifdef HAS_FOUR_ITERATOR_VERSION 63 assert(std::is_permutation(forward_iterator<const int*>(ia), 64 forward_iterator<const int*>(ia + sa), 65 forward_iterator<const int*>(ib), 66 forward_iterator<const int*>(ib + sa)) == false); 67 #endif 68 } 69 70 { 71 const int ia[] = {0, 0}; 72 const int ib[] = {0, 0}; 73 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 74 assert(std::is_permutation(forward_iterator<const int*>(ia), 75 forward_iterator<const int*>(ia + sa), 76 forward_iterator<const int*>(ib)) == true); 77 #ifdef HAS_FOUR_ITERATOR_VERSION 78 assert(std::is_permutation(forward_iterator<const int*>(ia), 79 forward_iterator<const int*>(ia + sa), 80 forward_iterator<const int*>(ib), 81 forward_iterator<const int*>(ib + sa)) == true); 82 assert(std::is_permutation(forward_iterator<const int*>(ia), 83 forward_iterator<const int*>(ia + sa), 84 forward_iterator<const int*>(ib), 85 forward_iterator<const int*>(ib + sa - 1)) == false); 86 #endif 87 } 88 { 89 const int ia[] = {0, 0}; 90 const int ib[] = {0, 1}; 91 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 92 assert(std::is_permutation(forward_iterator<const int*>(ia), 93 forward_iterator<const int*>(ia + sa), 94 forward_iterator<const int*>(ib)) == false); 95 #ifdef HAS_FOUR_ITERATOR_VERSION 96 assert(std::is_permutation(forward_iterator<const int*>(ia), 97 forward_iterator<const int*>(ia + sa), 98 forward_iterator<const int*>(ib), 99 forward_iterator<const int*>(ib + sa)) == false); 100 #endif 101 } 102 { 103 const int ia[] = {0, 0}; 104 const int ib[] = {1, 0}; 105 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 106 assert(std::is_permutation(forward_iterator<const int*>(ia), 107 forward_iterator<const int*>(ia + sa), 108 forward_iterator<const int*>(ib)) == false); 109 #ifdef HAS_FOUR_ITERATOR_VERSION 110 assert(std::is_permutation(forward_iterator<const int*>(ia), 111 forward_iterator<const int*>(ia + sa), 112 forward_iterator<const int*>(ib), 113 forward_iterator<const int*>(ib + sa)) == false); 114 #endif 115 } 116 { 117 const int ia[] = {0, 0}; 118 const int ib[] = {1, 1}; 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)) == false); 123 #ifdef HAS_FOUR_ITERATOR_VERSION 124 assert(std::is_permutation(forward_iterator<const int*>(ia), 125 forward_iterator<const int*>(ia + sa), 126 forward_iterator<const int*>(ib), 127 forward_iterator<const int*>(ib + sa)) == false); 128 #endif 129 } 130 { 131 const int ia[] = {0, 1}; 132 const int ib[] = {0, 0}; 133 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 134 assert(std::is_permutation(forward_iterator<const int*>(ia), 135 forward_iterator<const int*>(ia + sa), 136 forward_iterator<const int*>(ib)) == false); 137 #ifdef HAS_FOUR_ITERATOR_VERSION 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)) == false); 142 #endif 143 } 144 { 145 const int ia[] = {0, 1}; 146 const int ib[] = {0, 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)) == true); 151 #ifdef HAS_FOUR_ITERATOR_VERSION 152 assert(std::is_permutation(forward_iterator<const int*>(ia), 153 forward_iterator<const int*>(ia + sa), 154 forward_iterator<const int*>(ib), 155 forward_iterator<const int*>(ib + sa)) == true); 156 assert(std::is_permutation(forward_iterator<const int*>(ia), 157 forward_iterator<const int*>(ia + sa), 158 forward_iterator<const int*>(ib), 159 forward_iterator<const int*>(ib + sa - 1)) == false); 160 #endif 161 } 162 { 163 const int ia[] = {0, 1}; 164 const int ib[] = {1, 0}; 165 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 166 assert(std::is_permutation(forward_iterator<const int*>(ia), 167 forward_iterator<const int*>(ia + sa), 168 forward_iterator<const int*>(ib)) == true); 169 #ifdef HAS_FOUR_ITERATOR_VERSION 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)) == true); 174 #endif 175 } 176 { 177 const int ia[] = {0, 1}; 178 const int ib[] = {1, 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)) == false); 183 #ifdef HAS_FOUR_ITERATOR_VERSION 184 assert(std::is_permutation(forward_iterator<const int*>(ia), 185 forward_iterator<const int*>(ia + sa), 186 forward_iterator<const int*>(ib), 187 forward_iterator<const int*>(ib + sa)) == false); 188 #endif 189 } 190 { 191 const int ia[] = {1, 0}; 192 const int ib[] = {0, 0}; 193 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 194 assert(std::is_permutation(forward_iterator<const int*>(ia), 195 forward_iterator<const int*>(ia + sa), 196 forward_iterator<const int*>(ib)) == false); 197 #ifdef HAS_FOUR_ITERATOR_VERSION 198 assert(std::is_permutation(forward_iterator<const int*>(ia), 199 forward_iterator<const int*>(ia + sa), 200 forward_iterator<const int*>(ib), 201 forward_iterator<const int*>(ib + sa)) == false); 202 #endif 203 } 204 { 205 const int ia[] = {1, 0}; 206 const int ib[] = {0, 1}; 207 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 208 assert(std::is_permutation(forward_iterator<const int*>(ia), 209 forward_iterator<const int*>(ia + sa), 210 forward_iterator<const int*>(ib)) == true); 211 #ifdef HAS_FOUR_ITERATOR_VERSION 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)) == true); 216 #endif 217 } 218 { 219 const int ia[] = {1, 0}; 220 const int ib[] = {1, 0}; 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)) == true); 225 #ifdef HAS_FOUR_ITERATOR_VERSION 226 assert(std::is_permutation(forward_iterator<const int*>(ia), 227 forward_iterator<const int*>(ia + sa), 228 forward_iterator<const int*>(ib), 229 forward_iterator<const int*>(ib + sa)) == true); 230 #endif 231 } 232 { 233 const int ia[] = {1, 0}; 234 const int ib[] = {1, 1}; 235 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 236 assert(std::is_permutation(forward_iterator<const int*>(ia), 237 forward_iterator<const int*>(ia + sa), 238 forward_iterator<const int*>(ib)) == false); 239 #ifdef HAS_FOUR_ITERATOR_VERSION 240 assert(std::is_permutation(forward_iterator<const int*>(ia), 241 forward_iterator<const int*>(ia + sa), 242 forward_iterator<const int*>(ib), 243 forward_iterator<const int*>(ib + sa)) == false); 244 #endif 245 } 246 { 247 const int ia[] = {1, 1}; 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)) == false); 253 #ifdef HAS_FOUR_ITERATOR_VERSION 254 assert(std::is_permutation(forward_iterator<const int*>(ia), 255 forward_iterator<const int*>(ia + sa), 256 forward_iterator<const int*>(ib), 257 forward_iterator<const int*>(ib + sa)) == false); 258 #endif 259 } 260 { 261 const int ia[] = {1, 1}; 262 const int ib[] = {0, 1}; 263 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 264 assert(std::is_permutation(forward_iterator<const int*>(ia), 265 forward_iterator<const int*>(ia + sa), 266 forward_iterator<const int*>(ib)) == false); 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)) == false); 272 #endif 273 } 274 { 275 const int ia[] = {1, 1}; 276 const int ib[] = {1, 0}; 277 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 278 assert(std::is_permutation(forward_iterator<const int*>(ia), 279 forward_iterator<const int*>(ia + sa), 280 forward_iterator<const int*>(ib)) == false); 281 #ifdef HAS_FOUR_ITERATOR_VERSION 282 assert(std::is_permutation(forward_iterator<const int*>(ia), 283 forward_iterator<const int*>(ia + sa), 284 forward_iterator<const int*>(ib), 285 forward_iterator<const int*>(ib + sa)) == false); 286 #endif 287 } 288 { 289 const int ia[] = {1, 1}; 290 const int ib[] = {1, 1}; 291 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 292 assert(std::is_permutation(forward_iterator<const int*>(ia), 293 forward_iterator<const int*>(ia + sa), 294 forward_iterator<const int*>(ib)) == true); 295 #ifdef HAS_FOUR_ITERATOR_VERSION 296 assert(std::is_permutation(forward_iterator<const int*>(ia), 297 forward_iterator<const int*>(ia + sa), 298 forward_iterator<const int*>(ib), 299 forward_iterator<const int*>(ib + sa)) == true); 300 #endif 301 } 302 303 { 304 const int ia[] = {0, 0, 0}; 305 const int ib[] = {1, 0, 0}; 306 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 307 assert(std::is_permutation(forward_iterator<const int*>(ia), 308 forward_iterator<const int*>(ia + sa), 309 forward_iterator<const int*>(ib)) == false); 310 #ifdef HAS_FOUR_ITERATOR_VERSION 311 assert(std::is_permutation(forward_iterator<const int*>(ia), 312 forward_iterator<const int*>(ia + sa), 313 forward_iterator<const int*>(ib), 314 forward_iterator<const int*>(ib + sa)) == false); 315 #endif 316 } 317 { 318 const int ia[] = {0, 0, 0}; 319 const int ib[] = {1, 0, 1}; 320 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 321 assert(std::is_permutation(forward_iterator<const int*>(ia), 322 forward_iterator<const int*>(ia + sa), 323 forward_iterator<const int*>(ib)) == false); 324 #ifdef HAS_FOUR_ITERATOR_VERSION 325 assert(std::is_permutation(forward_iterator<const int*>(ia), 326 forward_iterator<const int*>(ia + sa), 327 forward_iterator<const int*>(ib), 328 forward_iterator<const int*>(ib + sa)) == false); 329 #endif 330 } 331 { 332 const int ia[] = {0, 0, 0}; 333 const int ib[] = {1, 0, 2}; 334 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 335 assert(std::is_permutation(forward_iterator<const int*>(ia), 336 forward_iterator<const int*>(ia + sa), 337 forward_iterator<const int*>(ib)) == false); 338 #ifdef HAS_FOUR_ITERATOR_VERSION 339 assert(std::is_permutation(forward_iterator<const int*>(ia), 340 forward_iterator<const int*>(ia + sa), 341 forward_iterator<const int*>(ib), 342 forward_iterator<const int*>(ib + sa)) == false); 343 #endif 344 } 345 { 346 const int ia[] = {0, 0, 0}; 347 const int ib[] = {1, 1, 0}; 348 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 349 assert(std::is_permutation(forward_iterator<const int*>(ia), 350 forward_iterator<const int*>(ia + sa), 351 forward_iterator<const int*>(ib)) == false); 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)) == false); 357 #endif 358 } 359 { 360 const int ia[] = {0, 0, 0}; 361 const int ib[] = {1, 1, 1}; 362 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 363 assert(std::is_permutation(forward_iterator<const int*>(ia), 364 forward_iterator<const int*>(ia + sa), 365 forward_iterator<const int*>(ib)) == false); 366 #ifdef HAS_FOUR_ITERATOR_VERSION 367 assert(std::is_permutation(forward_iterator<const int*>(ia), 368 forward_iterator<const int*>(ia + sa), 369 forward_iterator<const int*>(ib), 370 forward_iterator<const int*>(ib + sa)) == false); 371 #endif 372 } 373 { 374 const int ia[] = {0, 0, 0}; 375 const int ib[] = {1, 1, 2}; 376 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 377 assert(std::is_permutation(forward_iterator<const int*>(ia), 378 forward_iterator<const int*>(ia + sa), 379 forward_iterator<const int*>(ib)) == false); 380 #ifdef HAS_FOUR_ITERATOR_VERSION 381 assert(std::is_permutation(forward_iterator<const int*>(ia), 382 forward_iterator<const int*>(ia + sa), 383 forward_iterator<const int*>(ib), 384 forward_iterator<const int*>(ib + sa)) == false); 385 #endif 386 } 387 { 388 const int ia[] = {0, 0, 0}; 389 const int ib[] = {1, 2, 0}; 390 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 391 assert(std::is_permutation(forward_iterator<const int*>(ia), 392 forward_iterator<const int*>(ia + sa), 393 forward_iterator<const int*>(ib)) == false); 394 #ifdef HAS_FOUR_ITERATOR_VERSION 395 assert(std::is_permutation(forward_iterator<const int*>(ia), 396 forward_iterator<const int*>(ia + sa), 397 forward_iterator<const int*>(ib), 398 forward_iterator<const int*>(ib + sa)) == false); 399 #endif 400 } 401 { 402 const int ia[] = {0, 0, 0}; 403 const int ib[] = {1, 2, 1}; 404 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 405 assert(std::is_permutation(forward_iterator<const int*>(ia), 406 forward_iterator<const int*>(ia + sa), 407 forward_iterator<const int*>(ib)) == false); 408 #ifdef HAS_FOUR_ITERATOR_VERSION 409 assert(std::is_permutation(forward_iterator<const int*>(ia), 410 forward_iterator<const int*>(ia + sa), 411 forward_iterator<const int*>(ib), 412 forward_iterator<const int*>(ib + sa)) == false); 413 #endif 414 } 415 { 416 const int ia[] = {0, 0, 0}; 417 const int ib[] = {1, 2, 2}; 418 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 419 assert(std::is_permutation(forward_iterator<const int*>(ia), 420 forward_iterator<const int*>(ia + sa), 421 forward_iterator<const int*>(ib)) == 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)) == false); 427 #endif 428 } 429 { 430 const int ia[] = {0, 0, 1}; 431 const int ib[] = {1, 0, 0}; 432 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 433 assert(std::is_permutation(forward_iterator<const int*>(ia), 434 forward_iterator<const int*>(ia + sa), 435 forward_iterator<const int*>(ib)) == true); 436 #ifdef HAS_FOUR_ITERATOR_VERSION 437 assert(std::is_permutation(forward_iterator<const int*>(ia), 438 forward_iterator<const int*>(ia + sa), 439 forward_iterator<const int*>(ib), 440 forward_iterator<const int*>(ib + sa)) == true); 441 assert(std::is_permutation(forward_iterator<const int*>(ia), 442 forward_iterator<const int*>(ia + sa), 443 forward_iterator<const int*>(ib), 444 forward_iterator<const int*>(ib + sa - 1)) == false); 445 #endif 446 } 447 { 448 const int ia[] = {0, 0, 1}; 449 const int ib[] = {1, 0, 1}; 450 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 451 assert(std::is_permutation(forward_iterator<const int*>(ia), 452 forward_iterator<const int*>(ia + sa), 453 forward_iterator<const int*>(ib)) == 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)) == false); 459 #endif 460 } 461 { 462 const int ia[] = {0, 1, 2}; 463 const int ib[] = {1, 0, 2}; 464 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 465 assert(std::is_permutation(forward_iterator<const int*>(ia), 466 forward_iterator<const int*>(ia + sa), 467 forward_iterator<const int*>(ib)) == true); 468 #ifdef HAS_FOUR_ITERATOR_VERSION 469 assert(std::is_permutation(forward_iterator<const int*>(ia), 470 forward_iterator<const int*>(ia + sa), 471 forward_iterator<const int*>(ib), 472 forward_iterator<const int*>(ib + sa)) == true); 473 assert(std::is_permutation(forward_iterator<const int*>(ia), 474 forward_iterator<const int*>(ia + sa), 475 forward_iterator<const int*>(ib), 476 forward_iterator<const int*>(ib + sa - 1)) == false); 477 #endif 478 } 479 { 480 const int ia[] = {0, 1, 2}; 481 const int ib[] = {1, 2, 0}; 482 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 483 assert(std::is_permutation(forward_iterator<const int*>(ia), 484 forward_iterator<const int*>(ia + sa), 485 forward_iterator<const int*>(ib)) == true); 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)) == true); 491 assert(std::is_permutation(forward_iterator<const int*>(ia), 492 forward_iterator<const int*>(ia + sa), 493 forward_iterator<const int*>(ib), 494 forward_iterator<const int*>(ib + sa - 1)) == false); 495 #endif 496 } 497 { 498 const int ia[] = {0, 1, 2}; 499 const int ib[] = {2, 1, 0}; 500 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 501 assert(std::is_permutation(forward_iterator<const int*>(ia), 502 forward_iterator<const int*>(ia + sa), 503 forward_iterator<const int*>(ib)) == true); 504 #ifdef HAS_FOUR_ITERATOR_VERSION 505 assert(std::is_permutation(forward_iterator<const int*>(ia), 506 forward_iterator<const int*>(ia + sa), 507 forward_iterator<const int*>(ib), 508 forward_iterator<const int*>(ib + sa)) == true); 509 assert(std::is_permutation(forward_iterator<const int*>(ia), 510 forward_iterator<const int*>(ia + sa), 511 forward_iterator<const int*>(ib), 512 forward_iterator<const int*>(ib + sa - 1)) == false); 513 #endif 514 } 515 { 516 const int ia[] = {0, 1, 2}; 517 const int ib[] = {2, 0, 1}; 518 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 519 assert(std::is_permutation(forward_iterator<const int*>(ia), 520 forward_iterator<const int*>(ia + sa), 521 forward_iterator<const int*>(ib)) == true); 522 #ifdef HAS_FOUR_ITERATOR_VERSION 523 assert(std::is_permutation(forward_iterator<const int*>(ia), 524 forward_iterator<const int*>(ia + sa), 525 forward_iterator<const int*>(ib), 526 forward_iterator<const int*>(ib + sa)) == true); 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 - 1)) == false); 531 #endif 532 } 533 { 534 const int ia[] = {0, 0, 1}; 535 const int ib[] = {1, 0, 1}; 536 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 537 assert(std::is_permutation(forward_iterator<const int*>(ia), 538 forward_iterator<const int*>(ia + sa), 539 forward_iterator<const int*>(ib)) == false); 540 #ifdef HAS_FOUR_ITERATOR_VERSION 541 assert(std::is_permutation(forward_iterator<const int*>(ia), 542 forward_iterator<const int*>(ia + sa), 543 forward_iterator<const int*>(ib), 544 forward_iterator<const int*>(ib + sa)) == false); 545 #endif 546 } 547 { 548 const int ia[] = {0, 0, 1}; 549 const int ib[] = {1, 0, 0}; 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)) == true); 554 #ifdef HAS_FOUR_ITERATOR_VERSION 555 assert(std::is_permutation(forward_iterator<const int*>(ia), 556 forward_iterator<const int*>(ia + sa), 557 forward_iterator<const int*>(ib), 558 forward_iterator<const int*>(ib + sa)) == true); 559 assert(std::is_permutation(forward_iterator<const int*>(ia), 560 forward_iterator<const int*>(ia + sa), 561 forward_iterator<const int*>(ib + 1), 562 forward_iterator<const int*>(ib + sa)) == false); 563 assert(std::is_permutation(forward_iterator<const int*>(ia), 564 forward_iterator<const int*>(ia + sa), 565 forward_iterator<const int*>(ib), 566 forward_iterator<const int*>(ib + sa - 1)) == false); 567 #endif 568 } 569 { 570 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4}; 571 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2}; 572 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 573 assert(std::is_permutation(forward_iterator<const int*>(ia), 574 forward_iterator<const int*>(ia + sa), 575 forward_iterator<const int*>(ib)) == 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)) == true); 581 assert(std::is_permutation(forward_iterator<const int*>(ia), 582 forward_iterator<const int*>(ia + sa), 583 forward_iterator<const int*>(ib + 1 ), 584 forward_iterator<const int*>(ib + sa)) == false); 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)) == false); 589 #endif 590 } 591 { 592 const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4}; 593 const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0}; 594 const unsigned sa = sizeof(ia)/sizeof(ia[0]); 595 assert(std::is_permutation(forward_iterator<const int*>(ia), 596 forward_iterator<const int*>(ia + sa), 597 forward_iterator<const int*>(ib)) == false); 598 #ifdef HAS_FOUR_ITERATOR_VERSION 599 assert(std::is_permutation(forward_iterator<const int*>(ia), 600 forward_iterator<const int*>(ia + sa), 601 forward_iterator<const int*>(ib), 602 forward_iterator<const int*>(ib + sa)) == false); 603 #endif 604 } 605 } 606
