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<ForwardIterator Iter, StrictWeakOrder<auto, Iter::value_type> Compare>
13 //   requires CopyConstructible<Compare>
14 //   bool
15 //   is_sorted(Iter first, Iter last, Compare comp);
16 
17 #include <algorithm>
18 #include <functional>
19 #include <cassert>
20 
21 #include "test_iterators.h"
22 
23 template <class Iter>
24 void
test()25 test()
26 {
27     {
28     int a[] = {0};
29     unsigned sa = sizeof(a) / sizeof(a[0]);
30     assert(std::is_sorted(Iter(a), Iter(a)));
31     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
32     }
33 
34     {
35     int a[] = {0, 0};
36     unsigned sa = sizeof(a) / sizeof(a[0]);
37     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
38     }
39     {
40     int a[] = {0, 1};
41     unsigned sa = sizeof(a) / sizeof(a[0]);
42     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
43     }
44     {
45     int a[] = {1, 0};
46     unsigned sa = sizeof(a) / sizeof(a[0]);
47     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
48     }
49     {
50     int a[] = {1, 1};
51     unsigned sa = sizeof(a) / sizeof(a[0]);
52     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
53     }
54 
55     {
56     int a[] = {0, 0, 0};
57     unsigned sa = sizeof(a) / sizeof(a[0]);
58     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
59     }
60     {
61     int a[] = {0, 0, 1};
62     unsigned sa = sizeof(a) / sizeof(a[0]);
63     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
64     }
65     {
66     int a[] = {0, 1, 0};
67     unsigned sa = sizeof(a) / sizeof(a[0]);
68     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
69     }
70     {
71     int a[] = {0, 1, 1};
72     unsigned sa = sizeof(a) / sizeof(a[0]);
73     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
74     }
75     {
76     int a[] = {1, 0, 0};
77     unsigned sa = sizeof(a) / sizeof(a[0]);
78     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
79     }
80     {
81     int a[] = {1, 0, 1};
82     unsigned sa = sizeof(a) / sizeof(a[0]);
83     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
84     }
85     {
86     int a[] = {1, 1, 0};
87     unsigned sa = sizeof(a) / sizeof(a[0]);
88     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
89     }
90     {
91     int a[] = {1, 1, 1};
92     unsigned sa = sizeof(a) / sizeof(a[0]);
93     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
94     }
95 
96     {
97     int a[] = {0, 0, 0, 0};
98     unsigned sa = sizeof(a) / sizeof(a[0]);
99     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
100     }
101     {
102     int a[] = {0, 0, 0, 1};
103     unsigned sa = sizeof(a) / sizeof(a[0]);
104     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
105     }
106     {
107     int a[] = {0, 0, 1, 0};
108     unsigned sa = sizeof(a) / sizeof(a[0]);
109     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
110     }
111     {
112     int a[] = {0, 0, 1, 1};
113     unsigned sa = sizeof(a) / sizeof(a[0]);
114     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
115     }
116     {
117     int a[] = {0, 1, 0, 0};
118     unsigned sa = sizeof(a) / sizeof(a[0]);
119     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
120     }
121     {
122     int a[] = {0, 1, 0, 1};
123     unsigned sa = sizeof(a) / sizeof(a[0]);
124     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
125     }
126     {
127     int a[] = {0, 1, 1, 0};
128     unsigned sa = sizeof(a) / sizeof(a[0]);
129     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
130     }
131     {
132     int a[] = {0, 1, 1, 1};
133     unsigned sa = sizeof(a) / sizeof(a[0]);
134     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
135     }
136     {
137     int a[] = {1, 0, 0, 0};
138     unsigned sa = sizeof(a) / sizeof(a[0]);
139     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
140     }
141     {
142     int a[] = {1, 0, 0, 1};
143     unsigned sa = sizeof(a) / sizeof(a[0]);
144     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
145     }
146     {
147     int a[] = {1, 0, 1, 0};
148     unsigned sa = sizeof(a) / sizeof(a[0]);
149     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
150     }
151     {
152     int a[] = {1, 0, 1, 1};
153     unsigned sa = sizeof(a) / sizeof(a[0]);
154     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
155     }
156     {
157     int a[] = {1, 1, 0, 0};
158     unsigned sa = sizeof(a) / sizeof(a[0]);
159     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
160     }
161     {
162     int a[] = {1, 1, 0, 1};
163     unsigned sa = sizeof(a) / sizeof(a[0]);
164     assert(!std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
165     }
166     {
167     int a[] = {1, 1, 1, 0};
168     unsigned sa = sizeof(a) / sizeof(a[0]);
169     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
170     }
171     {
172     int a[] = {1, 1, 1, 1};
173     unsigned sa = sizeof(a) / sizeof(a[0]);
174     assert(std::is_sorted(Iter(a), Iter(a+sa), std::greater<int>()));
175     }
176 }
177 
main()178 int main()
179 {
180     test<forward_iterator<const int*> >();
181     test<bidirectional_iterator<const int*> >();
182     test<random_access_iterator<const int*> >();
183     test<const int*>();
184 }
185