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
22template <class Iter>
23void
24test()
25{
26    {
27    int a[] = {0};
28    unsigned sa = sizeof(a) / sizeof(a[0]);
29    assert(std::is_sorted_until(Iter(a), Iter(a)) == Iter(a));
30    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+sa));
31    }
32
33    {
34    int a[] = {0, 0};
35    unsigned sa = sizeof(a) / sizeof(a[0]);
36    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+sa));
37    }
38    {
39    int a[] = {0, 1};
40    unsigned sa = sizeof(a) / sizeof(a[0]);
41    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+sa));
42    }
43    {
44    int a[] = {1, 0};
45    unsigned sa = sizeof(a) / sizeof(a[0]);
46    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+1));
47    }
48    {
49    int a[] = {1, 1};
50    unsigned sa = sizeof(a) / sizeof(a[0]);
51    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == 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_until(Iter(a), Iter(a+sa)) == Iter(a+sa));
58    }
59    {
60    int a[] = {0, 0, 1};
61    unsigned sa = sizeof(a) / sizeof(a[0]);
62    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+sa));
63    }
64    {
65    int a[] = {0, 1, 0};
66    unsigned sa = sizeof(a) / sizeof(a[0]);
67    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+2));
68    }
69    {
70    int a[] = {0, 1, 1};
71    unsigned sa = sizeof(a) / sizeof(a[0]);
72    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+sa));
73    }
74    {
75    int a[] = {1, 0, 0};
76    unsigned sa = sizeof(a) / sizeof(a[0]);
77    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+1));
78    }
79    {
80    int a[] = {1, 0, 1};
81    unsigned sa = sizeof(a) / sizeof(a[0]);
82    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+1));
83    }
84    {
85    int a[] = {1, 1, 0};
86    unsigned sa = sizeof(a) / sizeof(a[0]);
87    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+2));
88    }
89    {
90    int a[] = {1, 1, 1};
91    unsigned sa = sizeof(a) / sizeof(a[0]);
92    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == 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_until(Iter(a), Iter(a+sa)) == 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_until(Iter(a), Iter(a+sa)) == 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_until(Iter(a), Iter(a+sa)) == Iter(a+3));
109    }
110    {
111    int a[] = {0, 0, 1, 1};
112    unsigned sa = sizeof(a) / sizeof(a[0]);
113    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == 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_until(Iter(a), Iter(a+sa)) == Iter(a+2));
119    }
120    {
121    int a[] = {0, 1, 0, 1};
122    unsigned sa = sizeof(a) / sizeof(a[0]);
123    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+2));
124    }
125    {
126    int a[] = {0, 1, 1, 0};
127    unsigned sa = sizeof(a) / sizeof(a[0]);
128    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+3));
129    }
130    {
131    int a[] = {0, 1, 1, 1};
132    unsigned sa = sizeof(a) / sizeof(a[0]);
133    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == 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_until(Iter(a), Iter(a+sa)) == Iter(a+1));
139    }
140    {
141    int a[] = {1, 0, 0, 1};
142    unsigned sa = sizeof(a) / sizeof(a[0]);
143    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+1));
144    }
145    {
146    int a[] = {1, 0, 1, 0};
147    unsigned sa = sizeof(a) / sizeof(a[0]);
148    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+1));
149    }
150    {
151    int a[] = {1, 0, 1, 1};
152    unsigned sa = sizeof(a) / sizeof(a[0]);
153    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+1));
154    }
155    {
156    int a[] = {1, 1, 0, 0};
157    unsigned sa = sizeof(a) / sizeof(a[0]);
158    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+2));
159    }
160    {
161    int a[] = {1, 1, 0, 1};
162    unsigned sa = sizeof(a) / sizeof(a[0]);
163    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+2));
164    }
165    {
166    int a[] = {1, 1, 1, 0};
167    unsigned sa = sizeof(a) / sizeof(a[0]);
168    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+3));
169    }
170    {
171    int a[] = {1, 1, 1, 1};
172    unsigned sa = sizeof(a) / sizeof(a[0]);
173    assert(std::is_sorted_until(Iter(a), Iter(a+sa)) == Iter(a+sa));
174    }
175}
176
177int 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