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