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 // Iter
15 // is_sorted_until(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_until(Iter(a), Iter(a), std::greater<int>()) == Iter(a));
31 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
32 }
33
34 {
35 int a[] = {0, 0};
36 unsigned sa = sizeof(a) / sizeof(a[0]);
37 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
38 }
39 {
40 int a[] = {0, 1};
41 unsigned sa = sizeof(a) / sizeof(a[0]);
42 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+1));
43 }
44 {
45 int a[] = {1, 0};
46 unsigned sa = sizeof(a) / sizeof(a[0]);
47 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
48 }
49 {
50 int a[] = {1, 1};
51 unsigned sa = sizeof(a) / sizeof(a[0]);
52 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
53 }
54
55 {
56 int a[] = {0, 0, 0};
57 unsigned sa = sizeof(a) / sizeof(a[0]);
58 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
59 }
60 {
61 int a[] = {0, 0, 1};
62 unsigned sa = sizeof(a) / sizeof(a[0]);
63 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+2));
64 }
65 {
66 int a[] = {0, 1, 0};
67 unsigned sa = sizeof(a) / sizeof(a[0]);
68 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+1));
69 }
70 {
71 int a[] = {0, 1, 1};
72 unsigned sa = sizeof(a) / sizeof(a[0]);
73 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+1));
74 }
75 {
76 int a[] = {1, 0, 0};
77 unsigned sa = sizeof(a) / sizeof(a[0]);
78 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
79 }
80 {
81 int a[] = {1, 0, 1};
82 unsigned sa = sizeof(a) / sizeof(a[0]);
83 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+2));
84 }
85 {
86 int a[] = {1, 1, 0};
87 unsigned sa = sizeof(a) / sizeof(a[0]);
88 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
89 }
90 {
91 int a[] = {1, 1, 1};
92 unsigned sa = sizeof(a) / sizeof(a[0]);
93 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
94 }
95
96 {
97 int a[] = {0, 0, 0, 0};
98 unsigned sa = sizeof(a) / sizeof(a[0]);
99 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
100 }
101 {
102 int a[] = {0, 0, 0, 1};
103 unsigned sa = sizeof(a) / sizeof(a[0]);
104 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+3));
105 }
106 {
107 int a[] = {0, 0, 1, 0};
108 unsigned sa = sizeof(a) / sizeof(a[0]);
109 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+2));
110 }
111 {
112 int a[] = {0, 0, 1, 1};
113 unsigned sa = sizeof(a) / sizeof(a[0]);
114 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+2));
115 }
116 {
117 int a[] = {0, 1, 0, 0};
118 unsigned sa = sizeof(a) / sizeof(a[0]);
119 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+1));
120 }
121 {
122 int a[] = {0, 1, 0, 1};
123 unsigned sa = sizeof(a) / sizeof(a[0]);
124 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+1));
125 }
126 {
127 int a[] = {0, 1, 1, 0};
128 unsigned sa = sizeof(a) / sizeof(a[0]);
129 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+1));
130 }
131 {
132 int a[] = {0, 1, 1, 1};
133 unsigned sa = sizeof(a) / sizeof(a[0]);
134 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+1));
135 }
136 {
137 int a[] = {1, 0, 0, 0};
138 unsigned sa = sizeof(a) / sizeof(a[0]);
139 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
140 }
141 {
142 int a[] = {1, 0, 0, 1};
143 unsigned sa = sizeof(a) / sizeof(a[0]);
144 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+3));
145 }
146 {
147 int a[] = {1, 0, 1, 0};
148 unsigned sa = sizeof(a) / sizeof(a[0]);
149 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+2));
150 }
151 {
152 int a[] = {1, 0, 1, 1};
153 unsigned sa = sizeof(a) / sizeof(a[0]);
154 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+2));
155 }
156 {
157 int a[] = {1, 1, 0, 0};
158 unsigned sa = sizeof(a) / sizeof(a[0]);
159 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
160 }
161 {
162 int a[] = {1, 1, 0, 1};
163 unsigned sa = sizeof(a) / sizeof(a[0]);
164 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+3));
165 }
166 {
167 int a[] = {1, 1, 1, 0};
168 unsigned sa = sizeof(a) / sizeof(a[0]);
169 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
170 }
171 {
172 int a[] = {1, 1, 1, 1};
173 unsigned sa = sizeof(a) / sizeof(a[0]);
174 assert(std::is_sorted_until(Iter(a), Iter(a+sa), std::greater<int>()) == Iter(a+sa));
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