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