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