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