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
22template <class Iter>
23void
24test()
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
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