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 // Test that all public C++ headers define the verbose termination function.
10 
11 // The system-provided <uchar.h> seems to be broken on AIX, which trips up this test.
12 // XFAIL: LIBCXX-AIX-FIXME
13 
14 /*
15 BEGIN-SCRIPT
16 
17 for i, header in enumerate(public_headers):
18     # Skip C compatibility headers.
19     if header.endswith('.h'):
20         continue
21 
22     vars = {
23         'run': 'RUN',
24         'i': i,
25         'restrictions': ' && ' + header_restrictions[header] if header in header_restrictions else '',
26         'header': header
27     }
28 
29     print("""\
30 // {run}: %{{build}} -DTEST_{i}
31 #if defined(TEST_{i}){restrictions}
32 #   include <{header}>
33     using HandlerType = decltype(std::__libcpp_verbose_abort);
34 #endif
35 """.format(**vars))
36 
37 END-SCRIPT
38 */
39 
40 #include <__config>
41 
42 // Prevent <ext/hash_map> from generating deprecated warnings for this test.
43 #if defined(__DEPRECATED)
44 #   undef __DEPRECATED
45 #endif
46 
main(int,char **)47 int main(int, char**) { return 0; }
48 
49 // DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW
50 // GENERATED-MARKER
51 // RUN: %{build} -DTEST_0
52 #if defined(TEST_0)
53 #   include <algorithm>
54     using HandlerType = decltype(std::__libcpp_verbose_abort);
55 #endif
56 
57 // RUN: %{build} -DTEST_1
58 #if defined(TEST_1)
59 #   include <any>
60     using HandlerType = decltype(std::__libcpp_verbose_abort);
61 #endif
62 
63 // RUN: %{build} -DTEST_2
64 #if defined(TEST_2)
65 #   include <array>
66     using HandlerType = decltype(std::__libcpp_verbose_abort);
67 #endif
68 
69 // RUN: %{build} -DTEST_3
70 #if defined(TEST_3)
71 #   include <atomic>
72     using HandlerType = decltype(std::__libcpp_verbose_abort);
73 #endif
74 
75 // RUN: %{build} -DTEST_4
76 #if defined(TEST_4) && !defined(_LIBCPP_HAS_NO_THREADS)
77 #   include <barrier>
78     using HandlerType = decltype(std::__libcpp_verbose_abort);
79 #endif
80 
81 // RUN: %{build} -DTEST_5
82 #if defined(TEST_5)
83 #   include <bit>
84     using HandlerType = decltype(std::__libcpp_verbose_abort);
85 #endif
86 
87 // RUN: %{build} -DTEST_6
88 #if defined(TEST_6)
89 #   include <bitset>
90     using HandlerType = decltype(std::__libcpp_verbose_abort);
91 #endif
92 
93 // RUN: %{build} -DTEST_7
94 #if defined(TEST_7)
95 #   include <cassert>
96     using HandlerType = decltype(std::__libcpp_verbose_abort);
97 #endif
98 
99 // RUN: %{build} -DTEST_8
100 #if defined(TEST_8)
101 #   include <ccomplex>
102     using HandlerType = decltype(std::__libcpp_verbose_abort);
103 #endif
104 
105 // RUN: %{build} -DTEST_9
106 #if defined(TEST_9)
107 #   include <cctype>
108     using HandlerType = decltype(std::__libcpp_verbose_abort);
109 #endif
110 
111 // RUN: %{build} -DTEST_10
112 #if defined(TEST_10)
113 #   include <cerrno>
114     using HandlerType = decltype(std::__libcpp_verbose_abort);
115 #endif
116 
117 // RUN: %{build} -DTEST_11
118 #if defined(TEST_11)
119 #   include <cfenv>
120     using HandlerType = decltype(std::__libcpp_verbose_abort);
121 #endif
122 
123 // RUN: %{build} -DTEST_12
124 #if defined(TEST_12)
125 #   include <cfloat>
126     using HandlerType = decltype(std::__libcpp_verbose_abort);
127 #endif
128 
129 // RUN: %{build} -DTEST_13
130 #if defined(TEST_13)
131 #   include <charconv>
132     using HandlerType = decltype(std::__libcpp_verbose_abort);
133 #endif
134 
135 // RUN: %{build} -DTEST_14
136 #if defined(TEST_14)
137 #   include <chrono>
138     using HandlerType = decltype(std::__libcpp_verbose_abort);
139 #endif
140 
141 // RUN: %{build} -DTEST_15
142 #if defined(TEST_15)
143 #   include <cinttypes>
144     using HandlerType = decltype(std::__libcpp_verbose_abort);
145 #endif
146 
147 // RUN: %{build} -DTEST_16
148 #if defined(TEST_16)
149 #   include <ciso646>
150     using HandlerType = decltype(std::__libcpp_verbose_abort);
151 #endif
152 
153 // RUN: %{build} -DTEST_17
154 #if defined(TEST_17)
155 #   include <climits>
156     using HandlerType = decltype(std::__libcpp_verbose_abort);
157 #endif
158 
159 // RUN: %{build} -DTEST_18
160 #if defined(TEST_18) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
161 #   include <clocale>
162     using HandlerType = decltype(std::__libcpp_verbose_abort);
163 #endif
164 
165 // RUN: %{build} -DTEST_19
166 #if defined(TEST_19)
167 #   include <cmath>
168     using HandlerType = decltype(std::__libcpp_verbose_abort);
169 #endif
170 
171 // RUN: %{build} -DTEST_20
172 #if defined(TEST_20) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
173 #   include <codecvt>
174     using HandlerType = decltype(std::__libcpp_verbose_abort);
175 #endif
176 
177 // RUN: %{build} -DTEST_21
178 #if defined(TEST_21)
179 #   include <compare>
180     using HandlerType = decltype(std::__libcpp_verbose_abort);
181 #endif
182 
183 // RUN: %{build} -DTEST_22
184 #if defined(TEST_22)
185 #   include <complex>
186     using HandlerType = decltype(std::__libcpp_verbose_abort);
187 #endif
188 
189 // RUN: %{build} -DTEST_24
190 #if defined(TEST_24)
191 #   include <concepts>
192     using HandlerType = decltype(std::__libcpp_verbose_abort);
193 #endif
194 
195 // RUN: %{build} -DTEST_25
196 #if defined(TEST_25)
197 #   include <condition_variable>
198     using HandlerType = decltype(std::__libcpp_verbose_abort);
199 #endif
200 
201 // RUN: %{build} -DTEST_26
202 #if defined(TEST_26)
203 #   include <coroutine>
204     using HandlerType = decltype(std::__libcpp_verbose_abort);
205 #endif
206 
207 // RUN: %{build} -DTEST_27
208 #if defined(TEST_27)
209 #   include <csetjmp>
210     using HandlerType = decltype(std::__libcpp_verbose_abort);
211 #endif
212 
213 // RUN: %{build} -DTEST_28
214 #if defined(TEST_28)
215 #   include <csignal>
216     using HandlerType = decltype(std::__libcpp_verbose_abort);
217 #endif
218 
219 // RUN: %{build} -DTEST_29
220 #if defined(TEST_29)
221 #   include <cstdarg>
222     using HandlerType = decltype(std::__libcpp_verbose_abort);
223 #endif
224 
225 // RUN: %{build} -DTEST_30
226 #if defined(TEST_30)
227 #   include <cstdbool>
228     using HandlerType = decltype(std::__libcpp_verbose_abort);
229 #endif
230 
231 // RUN: %{build} -DTEST_31
232 #if defined(TEST_31)
233 #   include <cstddef>
234     using HandlerType = decltype(std::__libcpp_verbose_abort);
235 #endif
236 
237 // RUN: %{build} -DTEST_32
238 #if defined(TEST_32)
239 #   include <cstdint>
240     using HandlerType = decltype(std::__libcpp_verbose_abort);
241 #endif
242 
243 // RUN: %{build} -DTEST_33
244 #if defined(TEST_33)
245 #   include <cstdio>
246     using HandlerType = decltype(std::__libcpp_verbose_abort);
247 #endif
248 
249 // RUN: %{build} -DTEST_34
250 #if defined(TEST_34)
251 #   include <cstdlib>
252     using HandlerType = decltype(std::__libcpp_verbose_abort);
253 #endif
254 
255 // RUN: %{build} -DTEST_35
256 #if defined(TEST_35)
257 #   include <cstring>
258     using HandlerType = decltype(std::__libcpp_verbose_abort);
259 #endif
260 
261 // RUN: %{build} -DTEST_36
262 #if defined(TEST_36)
263 #   include <ctgmath>
264     using HandlerType = decltype(std::__libcpp_verbose_abort);
265 #endif
266 
267 // RUN: %{build} -DTEST_37
268 #if defined(TEST_37)
269 #   include <ctime>
270     using HandlerType = decltype(std::__libcpp_verbose_abort);
271 #endif
272 
273 // RUN: %{build} -DTEST_39
274 #if defined(TEST_39)
275 #   include <cuchar>
276     using HandlerType = decltype(std::__libcpp_verbose_abort);
277 #endif
278 
279 // RUN: %{build} -DTEST_40
280 #if defined(TEST_40) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
281 #   include <cwchar>
282     using HandlerType = decltype(std::__libcpp_verbose_abort);
283 #endif
284 
285 // RUN: %{build} -DTEST_41
286 #if defined(TEST_41) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
287 #   include <cwctype>
288     using HandlerType = decltype(std::__libcpp_verbose_abort);
289 #endif
290 
291 // RUN: %{build} -DTEST_42
292 #if defined(TEST_42)
293 #   include <deque>
294     using HandlerType = decltype(std::__libcpp_verbose_abort);
295 #endif
296 
297 // RUN: %{build} -DTEST_44
298 #if defined(TEST_44)
299 #   include <exception>
300     using HandlerType = decltype(std::__libcpp_verbose_abort);
301 #endif
302 
303 // RUN: %{build} -DTEST_45
304 #if defined(TEST_45)
305 #   include <execution>
306     using HandlerType = decltype(std::__libcpp_verbose_abort);
307 #endif
308 
309 // RUN: %{build} -DTEST_47
310 #if defined(TEST_47) && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
311 #   include <filesystem>
312     using HandlerType = decltype(std::__libcpp_verbose_abort);
313 #endif
314 
315 // RUN: %{build} -DTEST_49
316 #if defined(TEST_49)
317 #   include <format>
318     using HandlerType = decltype(std::__libcpp_verbose_abort);
319 #endif
320 
321 // RUN: %{build} -DTEST_50
322 #if defined(TEST_50)
323 #   include <forward_list>
324     using HandlerType = decltype(std::__libcpp_verbose_abort);
325 #endif
326 
327 // RUN: %{build} -DTEST_51
328 #if defined(TEST_51) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
329 #   include <fstream>
330     using HandlerType = decltype(std::__libcpp_verbose_abort);
331 #endif
332 
333 // RUN: %{build} -DTEST_52
334 #if defined(TEST_52)
335 #   include <functional>
336     using HandlerType = decltype(std::__libcpp_verbose_abort);
337 #endif
338 
339 // RUN: %{build} -DTEST_53
340 #if defined(TEST_53) && !defined(_LIBCPP_HAS_NO_THREADS)
341 #   include <future>
342     using HandlerType = decltype(std::__libcpp_verbose_abort);
343 #endif
344 
345 // RUN: %{build} -DTEST_54
346 #if defined(TEST_54)
347 #   include <initializer_list>
348     using HandlerType = decltype(std::__libcpp_verbose_abort);
349 #endif
350 
351 // RUN: %{build} -DTEST_56
352 #if defined(TEST_56) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
353 #   include <iomanip>
354     using HandlerType = decltype(std::__libcpp_verbose_abort);
355 #endif
356 
357 // RUN: %{build} -DTEST_57
358 #if defined(TEST_57) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
359 #   include <ios>
360     using HandlerType = decltype(std::__libcpp_verbose_abort);
361 #endif
362 
363 // RUN: %{build} -DTEST_58
364 #if defined(TEST_58)
365 #   include <iosfwd>
366     using HandlerType = decltype(std::__libcpp_verbose_abort);
367 #endif
368 
369 // RUN: %{build} -DTEST_59
370 #if defined(TEST_59) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
371 #   include <iostream>
372     using HandlerType = decltype(std::__libcpp_verbose_abort);
373 #endif
374 
375 // RUN: %{build} -DTEST_60
376 #if defined(TEST_60) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
377 #   include <istream>
378     using HandlerType = decltype(std::__libcpp_verbose_abort);
379 #endif
380 
381 // RUN: %{build} -DTEST_61
382 #if defined(TEST_61)
383 #   include <iterator>
384     using HandlerType = decltype(std::__libcpp_verbose_abort);
385 #endif
386 
387 // RUN: %{build} -DTEST_62
388 #if defined(TEST_62) && !defined(_LIBCPP_HAS_NO_THREADS)
389 #   include <latch>
390     using HandlerType = decltype(std::__libcpp_verbose_abort);
391 #endif
392 
393 // RUN: %{build} -DTEST_63
394 #if defined(TEST_63)
395 #   include <limits>
396     using HandlerType = decltype(std::__libcpp_verbose_abort);
397 #endif
398 
399 // RUN: %{build} -DTEST_65
400 #if defined(TEST_65)
401 #   include <list>
402     using HandlerType = decltype(std::__libcpp_verbose_abort);
403 #endif
404 
405 // RUN: %{build} -DTEST_66
406 #if defined(TEST_66) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
407 #   include <locale>
408     using HandlerType = decltype(std::__libcpp_verbose_abort);
409 #endif
410 
411 // RUN: %{build} -DTEST_68
412 #if defined(TEST_68)
413 #   include <map>
414     using HandlerType = decltype(std::__libcpp_verbose_abort);
415 #endif
416 
417 // RUN: %{build} -DTEST_70
418 #if defined(TEST_70)
419 #   include <memory>
420     using HandlerType = decltype(std::__libcpp_verbose_abort);
421 #endif
422 
423 // RUN: %{build} -DTEST_71
424 #if defined(TEST_71) && !defined(_LIBCPP_HAS_NO_THREADS)
425 #   include <mutex>
426     using HandlerType = decltype(std::__libcpp_verbose_abort);
427 #endif
428 
429 // RUN: %{build} -DTEST_72
430 #if defined(TEST_72)
431 #   include <new>
432     using HandlerType = decltype(std::__libcpp_verbose_abort);
433 #endif
434 
435 // RUN: %{build} -DTEST_73
436 #if defined(TEST_73)
437 #   include <numbers>
438     using HandlerType = decltype(std::__libcpp_verbose_abort);
439 #endif
440 
441 // RUN: %{build} -DTEST_74
442 #if defined(TEST_74)
443 #   include <numeric>
444     using HandlerType = decltype(std::__libcpp_verbose_abort);
445 #endif
446 
447 // RUN: %{build} -DTEST_75
448 #if defined(TEST_75)
449 #   include <optional>
450     using HandlerType = decltype(std::__libcpp_verbose_abort);
451 #endif
452 
453 // RUN: %{build} -DTEST_76
454 #if defined(TEST_76) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
455 #   include <ostream>
456     using HandlerType = decltype(std::__libcpp_verbose_abort);
457 #endif
458 
459 // RUN: %{build} -DTEST_77
460 #if defined(TEST_77)
461 #   include <queue>
462     using HandlerType = decltype(std::__libcpp_verbose_abort);
463 #endif
464 
465 // RUN: %{build} -DTEST_78
466 #if defined(TEST_78)
467 #   include <random>
468     using HandlerType = decltype(std::__libcpp_verbose_abort);
469 #endif
470 
471 // RUN: %{build} -DTEST_79
472 #if defined(TEST_79)
473 #   include <ranges>
474     using HandlerType = decltype(std::__libcpp_verbose_abort);
475 #endif
476 
477 // RUN: %{build} -DTEST_80
478 #if defined(TEST_80)
479 #   include <ratio>
480     using HandlerType = decltype(std::__libcpp_verbose_abort);
481 #endif
482 
483 // RUN: %{build} -DTEST_81
484 #if defined(TEST_81) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
485 #   include <regex>
486     using HandlerType = decltype(std::__libcpp_verbose_abort);
487 #endif
488 
489 // RUN: %{build} -DTEST_82
490 #if defined(TEST_82)
491 #   include <scoped_allocator>
492     using HandlerType = decltype(std::__libcpp_verbose_abort);
493 #endif
494 
495 // RUN: %{build} -DTEST_83
496 #if defined(TEST_83) && !defined(_LIBCPP_HAS_NO_THREADS)
497 #   include <semaphore>
498     using HandlerType = decltype(std::__libcpp_verbose_abort);
499 #endif
500 
501 // RUN: %{build} -DTEST_84
502 #if defined(TEST_84)
503 #   include <set>
504     using HandlerType = decltype(std::__libcpp_verbose_abort);
505 #endif
506 
507 // RUN: %{build} -DTEST_86
508 #if defined(TEST_86) && !defined(_LIBCPP_HAS_NO_THREADS)
509 #   include <shared_mutex>
510     using HandlerType = decltype(std::__libcpp_verbose_abort);
511 #endif
512 
513 // RUN: %{build} -DTEST_87
514 #if defined(TEST_87)
515 #   include <span>
516     using HandlerType = decltype(std::__libcpp_verbose_abort);
517 #endif
518 
519 // RUN: %{build} -DTEST_88
520 #if defined(TEST_88) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
521 #   include <sstream>
522     using HandlerType = decltype(std::__libcpp_verbose_abort);
523 #endif
524 
525 // RUN: %{build} -DTEST_89
526 #if defined(TEST_89)
527 #   include <stack>
528     using HandlerType = decltype(std::__libcpp_verbose_abort);
529 #endif
530 
531 // RUN: %{build} -DTEST_93
532 #if defined(TEST_93)
533 #   include <stdexcept>
534     using HandlerType = decltype(std::__libcpp_verbose_abort);
535 #endif
536 
537 // RUN: %{build} -DTEST_97
538 #if defined(TEST_97) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
539 #   include <streambuf>
540     using HandlerType = decltype(std::__libcpp_verbose_abort);
541 #endif
542 
543 // RUN: %{build} -DTEST_98
544 #if defined(TEST_98)
545 #   include <string>
546     using HandlerType = decltype(std::__libcpp_verbose_abort);
547 #endif
548 
549 // RUN: %{build} -DTEST_100
550 #if defined(TEST_100)
551 #   include <string_view>
552     using HandlerType = decltype(std::__libcpp_verbose_abort);
553 #endif
554 
555 // RUN: %{build} -DTEST_101
556 #if defined(TEST_101) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
557 #   include <strstream>
558     using HandlerType = decltype(std::__libcpp_verbose_abort);
559 #endif
560 
561 // RUN: %{build} -DTEST_102
562 #if defined(TEST_102)
563 #   include <system_error>
564     using HandlerType = decltype(std::__libcpp_verbose_abort);
565 #endif
566 
567 // RUN: %{build} -DTEST_104
568 #if defined(TEST_104) && !defined(_LIBCPP_HAS_NO_THREADS)
569 #   include <thread>
570     using HandlerType = decltype(std::__libcpp_verbose_abort);
571 #endif
572 
573 // RUN: %{build} -DTEST_105
574 #if defined(TEST_105)
575 #   include <tuple>
576     using HandlerType = decltype(std::__libcpp_verbose_abort);
577 #endif
578 
579 // RUN: %{build} -DTEST_106
580 #if defined(TEST_106)
581 #   include <type_traits>
582     using HandlerType = decltype(std::__libcpp_verbose_abort);
583 #endif
584 
585 // RUN: %{build} -DTEST_107
586 #if defined(TEST_107)
587 #   include <typeindex>
588     using HandlerType = decltype(std::__libcpp_verbose_abort);
589 #endif
590 
591 // RUN: %{build} -DTEST_108
592 #if defined(TEST_108)
593 #   include <typeinfo>
594     using HandlerType = decltype(std::__libcpp_verbose_abort);
595 #endif
596 
597 // RUN: %{build} -DTEST_110
598 #if defined(TEST_110)
599 #   include <unordered_map>
600     using HandlerType = decltype(std::__libcpp_verbose_abort);
601 #endif
602 
603 // RUN: %{build} -DTEST_111
604 #if defined(TEST_111)
605 #   include <unordered_set>
606     using HandlerType = decltype(std::__libcpp_verbose_abort);
607 #endif
608 
609 // RUN: %{build} -DTEST_112
610 #if defined(TEST_112)
611 #   include <utility>
612     using HandlerType = decltype(std::__libcpp_verbose_abort);
613 #endif
614 
615 // RUN: %{build} -DTEST_113
616 #if defined(TEST_113)
617 #   include <valarray>
618     using HandlerType = decltype(std::__libcpp_verbose_abort);
619 #endif
620 
621 // RUN: %{build} -DTEST_114
622 #if defined(TEST_114)
623 #   include <variant>
624     using HandlerType = decltype(std::__libcpp_verbose_abort);
625 #endif
626 
627 // RUN: %{build} -DTEST_115
628 #if defined(TEST_115)
629 #   include <vector>
630     using HandlerType = decltype(std::__libcpp_verbose_abort);
631 #endif
632 
633 // RUN: %{build} -DTEST_116
634 #if defined(TEST_116)
635 #   include <version>
636     using HandlerType = decltype(std::__libcpp_verbose_abort);
637 #endif
638 
639 // RUN: %{build} -DTEST_119
640 #if defined(TEST_119) && __cplusplus >= 201103L
641 #   include <experimental/algorithm>
642     using HandlerType = decltype(std::__libcpp_verbose_abort);
643 #endif
644 
645 // RUN: %{build} -DTEST_120
646 #if defined(TEST_120) && __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
647 #   include <experimental/coroutine>
648     using HandlerType = decltype(std::__libcpp_verbose_abort);
649 #endif
650 
651 // RUN: %{build} -DTEST_121
652 #if defined(TEST_121) && __cplusplus >= 201103L
653 #   include <experimental/deque>
654     using HandlerType = decltype(std::__libcpp_verbose_abort);
655 #endif
656 
657 // RUN: %{build} -DTEST_122
658 #if defined(TEST_122) && __cplusplus >= 201103L
659 #   include <experimental/forward_list>
660     using HandlerType = decltype(std::__libcpp_verbose_abort);
661 #endif
662 
663 // RUN: %{build} -DTEST_123
664 #if defined(TEST_123) && __cplusplus >= 201103L
665 #   include <experimental/functional>
666     using HandlerType = decltype(std::__libcpp_verbose_abort);
667 #endif
668 
669 // RUN: %{build} -DTEST_124
670 #if defined(TEST_124) && __cplusplus >= 201103L
671 #   include <experimental/iterator>
672     using HandlerType = decltype(std::__libcpp_verbose_abort);
673 #endif
674 
675 // RUN: %{build} -DTEST_125
676 #if defined(TEST_125) && __cplusplus >= 201103L
677 #   include <experimental/list>
678     using HandlerType = decltype(std::__libcpp_verbose_abort);
679 #endif
680 
681 // RUN: %{build} -DTEST_126
682 #if defined(TEST_126) && __cplusplus >= 201103L
683 #   include <experimental/map>
684     using HandlerType = decltype(std::__libcpp_verbose_abort);
685 #endif
686 
687 // RUN: %{build} -DTEST_127
688 #if defined(TEST_127) && __cplusplus >= 201103L
689 #   include <experimental/memory_resource>
690     using HandlerType = decltype(std::__libcpp_verbose_abort);
691 #endif
692 
693 // RUN: %{build} -DTEST_128
694 #if defined(TEST_128) && __cplusplus >= 201103L
695 #   include <experimental/propagate_const>
696     using HandlerType = decltype(std::__libcpp_verbose_abort);
697 #endif
698 
699 // RUN: %{build} -DTEST_129
700 #if defined(TEST_129) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
701 #   include <experimental/regex>
702     using HandlerType = decltype(std::__libcpp_verbose_abort);
703 #endif
704 
705 // RUN: %{build} -DTEST_130
706 #if defined(TEST_130) && __cplusplus >= 201103L
707 #   include <experimental/set>
708     using HandlerType = decltype(std::__libcpp_verbose_abort);
709 #endif
710 
711 // RUN: %{build} -DTEST_131
712 #if defined(TEST_131) && __cplusplus >= 201103L
713 #   include <experimental/simd>
714     using HandlerType = decltype(std::__libcpp_verbose_abort);
715 #endif
716 
717 // RUN: %{build} -DTEST_132
718 #if defined(TEST_132) && __cplusplus >= 201103L
719 #   include <experimental/string>
720     using HandlerType = decltype(std::__libcpp_verbose_abort);
721 #endif
722 
723 // RUN: %{build} -DTEST_133
724 #if defined(TEST_133) && __cplusplus >= 201103L
725 #   include <experimental/type_traits>
726     using HandlerType = decltype(std::__libcpp_verbose_abort);
727 #endif
728 
729 // RUN: %{build} -DTEST_134
730 #if defined(TEST_134) && __cplusplus >= 201103L
731 #   include <experimental/unordered_map>
732     using HandlerType = decltype(std::__libcpp_verbose_abort);
733 #endif
734 
735 // RUN: %{build} -DTEST_135
736 #if defined(TEST_135) && __cplusplus >= 201103L
737 #   include <experimental/unordered_set>
738     using HandlerType = decltype(std::__libcpp_verbose_abort);
739 #endif
740 
741 // RUN: %{build} -DTEST_136
742 #if defined(TEST_136) && __cplusplus >= 201103L
743 #   include <experimental/utility>
744     using HandlerType = decltype(std::__libcpp_verbose_abort);
745 #endif
746 
747 // RUN: %{build} -DTEST_137
748 #if defined(TEST_137) && __cplusplus >= 201103L
749 #   include <experimental/vector>
750     using HandlerType = decltype(std::__libcpp_verbose_abort);
751 #endif
752 
753 // RUN: %{build} -DTEST_138
754 #if defined(TEST_138)
755 #   include <ext/hash_map>
756     using HandlerType = decltype(std::__libcpp_verbose_abort);
757 #endif
758 
759 // RUN: %{build} -DTEST_139
760 #if defined(TEST_139)
761 #   include <ext/hash_set>
762     using HandlerType = decltype(std::__libcpp_verbose_abort);
763 #endif
764 
765 // GENERATED-MARKER
766