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