1 //===----------------------------------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // <algorithm>
11 
12 // template <class InputIterator, class Predicate>
13 //     bool
14 //     is_partitioned(InputIterator first, InputIterator last, Predicate pred);
15 
16 #include <algorithm>
17 #include <functional>
18 #include <cassert>
19 
20 #include "test_iterators.h"
21 #include "counting_predicates.hpp"
22 
23 struct is_odd
24 {
25     bool operator()(const int& i) const {return i & 1;}
26 };
27 
28 int main()
29 {
30     {
31         const int ia[] = {1, 2, 3, 4, 5, 6};
32         unary_counting_predicate<is_odd, int> pred((is_odd()));
33         assert(!std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
34                                     input_iterator<const int*>(std::end(ia)),
35                                     std::ref(pred)));
36         assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
37     }
38     {
39         const int ia[] = {1, 3, 5, 2, 4, 6};
40         unary_counting_predicate<is_odd, int> pred((is_odd()));
41         assert( std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
42                                     input_iterator<const int*>(std::end(ia)),
43                                     std::ref(pred)));
44         assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
45     }
46     {
47         const int ia[] = {2, 4, 6, 1, 3, 5};
48         unary_counting_predicate<is_odd, int> pred((is_odd()));
49         assert(!std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
50                                     input_iterator<const int*>(std::end(ia)),
51                                     std::ref(pred)));
52         assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
53     }
54     {
55         const int ia[] = {1, 3, 5, 2, 4, 6, 7};
56         unary_counting_predicate<is_odd, int> pred((is_odd()));
57         assert(!std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
58                                     input_iterator<const int*>(std::end(ia)),
59                                     std::ref(pred)));
60         assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
61     }
62     {
63         const int ia[] = {1, 3, 5, 2, 4, 6, 7};
64         unary_counting_predicate<is_odd, int> pred((is_odd()));
65         assert( std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
66                                     input_iterator<const int*>(std::begin(ia)),
67                                     std::ref(pred)));
68         assert(pred.count() <= std::distance(std::begin(ia), std::begin(ia)));
69     }
70     {
71         const int ia[] = {1, 3, 5, 7, 9, 11, 2};
72         unary_counting_predicate<is_odd, int> pred((is_odd()));
73         assert( std::is_partitioned(input_iterator<const int*>(std::begin(ia)),
74                                     input_iterator<const int*>(std::end(ia)),
75                                     std::ref(pred)));
76         assert(pred.count() <= std::distance(std::begin(ia), std::end(ia)));
77     }
78 }
79