diff options
Diffstat (limited to 'test/std/algorithms/alg.nonmodifying/alg.is_permutation')
| -rw-r--r-- | test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp | 605 | ||||
| -rw-r--r-- | test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp | 729 |
2 files changed, 1334 insertions, 0 deletions
diff --git a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp new file mode 100644 index 000000000000..028aec5e7f29 --- /dev/null +++ b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp @@ -0,0 +1,605 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<class ForwardIterator1, class ForwardIterator2> +// bool +// is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, +// ForwardIterator2 first2); + +#include <algorithm> +#include <cassert> + +#include "test_iterators.h" + +#if _LIBCPP_STD_VER > 11 +#define HAS_FOUR_ITERATOR_VERSION +#endif + +int main() +{ + { + const int ia[] = {0}; + const int ib[] = {0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + 0), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + 0), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + 0)) == true); +#endif + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0}; + const int ib[] = {1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + + { + const int ia[] = {0, 0}; + const int ib[] = {0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 0}; + const int ib[] = {0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0}; + const int ib[] = {1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0}; + const int ib[] = {1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 1}; + const int ib[] = {0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 1}; + const int ib[] = {0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 1}; + const int ib[] = {1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); +#endif + } + { + const int ia[] = {0, 1}; + const int ib[] = {1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {1, 0}; + const int ib[] = {0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {1, 0}; + const int ib[] = {0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); +#endif + } + { + const int ia[] = {1, 0}; + const int ib[] = {1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); +#endif + } + { + const int ia[] = {1, 0}; + const int ib[] = {1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {1, 1}; + const int ib[] = {0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {1, 1}; + const int ib[] = {0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {1, 1}; + const int ib[] = {1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {1, 1}; + const int ib[] = {1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); +#endif + } + + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 0, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 1, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 2, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 2, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 2, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 1}; + const int ib[] = {1, 0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 0, 1}; + const int ib[] = {1, 0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 1, 2}; + const int ib[] = {1, 0, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 1, 2}; + const int ib[] = {1, 2, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 1, 2}; + const int ib[] = {2, 1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 1, 2}; + const int ib[] = {2, 0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 0, 1}; + const int ib[] = {1, 0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } + { + const int ia[] = {0, 0, 1}; + const int ib[] = {1, 0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib + 1), + forward_iterator<const int*>(ib + sa)) == false); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4}; + const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib + 1 ), + forward_iterator<const int*>(ib + sa)) == false); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1)) == false); +#endif + } + { + const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4}; + const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa)) == false); +#endif + } +} diff --git a/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp new file mode 100644 index 000000000000..ceb897da5148 --- /dev/null +++ b/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp @@ -0,0 +1,729 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> +// bool +// is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, +// ForwardIterator2 first2, BinaryPredicate pred); + +#include <algorithm> +#include <functional> +#include <cassert> + +#include "test_iterators.h" + +#if _LIBCPP_STD_VER > 11 +#define HAS_FOUR_ITERATOR_VERSION +#endif + +int comparison_count = 0; +template <typename T> +bool counting_equals ( const T &a, const T &b ) { + ++comparison_count; + return a == b; + } + + +int main() +{ + { + const int ia[] = {0}; + const int ib[] = {0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + 0), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0}; + const int ib[] = {1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + + { + const int ia[] = {0, 0}; + const int ib[] = {0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0}; + const int ib[] = {0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0}; + const int ib[] = {1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0}; + const int ib[] = {1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1}; + const int ib[] = {0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1}; + const int ib[] = {0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1}; + const int ib[] = {1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1}; + const int ib[] = {1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {1, 0}; + const int ib[] = {0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {1, 0}; + const int ib[] = {0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {1, 0}; + const int ib[] = {1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {1, 0}; + const int ib[] = {1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {1, 1}; + const int ib[] = {0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {1, 1}; + const int ib[] = {0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {1, 1}; + const int ib[] = {1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {1, 1}; + const int ib[] = {1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 0, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 1, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 1, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 2, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 2, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 0}; + const int ib[] = {1, 2, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 1}; + const int ib[] = {1, 0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 1}; + const int ib[] = {1, 0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1, 2}; + const int ib[] = {1, 0, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1, 2}; + const int ib[] = {1, 2, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1, 2}; + const int ib[] = {2, 1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1, 2}; + const int ib[] = {2, 0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 1}; + const int ib[] = {1, 0, 1}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 0, 1}; + const int ib[] = {1, 0, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib + 1), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); +#endif + } + { + const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4}; + const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 2}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == true); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == true); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib + 1), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + std::equal_to<const int>()) == false); + comparison_count = 0; + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa - 1), + counting_equals<const int>) == false); + assert ( comparison_count > 0 ); + comparison_count = 0; + assert(std::is_permutation(random_access_iterator<const int*>(ia), + random_access_iterator<const int*>(ia + sa), + random_access_iterator<const int*>(ib), + random_access_iterator<const int*>(ib + sa - 1), + counting_equals<const int>) == false); + assert ( comparison_count == 0 ); +#endif + } + { + const int ia[] = {0, 1, 2, 3, 0, 5, 6, 2, 4, 4}; + const int ib[] = {4, 2, 3, 0, 1, 4, 0, 5, 6, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + std::equal_to<const int>()) == false); +#ifdef HAS_FOUR_ITERATOR_VERSION + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sa), + std::equal_to<const int>()) == false); +#endif + } +} |