1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 // <algorithm>
10 
11 // template<RandomAccessIterator Iter>
12 //   requires LessThanComparable<Iter::value_type>
13 //   constexpr bool   // constexpr after C++17
14 //   is_heap_until(Iter first, Iter last);
15 
16 #include <algorithm>
17 #include <cassert>
18 
19 #include "test_macros.h"
20 #include "test_iterators.h"
21 
22 #if TEST_STD_VER > 17
test_constexpr()23 TEST_CONSTEXPR bool test_constexpr() {
24     int ia[] = {0, 0, 0, 0, 1, 0};
25     int ib[] = {0, 0, 0, 1, 1, 1};
26     return    (std::is_heap_until(std::begin(ia), std::end(ia)) == ia+4)
27            && (std::is_heap_until(std::begin(ib), std::end(ib)) == ib+3);
28     }
29 #endif
30 
test()31 void test()
32 {
33     typedef random_access_iterator<int *> RI;
34     int i1[] = {0, 0};
35     assert(std::is_heap_until(i1, i1) == i1);
36     assert(std::is_heap_until(i1, i1+1) == i1+1);
37     assert(std::is_heap_until(RI(i1), RI(i1)) == RI(i1));
38     assert(std::is_heap_until(RI(i1), RI(i1+1)) == RI(i1+1));
39 
40     int i2[] = {0, 1};
41     int i3[] = {1, 0};
42     assert(std::is_heap_until(i1, i1+2) == i1+2);
43     assert(std::is_heap_until(i2, i2+2) == i2+1);
44     assert(std::is_heap_until(i3, i3+2) == i3+2);
45     int i4[] = {0, 0, 0};
46     int i5[] = {0, 0, 1};
47     int i6[] = {0, 1, 0};
48     int i7[] = {0, 1, 1};
49     int i8[] = {1, 0, 0};
50     int i9[] = {1, 0, 1};
51     int i10[] = {1, 1, 0};
52     assert(std::is_heap_until(i4, i4+3) == i4+3);
53     assert(std::is_heap_until(i5, i5+3) == i5+2);
54     assert(std::is_heap_until(i6, i6+3) == i6+1);
55     assert(std::is_heap_until(i7, i7+3) == i7+1);
56     assert(std::is_heap_until(i8, i8+3) == i8+3);
57     assert(std::is_heap_until(i9, i9+3) == i9+3);
58     assert(std::is_heap_until(i10, i10+3) == i10+3);
59     int i11[] = {0, 0, 0, 0};
60     int i12[] = {0, 0, 0, 1};
61     int i13[] = {0, 0, 1, 0};
62     int i14[] = {0, 0, 1, 1};
63     int i15[] = {0, 1, 0, 0};
64     int i16[] = {0, 1, 0, 1};
65     int i17[] = {0, 1, 1, 0};
66     int i18[] = {0, 1, 1, 1};
67     int i19[] = {1, 0, 0, 0};
68     int i20[] = {1, 0, 0, 1};
69     int i21[] = {1, 0, 1, 0};
70     int i22[] = {1, 0, 1, 1};
71     int i23[] = {1, 1, 0, 0};
72     int i24[] = {1, 1, 0, 1};
73     int i25[] = {1, 1, 1, 0};
74     assert(std::is_heap_until(i11, i11+4) == i11+4);
75     assert(std::is_heap_until(i12, i12+4) == i12+3);
76     assert(std::is_heap_until(i13, i13+4) == i13+2);
77     assert(std::is_heap_until(i14, i14+4) == i14+2);
78     assert(std::is_heap_until(i15, i15+4) == i15+1);
79     assert(std::is_heap_until(i16, i16+4) == i16+1);
80     assert(std::is_heap_until(i17, i17+4) == i17+1);
81     assert(std::is_heap_until(i18, i18+4) == i18+1);
82     assert(std::is_heap_until(i19, i19+4) == i19+4);
83     assert(std::is_heap_until(i20, i20+4) == i20+3);
84     assert(std::is_heap_until(i21, i21+4) == i21+4);
85     assert(std::is_heap_until(i22, i22+4) == i22+3);
86     assert(std::is_heap_until(i23, i23+4) == i23+4);
87     assert(std::is_heap_until(i24, i24+4) == i24+4);
88     assert(std::is_heap_until(i25, i25+4) == i25+4);
89     int i26[] = {0, 0, 0, 0, 0};
90     int i27[] = {0, 0, 0, 0, 1};
91     int i28[] = {0, 0, 0, 1, 0};
92     int i29[] = {0, 0, 0, 1, 1};
93     int i30[] = {0, 0, 1, 0, 0};
94     int i31[] = {0, 0, 1, 0, 1};
95     int i32[] = {0, 0, 1, 1, 0};
96     int i33[] = {0, 0, 1, 1, 1};
97     int i34[] = {0, 1, 0, 0, 0};
98     int i35[] = {0, 1, 0, 0, 1};
99     int i36[] = {0, 1, 0, 1, 0};
100     int i37[] = {0, 1, 0, 1, 1};
101     int i38[] = {0, 1, 1, 0, 0};
102     int i39[] = {0, 1, 1, 0, 1};
103     int i40[] = {0, 1, 1, 1, 0};
104     int i41[] = {0, 1, 1, 1, 1};
105     int i42[] = {1, 0, 0, 0, 0};
106     int i43[] = {1, 0, 0, 0, 1};
107     int i44[] = {1, 0, 0, 1, 0};
108     int i45[] = {1, 0, 0, 1, 1};
109     int i46[] = {1, 0, 1, 0, 0};
110     int i47[] = {1, 0, 1, 0, 1};
111     int i48[] = {1, 0, 1, 1, 0};
112     int i49[] = {1, 0, 1, 1, 1};
113     int i50[] = {1, 1, 0, 0, 0};
114     int i51[] = {1, 1, 0, 0, 1};
115     int i52[] = {1, 1, 0, 1, 0};
116     int i53[] = {1, 1, 0, 1, 1};
117     int i54[] = {1, 1, 1, 0, 0};
118     int i55[] = {1, 1, 1, 0, 1};
119     int i56[] = {1, 1, 1, 1, 0};
120     assert(std::is_heap_until(i26, i26+5) == i26+5);
121     assert(std::is_heap_until(i27, i27+5) == i27+4);
122     assert(std::is_heap_until(i28, i28+5) == i28+3);
123     assert(std::is_heap_until(i29, i29+5) == i29+3);
124     assert(std::is_heap_until(i30, i30+5) == i30+2);
125     assert(std::is_heap_until(i31, i31+5) == i31+2);
126     assert(std::is_heap_until(i32, i32+5) == i32+2);
127     assert(std::is_heap_until(i33, i33+5) == i33+2);
128     assert(std::is_heap_until(i34, i34+5) == i34+1);
129     assert(std::is_heap_until(i35, i35+5) == i35+1);
130     assert(std::is_heap_until(i36, i36+5) == i36+1);
131     assert(std::is_heap_until(i37, i37+5) == i37+1);
132     assert(std::is_heap_until(i38, i38+5) == i38+1);
133     assert(std::is_heap_until(i39, i39+5) == i39+1);
134     assert(std::is_heap_until(i40, i40+5) == i40+1);
135     assert(std::is_heap_until(i41, i41+5) == i41+1);
136     assert(std::is_heap_until(i42, i42+5) == i42+5);
137     assert(std::is_heap_until(i43, i43+5) == i43+4);
138     assert(std::is_heap_until(i44, i44+5) == i44+3);
139     assert(std::is_heap_until(i45, i45+5) == i45+3);
140     assert(std::is_heap_until(i46, i46+5) == i46+5);
141     assert(std::is_heap_until(i47, i47+5) == i47+4);
142     assert(std::is_heap_until(i48, i48+5) == i48+3);
143     assert(std::is_heap_until(i49, i49+5) == i49+3);
144     assert(std::is_heap_until(i50, i50+5) == i50+5);
145     assert(std::is_heap_until(i51, i51+5) == i51+5);
146     assert(std::is_heap_until(i52, i52+5) == i52+5);
147     assert(std::is_heap_until(i53, i53+5) == i53+5);
148     assert(std::is_heap_until(i54, i54+5) == i54+5);
149     assert(std::is_heap_until(i55, i55+5) == i55+5);
150     assert(std::is_heap_until(i56, i56+5) == i56+5);
151     int i57[] = {0, 0, 0, 0, 0, 0};
152     int i58[] = {0, 0, 0, 0, 0, 1};
153     int i59[] = {0, 0, 0, 0, 1, 0};
154     int i60[] = {0, 0, 0, 0, 1, 1};
155     int i61[] = {0, 0, 0, 1, 0, 0};
156     int i62[] = {0, 0, 0, 1, 0, 1};
157     int i63[] = {0, 0, 0, 1, 1, 0};
158     int i64[] = {0, 0, 0, 1, 1, 1};
159     int i65[] = {0, 0, 1, 0, 0, 0};
160     int i66[] = {0, 0, 1, 0, 0, 1};
161     int i67[] = {0, 0, 1, 0, 1, 0};
162     int i68[] = {0, 0, 1, 0, 1, 1};
163     int i69[] = {0, 0, 1, 1, 0, 0};
164     int i70[] = {0, 0, 1, 1, 0, 1};
165     int i71[] = {0, 0, 1, 1, 1, 0};
166     int i72[] = {0, 0, 1, 1, 1, 1};
167     int i73[] = {0, 1, 0, 0, 0, 0};
168     int i74[] = {0, 1, 0, 0, 0, 1};
169     int i75[] = {0, 1, 0, 0, 1, 0};
170     int i76[] = {0, 1, 0, 0, 1, 1};
171     int i77[] = {0, 1, 0, 1, 0, 0};
172     int i78[] = {0, 1, 0, 1, 0, 1};
173     int i79[] = {0, 1, 0, 1, 1, 0};
174     int i80[] = {0, 1, 0, 1, 1, 1};
175     int i81[] = {0, 1, 1, 0, 0, 0};
176     int i82[] = {0, 1, 1, 0, 0, 1};
177     int i83[] = {0, 1, 1, 0, 1, 0};
178     int i84[] = {0, 1, 1, 0, 1, 1};
179     int i85[] = {0, 1, 1, 1, 0, 0};
180     int i86[] = {0, 1, 1, 1, 0, 1};
181     int i87[] = {0, 1, 1, 1, 1, 0};
182     int i88[] = {0, 1, 1, 1, 1, 1};
183     int i89[] = {1, 0, 0, 0, 0, 0};
184     int i90[] = {1, 0, 0, 0, 0, 1};
185     int i91[] = {1, 0, 0, 0, 1, 0};
186     int i92[] = {1, 0, 0, 0, 1, 1};
187     int i93[] = {1, 0, 0, 1, 0, 0};
188     int i94[] = {1, 0, 0, 1, 0, 1};
189     int i95[] = {1, 0, 0, 1, 1, 0};
190     int i96[] = {1, 0, 0, 1, 1, 1};
191     int i97[] = {1, 0, 1, 0, 0, 0};
192     int i98[] = {1, 0, 1, 0, 0, 1};
193     int i99[] = {1, 0, 1, 0, 1, 0};
194     int i100[] = {1, 0, 1, 0, 1, 1};
195     int i101[] = {1, 0, 1, 1, 0, 0};
196     int i102[] = {1, 0, 1, 1, 0, 1};
197     int i103[] = {1, 0, 1, 1, 1, 0};
198     int i104[] = {1, 0, 1, 1, 1, 1};
199     int i105[] = {1, 1, 0, 0, 0, 0};
200     int i106[] = {1, 1, 0, 0, 0, 1};
201     int i107[] = {1, 1, 0, 0, 1, 0};
202     int i108[] = {1, 1, 0, 0, 1, 1};
203     int i109[] = {1, 1, 0, 1, 0, 0};
204     int i110[] = {1, 1, 0, 1, 0, 1};
205     int i111[] = {1, 1, 0, 1, 1, 0};
206     int i112[] = {1, 1, 0, 1, 1, 1};
207     int i113[] = {1, 1, 1, 0, 0, 0};
208     int i114[] = {1, 1, 1, 0, 0, 1};
209     int i115[] = {1, 1, 1, 0, 1, 0};
210     int i116[] = {1, 1, 1, 0, 1, 1};
211     int i117[] = {1, 1, 1, 1, 0, 0};
212     int i118[] = {1, 1, 1, 1, 0, 1};
213     int i119[] = {1, 1, 1, 1, 1, 0};
214     assert(std::is_heap_until(i57, i57+6) == i57+6);
215     assert(std::is_heap_until(i58, i58+6) == i58+5);
216     assert(std::is_heap_until(i59, i59+6) == i59+4);
217     assert(std::is_heap_until(i60, i60+6) == i60+4);
218     assert(std::is_heap_until(i61, i61+6) == i61+3);
219     assert(std::is_heap_until(i62, i62+6) == i62+3);
220     assert(std::is_heap_until(i63, i63+6) == i63+3);
221     assert(std::is_heap_until(i64, i64+6) == i64+3);
222     assert(std::is_heap_until(i65, i65+6) == i65+2);
223     assert(std::is_heap_until(i66, i66+6) == i66+2);
224     assert(std::is_heap_until(i67, i67+6) == i67+2);
225     assert(std::is_heap_until(i68, i68+6) == i68+2);
226     assert(std::is_heap_until(i69, i69+6) == i69+2);
227     assert(std::is_heap_until(i70, i70+6) == i70+2);
228     assert(std::is_heap_until(i71, i71+6) == i71+2);
229     assert(std::is_heap_until(i72, i72+6) == i72+2);
230     assert(std::is_heap_until(i73, i73+6) == i73+1);
231     assert(std::is_heap_until(i74, i74+6) == i74+1);
232     assert(std::is_heap_until(i75, i75+6) == i75+1);
233     assert(std::is_heap_until(i76, i76+6) == i76+1);
234     assert(std::is_heap_until(i77, i77+6) == i77+1);
235     assert(std::is_heap_until(i78, i78+6) == i78+1);
236     assert(std::is_heap_until(i79, i79+6) == i79+1);
237     assert(std::is_heap_until(i80, i80+6) == i80+1);
238     assert(std::is_heap_until(i81, i81+6) == i81+1);
239     assert(std::is_heap_until(i82, i82+6) == i82+1);
240     assert(std::is_heap_until(i83, i83+6) == i83+1);
241     assert(std::is_heap_until(i84, i84+6) == i84+1);
242     assert(std::is_heap_until(i85, i85+6) == i85+1);
243     assert(std::is_heap_until(i86, i86+6) == i86+1);
244     assert(std::is_heap_until(i87, i87+6) == i87+1);
245     assert(std::is_heap_until(i88, i88+6) == i88+1);
246     assert(std::is_heap_until(i89, i89+6) == i89+6);
247     assert(std::is_heap_until(i90, i90+6) == i90+5);
248     assert(std::is_heap_until(i91, i91+6) == i91+4);
249     assert(std::is_heap_until(i92, i92+6) == i92+4);
250     assert(std::is_heap_until(i93, i93+6) == i93+3);
251     assert(std::is_heap_until(i94, i94+6) == i94+3);
252     assert(std::is_heap_until(i95, i95+6) == i95+3);
253     assert(std::is_heap_until(i96, i96+6) == i96+3);
254     assert(std::is_heap_until(i97, i97+6) == i97+6);
255     assert(std::is_heap_until(i98, i98+6) == i98+6);
256     assert(std::is_heap_until(i99, i99+6) == i99+4);
257     assert(std::is_heap_until(i100, i100+6) == i100+4);
258     assert(std::is_heap_until(i101, i101+6) == i101+3);
259     assert(std::is_heap_until(i102, i102+6) == i102+3);
260     assert(std::is_heap_until(i103, i103+6) == i103+3);
261     assert(std::is_heap_until(i104, i104+6) == i104+3);
262     assert(std::is_heap_until(i105, i105+6) == i105+6);
263     assert(std::is_heap_until(i106, i106+6) == i106+5);
264     assert(std::is_heap_until(i107, i107+6) == i107+6);
265     assert(std::is_heap_until(i108, i108+6) == i108+5);
266     assert(std::is_heap_until(i109, i109+6) == i109+6);
267     assert(std::is_heap_until(i110, i110+6) == i110+5);
268     assert(std::is_heap_until(i111, i111+6) == i111+6);
269     assert(std::is_heap_until(i112, i112+6) == i112+5);
270     assert(std::is_heap_until(i113, i113+6) == i113+6);
271     assert(std::is_heap_until(i114, i114+6) == i114+6);
272     assert(std::is_heap_until(i115, i115+6) == i115+6);
273     assert(std::is_heap_until(i116, i116+6) == i116+6);
274     assert(std::is_heap_until(i117, i117+6) == i117+6);
275     assert(std::is_heap_until(i118, i118+6) == i118+6);
276     assert(std::is_heap_until(i119, i119+6) == i119+6);
277     int i120[] = {0, 0, 0, 0, 0, 0, 0};
278     int i121[] = {0, 0, 0, 0, 0, 0, 1};
279     int i122[] = {0, 0, 0, 0, 0, 1, 0};
280     int i123[] = {0, 0, 0, 0, 0, 1, 1};
281     int i124[] = {0, 0, 0, 0, 1, 0, 0};
282     int i125[] = {0, 0, 0, 0, 1, 0, 1};
283     int i126[] = {0, 0, 0, 0, 1, 1, 0};
284     int i127[] = {0, 0, 0, 0, 1, 1, 1};
285     int i128[] = {0, 0, 0, 1, 0, 0, 0};
286     int i129[] = {0, 0, 0, 1, 0, 0, 1};
287     int i130[] = {0, 0, 0, 1, 0, 1, 0};
288     int i131[] = {0, 0, 0, 1, 0, 1, 1};
289     int i132[] = {0, 0, 0, 1, 1, 0, 0};
290     int i133[] = {0, 0, 0, 1, 1, 0, 1};
291     int i134[] = {0, 0, 0, 1, 1, 1, 0};
292     int i135[] = {0, 0, 0, 1, 1, 1, 1};
293     int i136[] = {0, 0, 1, 0, 0, 0, 0};
294     int i137[] = {0, 0, 1, 0, 0, 0, 1};
295     int i138[] = {0, 0, 1, 0, 0, 1, 0};
296     int i139[] = {0, 0, 1, 0, 0, 1, 1};
297     int i140[] = {0, 0, 1, 0, 1, 0, 0};
298     int i141[] = {0, 0, 1, 0, 1, 0, 1};
299     int i142[] = {0, 0, 1, 0, 1, 1, 0};
300     int i143[] = {0, 0, 1, 0, 1, 1, 1};
301     int i144[] = {0, 0, 1, 1, 0, 0, 0};
302     int i145[] = {0, 0, 1, 1, 0, 0, 1};
303     int i146[] = {0, 0, 1, 1, 0, 1, 0};
304     int i147[] = {0, 0, 1, 1, 0, 1, 1};
305     int i148[] = {0, 0, 1, 1, 1, 0, 0};
306     int i149[] = {0, 0, 1, 1, 1, 0, 1};
307     int i150[] = {0, 0, 1, 1, 1, 1, 0};
308     int i151[] = {0, 0, 1, 1, 1, 1, 1};
309     int i152[] = {0, 1, 0, 0, 0, 0, 0};
310     int i153[] = {0, 1, 0, 0, 0, 0, 1};
311     int i154[] = {0, 1, 0, 0, 0, 1, 0};
312     int i155[] = {0, 1, 0, 0, 0, 1, 1};
313     int i156[] = {0, 1, 0, 0, 1, 0, 0};
314     int i157[] = {0, 1, 0, 0, 1, 0, 1};
315     int i158[] = {0, 1, 0, 0, 1, 1, 0};
316     int i159[] = {0, 1, 0, 0, 1, 1, 1};
317     int i160[] = {0, 1, 0, 1, 0, 0, 0};
318     int i161[] = {0, 1, 0, 1, 0, 0, 1};
319     int i162[] = {0, 1, 0, 1, 0, 1, 0};
320     int i163[] = {0, 1, 0, 1, 0, 1, 1};
321     int i164[] = {0, 1, 0, 1, 1, 0, 0};
322     int i165[] = {0, 1, 0, 1, 1, 0, 1};
323     int i166[] = {0, 1, 0, 1, 1, 1, 0};
324     int i167[] = {0, 1, 0, 1, 1, 1, 1};
325     int i168[] = {0, 1, 1, 0, 0, 0, 0};
326     int i169[] = {0, 1, 1, 0, 0, 0, 1};
327     int i170[] = {0, 1, 1, 0, 0, 1, 0};
328     int i171[] = {0, 1, 1, 0, 0, 1, 1};
329     int i172[] = {0, 1, 1, 0, 1, 0, 0};
330     int i173[] = {0, 1, 1, 0, 1, 0, 1};
331     int i174[] = {0, 1, 1, 0, 1, 1, 0};
332     int i175[] = {0, 1, 1, 0, 1, 1, 1};
333     int i176[] = {0, 1, 1, 1, 0, 0, 0};
334     int i177[] = {0, 1, 1, 1, 0, 0, 1};
335     int i178[] = {0, 1, 1, 1, 0, 1, 0};
336     int i179[] = {0, 1, 1, 1, 0, 1, 1};
337     int i180[] = {0, 1, 1, 1, 1, 0, 0};
338     int i181[] = {0, 1, 1, 1, 1, 0, 1};
339     int i182[] = {0, 1, 1, 1, 1, 1, 0};
340     int i183[] = {0, 1, 1, 1, 1, 1, 1};
341     int i184[] = {1, 0, 0, 0, 0, 0, 0};
342     int i185[] = {1, 0, 0, 0, 0, 0, 1};
343     int i186[] = {1, 0, 0, 0, 0, 1, 0};
344     int i187[] = {1, 0, 0, 0, 0, 1, 1};
345     int i188[] = {1, 0, 0, 0, 1, 0, 0};
346     int i189[] = {1, 0, 0, 0, 1, 0, 1};
347     int i190[] = {1, 0, 0, 0, 1, 1, 0};
348     int i191[] = {1, 0, 0, 0, 1, 1, 1};
349     int i192[] = {1, 0, 0, 1, 0, 0, 0};
350     int i193[] = {1, 0, 0, 1, 0, 0, 1};
351     int i194[] = {1, 0, 0, 1, 0, 1, 0};
352     int i195[] = {1, 0, 0, 1, 0, 1, 1};
353     int i196[] = {1, 0, 0, 1, 1, 0, 0};
354     int i197[] = {1, 0, 0, 1, 1, 0, 1};
355     int i198[] = {1, 0, 0, 1, 1, 1, 0};
356     int i199[] = {1, 0, 0, 1, 1, 1, 1};
357     int i200[] = {1, 0, 1, 0, 0, 0, 0};
358     int i201[] = {1, 0, 1, 0, 0, 0, 1};
359     int i202[] = {1, 0, 1, 0, 0, 1, 0};
360     int i203[] = {1, 0, 1, 0, 0, 1, 1};
361     int i204[] = {1, 0, 1, 0, 1, 0, 0};
362     int i205[] = {1, 0, 1, 0, 1, 0, 1};
363     int i206[] = {1, 0, 1, 0, 1, 1, 0};
364     int i207[] = {1, 0, 1, 0, 1, 1, 1};
365     int i208[] = {1, 0, 1, 1, 0, 0, 0};
366     int i209[] = {1, 0, 1, 1, 0, 0, 1};
367     int i210[] = {1, 0, 1, 1, 0, 1, 0};
368     int i211[] = {1, 0, 1, 1, 0, 1, 1};
369     int i212[] = {1, 0, 1, 1, 1, 0, 0};
370     int i213[] = {1, 0, 1, 1, 1, 0, 1};
371     int i214[] = {1, 0, 1, 1, 1, 1, 0};
372     int i215[] = {1, 0, 1, 1, 1, 1, 1};
373     int i216[] = {1, 1, 0, 0, 0, 0, 0};
374     int i217[] = {1, 1, 0, 0, 0, 0, 1};
375     int i218[] = {1, 1, 0, 0, 0, 1, 0};
376     int i219[] = {1, 1, 0, 0, 0, 1, 1};
377     int i220[] = {1, 1, 0, 0, 1, 0, 0};
378     int i221[] = {1, 1, 0, 0, 1, 0, 1};
379     int i222[] = {1, 1, 0, 0, 1, 1, 0};
380     int i223[] = {1, 1, 0, 0, 1, 1, 1};
381     int i224[] = {1, 1, 0, 1, 0, 0, 0};
382     int i225[] = {1, 1, 0, 1, 0, 0, 1};
383     int i226[] = {1, 1, 0, 1, 0, 1, 0};
384     int i227[] = {1, 1, 0, 1, 0, 1, 1};
385     int i228[] = {1, 1, 0, 1, 1, 0, 0};
386     int i229[] = {1, 1, 0, 1, 1, 0, 1};
387     int i230[] = {1, 1, 0, 1, 1, 1, 0};
388     int i231[] = {1, 1, 0, 1, 1, 1, 1};
389     int i232[] = {1, 1, 1, 0, 0, 0, 0};
390     int i233[] = {1, 1, 1, 0, 0, 0, 1};
391     int i234[] = {1, 1, 1, 0, 0, 1, 0};
392     int i235[] = {1, 1, 1, 0, 0, 1, 1};
393     int i236[] = {1, 1, 1, 0, 1, 0, 0};
394     int i237[] = {1, 1, 1, 0, 1, 0, 1};
395     int i238[] = {1, 1, 1, 0, 1, 1, 0};
396     int i239[] = {1, 1, 1, 0, 1, 1, 1};
397     int i240[] = {1, 1, 1, 1, 0, 0, 0};
398     int i241[] = {1, 1, 1, 1, 0, 0, 1};
399     int i242[] = {1, 1, 1, 1, 0, 1, 0};
400     int i243[] = {1, 1, 1, 1, 0, 1, 1};
401     int i244[] = {1, 1, 1, 1, 1, 0, 0};
402     int i245[] = {1, 1, 1, 1, 1, 0, 1};
403     int i246[] = {1, 1, 1, 1, 1, 1, 0};
404     assert(std::is_heap_until(i120, i120+7) == i120+7);
405     assert(std::is_heap_until(i121, i121+7) == i121+6);
406     assert(std::is_heap_until(i122, i122+7) == i122+5);
407     assert(std::is_heap_until(i123, i123+7) == i123+5);
408     assert(std::is_heap_until(i124, i124+7) == i124+4);
409     assert(std::is_heap_until(i125, i125+7) == i125+4);
410     assert(std::is_heap_until(i126, i126+7) == i126+4);
411     assert(std::is_heap_until(i127, i127+7) == i127+4);
412     assert(std::is_heap_until(i128, i128+7) == i128+3);
413     assert(std::is_heap_until(i129, i129+7) == i129+3);
414     assert(std::is_heap_until(i130, i130+7) == i130+3);
415     assert(std::is_heap_until(i131, i131+7) == i131+3);
416     assert(std::is_heap_until(i132, i132+7) == i132+3);
417     assert(std::is_heap_until(i133, i133+7) == i133+3);
418     assert(std::is_heap_until(i134, i134+7) == i134+3);
419     assert(std::is_heap_until(i135, i135+7) == i135+3);
420     assert(std::is_heap_until(i136, i136+7) == i136+2);
421     assert(std::is_heap_until(i137, i137+7) == i137+2);
422     assert(std::is_heap_until(i138, i138+7) == i138+2);
423     assert(std::is_heap_until(i139, i139+7) == i139+2);
424     assert(std::is_heap_until(i140, i140+7) == i140+2);
425     assert(std::is_heap_until(i141, i141+7) == i141+2);
426     assert(std::is_heap_until(i142, i142+7) == i142+2);
427     assert(std::is_heap_until(i143, i143+7) == i143+2);
428     assert(std::is_heap_until(i144, i144+7) == i144+2);
429     assert(std::is_heap_until(i145, i145+7) == i145+2);
430     assert(std::is_heap_until(i146, i146+7) == i146+2);
431     assert(std::is_heap_until(i147, i147+7) == i147+2);
432     assert(std::is_heap_until(i148, i148+7) == i148+2);
433     assert(std::is_heap_until(i149, i149+7) == i149+2);
434     assert(std::is_heap_until(i150, i150+7) == i150+2);
435     assert(std::is_heap_until(i151, i151+7) == i151+2);
436     assert(std::is_heap_until(i152, i152+7) == i152+1);
437     assert(std::is_heap_until(i153, i153+7) == i153+1);
438     assert(std::is_heap_until(i154, i154+7) == i154+1);
439     assert(std::is_heap_until(i155, i155+7) == i155+1);
440     assert(std::is_heap_until(i156, i156+7) == i156+1);
441     assert(std::is_heap_until(i157, i157+7) == i157+1);
442     assert(std::is_heap_until(i158, i158+7) == i158+1);
443     assert(std::is_heap_until(i159, i159+7) == i159+1);
444     assert(std::is_heap_until(i160, i160+7) == i160+1);
445     assert(std::is_heap_until(i161, i161+7) == i161+1);
446     assert(std::is_heap_until(i162, i162+7) == i162+1);
447     assert(std::is_heap_until(i163, i163+7) == i163+1);
448     assert(std::is_heap_until(i164, i164+7) == i164+1);
449     assert(std::is_heap_until(i165, i165+7) == i165+1);
450     assert(std::is_heap_until(i166, i166+7) == i166+1);
451     assert(std::is_heap_until(i167, i167+7) == i167+1);
452     assert(std::is_heap_until(i168, i168+7) == i168+1);
453     assert(std::is_heap_until(i169, i169+7) == i169+1);
454     assert(std::is_heap_until(i170, i170+7) == i170+1);
455     assert(std::is_heap_until(i171, i171+7) == i171+1);
456     assert(std::is_heap_until(i172, i172+7) == i172+1);
457     assert(std::is_heap_until(i173, i173+7) == i173+1);
458     assert(std::is_heap_until(i174, i174+7) == i174+1);
459     assert(std::is_heap_until(i175, i175+7) == i175+1);
460     assert(std::is_heap_until(i176, i176+7) == i176+1);
461     assert(std::is_heap_until(i177, i177+7) == i177+1);
462     assert(std::is_heap_until(i178, i178+7) == i178+1);
463     assert(std::is_heap_until(i179, i179+7) == i179+1);
464     assert(std::is_heap_until(i180, i180+7) == i180+1);
465     assert(std::is_heap_until(i181, i181+7) == i181+1);
466     assert(std::is_heap_until(i182, i182+7) == i182+1);
467     assert(std::is_heap_until(i183, i183+7) == i183+1);
468     assert(std::is_heap_until(i184, i184+7) == i184+7);
469     assert(std::is_heap_until(i185, i185+7) == i185+6);
470     assert(std::is_heap_until(i186, i186+7) == i186+5);
471     assert(std::is_heap_until(i187, i187+7) == i187+5);
472     assert(std::is_heap_until(i188, i188+7) == i188+4);
473     assert(std::is_heap_until(i189, i189+7) == i189+4);
474     assert(std::is_heap_until(i190, i190+7) == i190+4);
475     assert(std::is_heap_until(i191, i191+7) == i191+4);
476     assert(std::is_heap_until(i192, i192+7) == i192+3);
477     assert(std::is_heap_until(i193, i193+7) == i193+3);
478     assert(std::is_heap_until(i194, i194+7) == i194+3);
479     assert(std::is_heap_until(i195, i195+7) == i195+3);
480     assert(std::is_heap_until(i196, i196+7) == i196+3);
481     assert(std::is_heap_until(i197, i197+7) == i197+3);
482     assert(std::is_heap_until(i198, i198+7) == i198+3);
483     assert(std::is_heap_until(i199, i199+7) == i199+3);
484     assert(std::is_heap_until(i200, i200+7) == i200+7);
485     assert(std::is_heap_until(i201, i201+7) == i201+7);
486     assert(std::is_heap_until(i202, i202+7) == i202+7);
487     assert(std::is_heap_until(i203, i203+7) == i203+7);
488     assert(std::is_heap_until(i204, i204+7) == i204+4);
489     assert(std::is_heap_until(i205, i205+7) == i205+4);
490     assert(std::is_heap_until(i206, i206+7) == i206+4);
491     assert(std::is_heap_until(i207, i207+7) == i207+4);
492     assert(std::is_heap_until(i208, i208+7) == i208+3);
493     assert(std::is_heap_until(i209, i209+7) == i209+3);
494     assert(std::is_heap_until(i210, i210+7) == i210+3);
495     assert(std::is_heap_until(i211, i211+7) == i211+3);
496     assert(std::is_heap_until(i212, i212+7) == i212+3);
497     assert(std::is_heap_until(i213, i213+7) == i213+3);
498     assert(std::is_heap_until(i214, i214+7) == i214+3);
499     assert(std::is_heap_until(i215, i215+7) == i215+3);
500     assert(std::is_heap_until(i216, i216+7) == i216+7);
501     assert(std::is_heap_until(i217, i217+7) == i217+6);
502     assert(std::is_heap_until(i218, i218+7) == i218+5);
503     assert(std::is_heap_until(i219, i219+7) == i219+5);
504     assert(std::is_heap_until(i220, i220+7) == i220+7);
505     assert(std::is_heap_until(i221, i221+7) == i221+6);
506     assert(std::is_heap_until(i222, i222+7) == i222+5);
507     assert(std::is_heap_until(i223, i223+7) == i223+5);
508     assert(std::is_heap_until(i224, i224+7) == i224+7);
509     assert(std::is_heap_until(i225, i225+7) == i225+6);
510     assert(std::is_heap_until(i226, i226+7) == i226+5);
511     assert(std::is_heap_until(i227, i227+7) == i227+5);
512     assert(std::is_heap_until(i228, i228+7) == i228+7);
513     assert(std::is_heap_until(i229, i229+7) == i229+6);
514     assert(std::is_heap_until(i230, i230+7) == i230+5);
515     assert(std::is_heap_until(i231, i231+7) == i231+5);
516     assert(std::is_heap_until(i232, i232+7) == i232+7);
517     assert(std::is_heap_until(i233, i233+7) == i233+7);
518     assert(std::is_heap_until(i234, i234+7) == i234+7);
519     assert(std::is_heap_until(i235, i235+7) == i235+7);
520     assert(std::is_heap_until(i236, i236+7) == i236+7);
521     assert(std::is_heap_until(i237, i237+7) == i237+7);
522     assert(std::is_heap_until(i238, i238+7) == i238+7);
523     assert(std::is_heap_until(i239, i239+7) == i239+7);
524     assert(std::is_heap_until(i240, i240+7) == i240+7);
525     assert(std::is_heap_until(i241, i241+7) == i241+7);
526     assert(std::is_heap_until(i242, i242+7) == i242+7);
527     assert(std::is_heap_until(i243, i243+7) == i243+7);
528     assert(std::is_heap_until(i244, i244+7) == i244+7);
529     assert(std::is_heap_until(i245, i245+7) == i245+7);
530     assert(std::is_heap_until(i246, i246+7) == i246+7);
531 }
532 
main(int,char **)533 int main(int, char**)
534 {
535     test();
536 
537 #if TEST_STD_VER > 17
538     static_assert(test_constexpr());
539 #endif
540 
541   return 0;
542 }
543