diff options
Diffstat (limited to 'libcxx/test/algorithms/alg.nonmodifying')
24 files changed, 1713 insertions, 0 deletions
diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp new file mode 100644 index 00000000000..467af8b8912 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp @@ -0,0 +1,35 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<ForwardIterator Iter> +// requires EqualityComparable<Iter::value_type> +// Iter +// adjacent_find(Iter first, Iter last); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::adjacent_find(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa)) == + forward_iterator<const int*>(ia+2)); + assert(std::adjacent_find(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia)) == + forward_iterator<const int*>(ia)); + assert(std::adjacent_find(forward_iterator<const int*>(ia+3), + forward_iterator<const int*>(ia + sa)) == + forward_iterator<const int*>(ia+sa)); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp new file mode 100644 index 00000000000..db061a703f0 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred> +// requires CopyConstructible<Pred> +// Iter +// adjacent_find(Iter first, Iter last, Pred pred); + +#include <algorithm> +#include <functional> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::adjacent_find(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + std::equal_to<int>()) == + forward_iterator<const int*>(ia+2)); + assert(std::adjacent_find(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia), + std::equal_to<int>()) == + forward_iterator<const int*>(ia)); + assert(std::adjacent_find(forward_iterator<const int*>(ia+3), + forward_iterator<const int*>(ia + sa), + std::equal_to<int>()) == + forward_iterator<const int*>(ia+sa)); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp new file mode 100644 index 00000000000..9744036f134 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp @@ -0,0 +1,47 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template <class InputIterator, class Predicate> +// bool +// all_of(InputIterator first, InputIterator last, Predicate pred); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +struct test1 +{ + bool operator()(const int& i) const + { + return i % 2 == 0; + } +}; + +int main() +{ + { + int ia[] = {2, 4, 6, 8}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::all_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), test1()) == true); + assert(std::all_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), test1()) == true); + } + { + const int ia[] = {2, 4, 5, 8}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::all_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), test1()) == false); + assert(std::all_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), test1()) == true); + } +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp new file mode 100644 index 00000000000..bedd3a4bc3b --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template <class InputIterator, class Predicate> +// bool +// any_of(InputIterator first, InputIterator last, Predicate pred); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +struct test1 +{ + bool operator()(const int& i) const + { + return i % 2 == 0; + } +}; + +int main() +{ + { + int ia[] = {2, 4, 6, 8}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::any_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), test1()) == true); + assert(std::any_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), test1()) == false); + } + { + const int ia[] = {2, 4, 5, 8}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::any_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), test1()) == true); + assert(std::any_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), test1()) == false); + } + { + const int ia[] = {1, 3, 5, 7}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::any_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), test1()) == false); + assert(std::any_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), test1()) == false); + } +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.count/count.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.count/count.pass.cpp new file mode 100644 index 00000000000..47356bc1d4e --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.count/count.pass.cpp @@ -0,0 +1,32 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter, class T> +// requires HasEqualTo<Iter::value_type, T> +// Iter::difference_type +// count(Iter first, Iter last, const T& value); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::count(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), 2) == 3); + assert(std::count(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), 7) == 0); + assert(std::count(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), 2) == 0); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp new file mode 100644 index 00000000000..f1a4e13365f --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred> +// requires CopyConstructible<Pred> +// Iter::difference_type +// count_if(Iter first, Iter last, Pred pred); + +#include <algorithm> +#include <functional> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::count_if(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + std::bind2nd(std::equal_to<int>(),2)) == 3); + assert(std::count_if(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + std::bind2nd(std::equal_to<int>(),7)) == 0); + assert(std::count_if(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), + std::bind2nd(std::equal_to<int>(),2)) == 0); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp new file mode 100644 index 00000000000..a8995d2f5d4 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter1, InputIterator Iter2> +// requires HasEqualTo<Iter1::value_type, Iter2::value_type> +// bool +// equal(Iter1 first1, Iter1 last1, Iter2 first2); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 3, 4, 5}; + const unsigned s = sizeof(ia)/sizeof(ia[0]); + int ib[s] = {0, 1, 2, 5, 4, 5}; + assert(std::equal(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), + input_iterator<const int*>(ia))); + assert(!std::equal(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), + input_iterator<const int*>(ib))); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp new file mode 100644 index 00000000000..5769515fb50 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter1, InputIterator Iter2, +// Predicate<auto, Iter1::value_type, Iter2::value_type> Pred> +// requires CopyConstructible<Pred> +// bool +// equal(Iter1 first1, Iter1 last1, Iter2 first2, Pred pred); + +#include <algorithm> +#include <functional> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 3, 4, 5}; + const unsigned s = sizeof(ia)/sizeof(ia[0]); + int ib[s] = {0, 1, 2, 5, 4, 5}; + assert(std::equal(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), + input_iterator<const int*>(ia), + std::equal_to<int>())); + assert(!std::equal(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), + input_iterator<const int*>(ib), + std::equal_to<int>())); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp new file mode 100644 index 00000000000..afce49a4dff --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<ForwardIterator Iter1, ForwardIterator Iter2> +// requires HasEqualTo<Iter1::value_type, Iter2::value_type> +// Iter1 +// find_end(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +template <class Iter1, class Iter2> +void +test() +{ + int ia[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + int b[] = {0}; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(b), Iter2(b+1)) == Iter1(ia+sa-1)); + int c[] = {0, 1}; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(c), Iter2(c+2)) == Iter1(ia+18)); + int d[] = {0, 1, 2}; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(d), Iter2(d+3)) == Iter1(ia+15)); + int e[] = {0, 1, 2, 3}; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(e), Iter2(e+4)) == Iter1(ia+11)); + int f[] = {0, 1, 2, 3, 4}; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(f), Iter2(f+5)) == Iter1(ia+6)); + int g[] = {0, 1, 2, 3, 4, 5}; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(g), Iter2(g+6)) == Iter1(ia)); + int h[] = {0, 1, 2, 3, 4, 5, 6}; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(h), Iter2(h+7)) == Iter1(ia+sa)); + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(b), Iter2(b)) == Iter1(ia+sa)); + assert(std::find_end(Iter1(ia), Iter1(ia), Iter2(b), Iter2(b+1)) == Iter1(ia)); +} + +int main() +{ + test<forward_iterator<const int*>, forward_iterator<const int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<forward_iterator<const int*>, random_access_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); + test<random_access_iterator<const int*>, forward_iterator<const int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp new file mode 100644 index 00000000000..de3037d31f6 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp @@ -0,0 +1,86 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<ForwardIterator Iter1, ForwardIterator Iter2, +// Predicate<auto, Iter1::value_type, Iter2::value_type> Pred> +// requires CopyConstructible<Pred> +// Iter1 +// find_end(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +struct count_equal +{ + static unsigned count; + template <class T> + bool operator()(const T& x, const T& y) + {++count; return x == y;} +}; + +unsigned count_equal::count = 0; + +template <class Iter1, class Iter2> +void +test() +{ + int ia[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + int b[] = {0}; + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(b), Iter2(b+1), count_equal()) == Iter1(ia+sa-1)); + assert(count_equal::count <= 1*(sa-1+1)); + int c[] = {0, 1}; + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(c), Iter2(c+2), count_equal()) == Iter1(ia+18)); + assert(count_equal::count <= 2*(sa-2+1)); + int d[] = {0, 1, 2}; + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(d), Iter2(d+3), count_equal()) == Iter1(ia+15)); + assert(count_equal::count <= 3*(sa-3+1)); + int e[] = {0, 1, 2, 3}; + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(e), Iter2(e+4), count_equal()) == Iter1(ia+11)); + assert(count_equal::count <= 4*(sa-4+1)); + int f[] = {0, 1, 2, 3, 4}; + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(f), Iter2(f+5), count_equal()) == Iter1(ia+6)); + assert(count_equal::count <= 5*(sa-5+1)); + int g[] = {0, 1, 2, 3, 4, 5}; + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(g), Iter2(g+6), count_equal()) == Iter1(ia)); + assert(count_equal::count <= 6*(sa-6+1)); + int h[] = {0, 1, 2, 3, 4, 5, 6}; + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(h), Iter2(h+7), count_equal()) == Iter1(ia+sa)); + assert(count_equal::count <= 7*(sa-7+1)); + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia+sa), Iter2(b), Iter2(b), count_equal()) == Iter1(ia+sa)); + assert(count_equal::count <= 0); + count_equal::count = 0; + assert(std::find_end(Iter1(ia), Iter1(ia), Iter2(b), Iter2(b+1), count_equal()) == Iter1(ia)); + assert(count_equal::count <= 0); +} + +int main() +{ + test<forward_iterator<const int*>, forward_iterator<const int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<forward_iterator<const int*>, random_access_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); + test<random_access_iterator<const int*>, forward_iterator<const int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp new file mode 100644 index 00000000000..c478b580e85 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp @@ -0,0 +1,49 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter1, ForwardIterator Iter2> +// requires HasEqualTo<Iter1::value_type, Iter2::value_type> +// Iter1 +// find_first_of(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 3, 0, 1, 2, 3}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + int ib[] = {1, 3, 5, 7}; + const unsigned sb = sizeof(ib)/sizeof(ib[0]); + assert(std::find_first_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sb)) == + input_iterator<const int*>(ia+1)); + int ic[] = {7}; + assert(std::find_first_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ic), + forward_iterator<const int*>(ic + 1)) == + input_iterator<const int*>(ia+sa)); + assert(std::find_first_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ic), + forward_iterator<const int*>(ic)) == + input_iterator<const int*>(ia+sa)); + assert(std::find_first_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), + forward_iterator<const int*>(ic), + forward_iterator<const int*>(ic+1)) == + input_iterator<const int*>(ia)); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp new file mode 100644 index 00000000000..7f8262400e9 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter1, ForwardIterator Iter2, +// Predicate<auto, Iter1::value_type, Iter2::value_type> Pred> +// requires CopyConstructible<Pred> +// Iter1 +// find_first_of(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred); + +#include <algorithm> +#include <functional> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 3, 0, 1, 2, 3}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + int ib[] = {1, 3, 5, 7}; + const unsigned sb = sizeof(ib)/sizeof(ib[0]); + assert(std::find_first_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib), + forward_iterator<const int*>(ib + sb), + std::equal_to<int>()) == + input_iterator<const int*>(ia+1)); + int ic[] = {7}; + assert(std::find_first_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ic), + forward_iterator<const int*>(ic + 1), + std::equal_to<int>()) == + input_iterator<const int*>(ia+sa)); + assert(std::find_first_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ic), + forward_iterator<const int*>(ic), + std::equal_to<int>()) == + input_iterator<const int*>(ia+sa)); + assert(std::find_first_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), + forward_iterator<const int*>(ic), + forward_iterator<const int*>(ic+1), + std::equal_to<int>()) == + input_iterator<const int*>(ia)); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.find/find.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.find/find.pass.cpp new file mode 100644 index 00000000000..13fdaca9bd4 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.find/find.pass.cpp @@ -0,0 +1,31 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter, class T> +// requires HasEqualTo<Iter::value_type, T> +// Iter +// find(Iter first, Iter last, const T& value); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 3, 4, 5}; + const unsigned s = sizeof(ia)/sizeof(ia[0]); + input_iterator<const int*> r = std::find(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), 3); + assert(*r == 3); + r = std::find(input_iterator<const int*>(ia), input_iterator<const int*>(ia+s), 10); + assert(r == input_iterator<const int*>(ia+s)); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp new file mode 100644 index 00000000000..fb46d1418ed --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp @@ -0,0 +1,35 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred> +// requires CopyConstructible<Pred> +// Iter +// find_if(Iter first, Iter last, Pred pred); + +#include <algorithm> +#include <functional> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 3, 4, 5}; + const unsigned s = sizeof(ia)/sizeof(ia[0]); + input_iterator<const int*> r = std::find_if(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), + std::bind2nd(std::equal_to<int>(), 3)); + assert(*r == 3); + r = std::find_if(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), + std::bind2nd(std::equal_to<int>(), 10)); + assert(r == input_iterator<const int*>(ia+s)); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp new file mode 100644 index 00000000000..6f5e754c2b8 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp @@ -0,0 +1,35 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter, Predicate<auto, Iter::value_type> Pred> +// requires CopyConstructible<Pred> +// Iter +// find_if_not(Iter first, Iter last, Pred pred); + +#include <algorithm> +#include <functional> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 3, 4, 5}; + const unsigned s = sizeof(ia)/sizeof(ia[0]); + input_iterator<const int*> r = std::find_if_not(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), + std::bind2nd(std::not_equal_to<int>(), 3)); + assert(*r == 3); + r = std::find_if_not(input_iterator<const int*>(ia), + input_iterator<const int*>(ia+s), + std::bind2nd(std::not_equal_to<int>(), 10)); + assert(r == input_iterator<const int*>(ia+s)); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp new file mode 100644 index 00000000000..57a9abb187d --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter, Callable<auto, Iter::reference> Function> +// requires CopyConstructible<Function> +// Function +// for_each(Iter first, Iter last, Function f); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +struct for_each_test +{ + for_each_test(int c) : count(c) {} + int count; + void operator()(int& i) {++i; ++count;} +}; + +int main() +{ + int ia[] = {0, 1, 2, 3, 4, 5}; + const unsigned s = sizeof(ia)/sizeof(ia[0]); + for_each_test f = std::for_each(input_iterator<int*>(ia), + input_iterator<int*>(ia+s), + for_each_test(0)); + assert(f.count == s); + for (unsigned i = 0; i < s; ++i) + assert(ia[i] == i+1); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp new file mode 100644 index 00000000000..fec64298931 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp @@ -0,0 +1,325 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. 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 "../../iterators.h" + +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); + assert(std::is_permutation(forward_iterator<const int*>(ia), + forward_iterator<const int*>(ia + sa), + forward_iterator<const int*>(ib)) == true); + } + { + 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); + } + + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp new file mode 100644 index 00000000000..c2027938ef2 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp @@ -0,0 +1,364 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. 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 "../../iterators.h" + +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); + } + { + 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); + } + + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } + { + 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); + } +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp new file mode 100644 index 00000000000..a4c9715db17 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template <class InputIterator, class Predicate> +// bool +// none_of(InputIterator first, InputIterator last, Predicate pred); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +struct test1 +{ + bool operator()(const int& i) const + { + return i % 2 == 0; + } +}; + +int main() +{ + { + int ia[] = {2, 4, 6, 8}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::none_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), test1()) == false); + assert(std::none_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), test1()) == true); + } + { + const int ia[] = {2, 4, 5, 8}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::none_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), test1()) == false); + assert(std::none_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), test1()) == true); + } + { + const int ia[] = {1, 3, 5, 7}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::none_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), test1()) == true); + assert(std::none_of(input_iterator<const int*>(ia), + input_iterator<const int*>(ia), test1()) == true); + } +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.search/search.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.search/search.pass.cpp new file mode 100644 index 00000000000..b7312816109 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.search/search.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<ForwardIterator Iter1, ForwardIterator Iter2> +// requires HasEqualTo<Iter1::value_type, Iter2::value_type> +// Iter1 +// search(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +template <class Iter1, class Iter2> +void +test() +{ + int ia[] = {0, 1, 2, 3, 4, 5}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia)) == Iter1(ia)); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1)) == Iter1(ia)); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2)) == Iter1(ia+1)); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2)) == Iter1(ia)); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia+2)); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia+2)); + assert(std::search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3)) == Iter1(ia)); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa)) == Iter1(ia+sa-1)); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa)) == Iter1(ia+sa-3)); + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa)) == Iter1(ia)); + assert(std::search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa)) == Iter1(ia+sa-1)); + assert(std::search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa)) == Iter1(ia+1)); + int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; + const unsigned sb = sizeof(ib)/sizeof(ib[0]); + int ic[] = {1}; + assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1)) == Iter1(ib+1)); + int id[] = {1, 2}; + assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2)) == Iter1(ib+1)); + int ie[] = {1, 2, 3}; + assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3)) == Iter1(ib+4)); + int ig[] = {1, 2, 3, 4}; + assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4)) == Iter1(ib+8)); + int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; + const unsigned sh = sizeof(ih)/sizeof(ih[0]); + int ii[] = {1, 1, 2}; + assert(std::search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3)) == Iter1(ih+3)); + int ij[] = {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; + const unsigned sj = sizeof(ij)/sizeof(ij[0]); + int ik[] = {0, 0, 0, 0, 1, 1, 1, 1, 0, 0}; + const unsigned sk = sizeof(ik)/sizeof(ik[0]); + assert(std::search(Iter1(ij), Iter1(ij+sj), Iter2(ik), Iter2(ik+sk)) == Iter1(ij+6)); +} + +int main() +{ + test<forward_iterator<const int*>, forward_iterator<const int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<forward_iterator<const int*>, random_access_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); + test<random_access_iterator<const int*>, forward_iterator<const int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp new file mode 100644 index 00000000000..a8353e83b50 --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp @@ -0,0 +1,111 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<ForwardIterator Iter1, ForwardIterator Iter2> +// requires HasEqualTo<Iter1::value_type, Iter2::value_type> +// Iter1 +// search(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +struct count_equal +{ + static unsigned count; + template <class T> + bool operator()(const T& x, const T& y) + {++count; return x == y;} +}; + +unsigned count_equal::count = 0; + +template <class Iter1, class Iter2> +void +test() +{ + int ia[] = {0, 1, 2, 3, 4, 5}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia), count_equal()) == Iter1(ia)); + assert(count_equal::count <= 0); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+1), count_equal()) == Iter1(ia)); + assert(count_equal::count <= sa); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+1), Iter2(ia+2), count_equal()) == Iter1(ia+1)); + assert(count_equal::count <= sa); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+2), count_equal()) == Iter1(ia)); + assert(count_equal::count <= 0); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), count_equal()) == Iter1(ia+2)); + assert(count_equal::count <= sa); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+2), Iter2(ia+3), count_equal()) == Iter1(ia+2)); + assert(count_equal::count <= sa); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia), Iter2(ia+2), Iter2(ia+3), count_equal()) == Iter1(ia)); + assert(count_equal::count <= 0); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-1), Iter2(ia+sa), count_equal()) == Iter1(ia+sa-1)); + assert(count_equal::count <= sa); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia+sa-3), Iter2(ia+sa), count_equal()) == Iter1(ia+sa-3)); + assert(count_equal::count <= sa*3); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa), Iter2(ia), Iter2(ia+sa), count_equal()) == Iter1(ia)); + assert(count_equal::count <= sa*sa); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+sa-1), Iter2(ia), Iter2(ia+sa), count_equal()) == Iter1(ia+sa-1)); + assert(count_equal::count <= (sa-1)*sa); + count_equal::count = 0; + assert(std::search(Iter1(ia), Iter1(ia+1), Iter2(ia), Iter2(ia+sa), count_equal()) == Iter1(ia+1)); + assert(count_equal::count <= sa); + count_equal::count = 0; + int ib[] = {0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4}; + const unsigned sb = sizeof(ib)/sizeof(ib[0]); + int ic[] = {1}; + assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ic), Iter2(ic+1), count_equal()) == Iter1(ib+1)); + assert(count_equal::count <= sb); + count_equal::count = 0; + int id[] = {1, 2}; + assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(id), Iter2(id+2), count_equal()) == Iter1(ib+1)); + assert(count_equal::count <= sb*2); + count_equal::count = 0; + int ie[] = {1, 2, 3}; + assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ie), Iter2(ie+3), count_equal()) == Iter1(ib+4)); + assert(count_equal::count <= sb*3); + count_equal::count = 0; + int ig[] = {1, 2, 3, 4}; + assert(std::search(Iter1(ib), Iter1(ib+sb), Iter2(ig), Iter2(ig+4), count_equal()) == Iter1(ib+8)); + assert(count_equal::count <= sb*4); + count_equal::count = 0; + int ih[] = {0, 1, 1, 1, 1, 2, 3, 0, 1, 2, 3, 4}; + const unsigned sh = sizeof(ih)/sizeof(ih[0]); + int ii[] = {1, 1, 2}; + assert(std::search(Iter1(ih), Iter1(ih+sh), Iter2(ii), Iter2(ii+3), count_equal()) == Iter1(ih+3)); + assert(count_equal::count <= sh*3); +} + +int main() +{ + test<forward_iterator<const int*>, forward_iterator<const int*> >(); + test<forward_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<forward_iterator<const int*>, random_access_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, forward_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<bidirectional_iterator<const int*>, random_access_iterator<const int*> >(); + test<random_access_iterator<const int*>, forward_iterator<const int*> >(); + test<random_access_iterator<const int*>, bidirectional_iterator<const int*> >(); + test<random_access_iterator<const int*>, random_access_iterator<const int*> >(); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp new file mode 100644 index 00000000000..aedbd4f4f0e --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter1, InputIterator Iter2> +// requires HasEqualTo<Iter1::value_type, Iter2::value_type> +// pair<Iter1, Iter2> +// mismatch(Iter1 first1, Iter1 last1, Iter2 first2); + +#include <algorithm> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + int ib[] = {0, 1, 2, 3, 0, 1, 2, 3}; + assert(std::mismatch(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + input_iterator<const int*>(ib)) == + (std::pair<input_iterator<const int*>, + input_iterator<const int*> >( + input_iterator<const int*>(ia+3), + input_iterator<const int*>(ib+3)))); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp new file mode 100644 index 00000000000..2705ca2b46b --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <algorithm> + +// template<InputIterator Iter1, InputIterator Iter2, +// Predicate<auto, Iter1::value_type, Iter2::value_type> Pred> +// requires CopyConstructible<Pred> +// pair<Iter1, Iter2> +// mismatch(Iter1 first1, Iter1 last1, Iter2 first2, Pred pred); + +#include <algorithm> +#include <functional> +#include <cassert> + +#include "../../iterators.h" + +int main() +{ + int ia[] = {0, 1, 2, 2, 0, 1, 2, 3}; + const unsigned sa = sizeof(ia)/sizeof(ia[0]); + int ib[] = {0, 1, 2, 3, 0, 1, 2, 3}; + assert(std::mismatch(input_iterator<const int*>(ia), + input_iterator<const int*>(ia + sa), + input_iterator<const int*>(ib), + std::equal_to<int>()) == + (std::pair<input_iterator<const int*>, + input_iterator<const int*> >( + input_iterator<const int*>(ia+3), + input_iterator<const int*>(ib+3)))); + assert(std::mismatch(ia, ia + sa, ib, std::equal_to<int>()) == + (std::pair<int*,int*>(ia+3,ib+3))); +} diff --git a/libcxx/test/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp b/libcxx/test/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..fa4d462f18d --- /dev/null +++ b/libcxx/test/algorithms/alg.nonmodifying/nothing_to_do.pass.cpp @@ -0,0 +1,12 @@ +//===----------------------------------------------------------------------===// +// +// ΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚΚThe LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +int main() +{ +} |
