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 26int 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