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