This is an archive of the discontinued LLVM Phabricator instance.

Differential D146675

[libc++] Warn on including headers that are deprecated in C++17
AbandonedPublic

Authored by Mordante on Mar 22 2023, 5:13 PM.

Details

Reviewers
cjdb
philnik
ayzhao
Group Reviewers
Restricted Project
Summary

The headers ccomplex, cstdbool, and ctgmath have been marked as
deprecated in C++17, so this patch adds a #warning preprocessor
directive to these headers if they're used in a context where the C++
version is >= 17.

Additionally, update tests and remove includes of deprecated headers in
existing non-deprecated headers.

Diff Detail

Event Timeline

ayzhao created this revision.Mar 22 2023, 5:13 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 22 2023, 5:13 PM
Herald added subscribers: mikhail.ramalho, arichardson. · View Herald Transcript
ayzhao requested review of this revision.Mar 22 2023, 5:13 PM
Herald added a project: Restricted Project. · View Herald TranscriptMar 22 2023, 5:13 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
ayzhao retitled this revision from [libc++] Warn on including headers deprecated in C++17 to [libc++] Warn on including headers that are deprecated in C++17.Mar 22 2023, 5:16 PM
cjdb added inline comments.Mar 22 2023, 5:24 PM
libcxx/include/ccomplex
24
  • "removed as of C++20" increases the urgency of the diagnostic.
  • "Header" bit removed since that will be implied by context.
  • Added backticks to support SARIF diagnostics rendering this in Markdown.

Same comment applies below.

ayzhao updated this revision to Diff 507561.Mar 22 2023, 5:32 PM
ayzhao marked an inline comment as done.

update warning message per review comments

ayzhao updated this revision to Diff 507563.Mar 22 2023, 5:41 PM

remove quotes from warning message

cjdb accepted this revision.Mar 22 2023, 5:43 PM

LGTM from a diagnostic perspective!

Harbormaster completed remote builds in B221183: Diff 507563.Mar 23 2023, 12:08 AM
thakis added a subscriber: thakis.Mar 23 2023, 12:14 AM

Ms stl uses this construction to make the warning grouped under -Wdeprecated-declarations: https://github.com/search?q=repo%3Amicrosoft%2FSTL%20_CXX17_DEPRECATE_C_HEADER&type=code

Many worth doing?

philnik requested changes to this revision.Mar 23 2023, 2:51 AM
philnik added a subscriber: philnik.
philnik added inline comments.
libcxx/include/ccomplex
24

I don't think we want to say "and removed in C++20" if we don't actually remove the header. We'd have to move these headers into their own directory and teach clang about that, and this seems like quite a bit of work to remove these headers (although it might clean up the code base a bit).

24

Otherwise it just results in problems. Clang should just remove the quotes if the warning consists only of a string literal.

libcxx/include/complex.h
27–28

Why do we need this include now?

libcxx/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
11

Where did you get c++0x and c++1y from? I can't find anything in the code base.

libcxx/test/libcxx/transitive_includes.sh.cpp
52
libcxx/utils/generate_header_tests.py
64–67

We shouldn't disable the tests just because the headers are deprecated. It's still fine to use them in C++17.

This revision now requires changes to proceed.Mar 23 2023, 2:51 AM
ayzhao updated this revision to Diff 507797.Mar 23 2023, 10:28 AM
ayzhao marked 5 inline comments as done.

code review comments

ayzhao added a comment.Mar 23 2023, 10:28 AM
In D146675#4215557, @thakis wrote:

Ms stl uses this construction to make the warning grouped under -Wdeprecated-declarations: https://github.com/search?q=repo%3Amicrosoft%2FSTL%20_CXX17_DEPRECATE_C_HEADER&type=code

Many worth doing?

The problem with this approach (and with #pragma message, as I discovered earlier), is that the warning doesn't show up if the path to libc++ is passed via -isystem:

$ cat /tmp/llvm/include/c++/v1/cstdbool
// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_CSTDBOOL
#define _LIBCPP_CSTDBOOL

/*
    cstdbool synopsis

Macros:

    __bool_true_false_are_defined

*/

#include <__assert> // all public C++ headers provide the assertion handler
#include <__config>

using _HEADER_cstdbool [[deprecated("hello, world")]] = int;
using _Hdr_cstdbool = _HEADER_cstdbool ;

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#  pragma GCC system_header
#endif

#undef __bool_true_false_are_defined
#define __bool_true_false_are_defined 1

#endif // _LIBCPP_CSTDBOOL

$ cat include-deprecated.cc
#include <cstdbool>

$ clang++ -nostdinc++ -isystem/tmp/llvm/include/c++/v1 -c -o /dev/null include-deprecated.cc -std=c++20 -Wdeprecated-declarations
(nothing shows up)

@cjdb suggested implementing this with #warning, but I'll leave it up to the libc++ maintainers to decide on the best way forward. Any thoughts @philnik ?

libcxx/include/complex.h
27–28

Removed. I included it here since <ccomplex> originally included it, but now that I look at it, it seems like it doesn't matter.

libcxx/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
11

These are mentioned in params.py: https://github.com/llvm/llvm-project/blob/de939c6cd80c1e88913f1ef12be11aea501eb89b/libcxx/utils/libcxx/test/params.py#L60-L61

cjdb added inline comments.Mar 23 2023, 12:43 PM
libcxx/include/ccomplex
24

I don't think we want to say "and removed in C++20" if we don't actually remove the header. We'd have to move these headers into their own directory and teach clang about that, and this seems like quite a bit of work to remove these headers (although it might clean up the code base a bit).

It's implementable in library.

#if __cplusplus >= 202003L
#  error `<ccomplex>` removed in C++20.
#elif __cplusplus == 201703L
#  warning `<ccomplex>` deprecated in C++17
#endif

Otherwise it just results in problems. Clang should just remove the quotes if the warning consists only of a string literal.

What problems are those?

Mordante added a subscriber: Mordante.Mar 24 2023, 10:03 AM

I have not looked closely at the patch, can you please add the paper number in the summary and update the status page
libcxx/doc/Status? That makes reviewing the changes a lot easier.

libcxx/test/std/language.support/support.runtime/cstdbool.pass.cpp
11

Why not using the UNSUPPORTED like we usually do?

ayzhao added a comment.Mar 24 2023, 10:36 AM
In D146675#4219987, @Mordante wrote:

I have not looked closely at the patch, can you please add the paper number in the summary and update the status page
libcxx/doc/Status? That makes reviewing the changes a lot easier.

The headers were marked deprecated in p0063r3, which, interestingly enough, is already marked complete in the status page.

libcxx/test/std/language.support/support.runtime/cstdbool.pass.cpp
11

My idea was that by using XFAIL, we can test that the deprecation warning works (since we build with -Werror).

Harbormaster completed remote builds in B221354: Diff 507797.Mar 25 2023, 9:35 AM
philnik added inline comments.Mar 27 2023, 2:00 AM
libcxx/include/ccomplex
24

That would break __has_include(<ccomplex>) though. What's the point of that feature if you can't actually rely on it?

The compilers sometimes produce random additional warnings: https://godbolt.org/z/fE7x6E11r

libcxx/include/tgmath.h
27–29

Also here.

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.sh.cpp
49

Also for the comment in the other tests.

50

and move it near the XFAIL above.

libcxx/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp
11

You've got it the wrong way around :). The code you linked to treats them as equal compiler flags, i.e. -std=c++11 is the same as -std=c++0x and c++11 is the lit feature that's set. So you only have to test c++11 || c++14 || c++17 (and disable the deprecation warning).

libcxx/test/std/language.support/support.runtime/cstdbool.pass.cpp
11

That should instead be done with a .verify.cpp. You can also run the test suite without warnings enabled, and having an XFAIL from a warning would break this. The .verify.cpp also checks what warnings/errors are generated instead of just XFAILing for any reason.

Mordante requested changes to this revision.Apr 8 2023, 5:09 AM
In D146675#4220118, @ayzhao wrote:
In D146675#4219987, @Mordante wrote:

I have not looked closely at the patch, can you please add the paper number in the summary and update the status page
libcxx/doc/Status? That makes reviewing the changes a lot easier.

The headers were marked deprecated in p0063r3, which, interestingly enough, is already marked complete in the status page.

Thanks for the info.

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.sh.cpp
50

This will fail when running the tests with _LIBCPP_DISABLE_DEPRECATION_WARNINGS already defined.

I'm not really happy with blanket disabling the deprecation warnings in tests. Basically this changes the behaviour of these tests and they are not tested in the typical libc++ configuration. I really would like to see a more fine-grained approach in the basic generation script instead of this approach.

This revision now requires changes to proceed.Apr 8 2023, 5:09 AM
Mordante commandeered this revision.Aug 31 2023, 12:27 PM
Mordante edited reviewers, added: ayzhao; removed: Mordante.

This patch is inactive for quite a while. We're moving to GitHub and want to clean up the patch review queue. If you want to pursue this patch, please file a new patch as GitHub PR. I'll close the patch for now,

Mordante abandoned this revision.Aug 31 2023, 12:27 PM
ayzhao added a comment.Aug 31 2023, 12:32 PM
In D146675#4632294, @Mordante wrote:

This patch is inactive for quite a while. We're moving to GitHub and want to clean up the patch review queue. If you want to pursue this patch, please file a new patch as GitHub PR. I'll close the patch for now,

Sorry for leaving this patch in your review queue for such a long time - I haven't had the bandwidth to move this forward, and I doubt I will in the foreseeable future.

Revision Contents

PathSize
libcxx/
include/
4 lines
3 lines
4 lines
4 lines
4 lines
test/
libcxx/
assertions/
6 lines
12 lines
12 lines
language.support/
support.runtime/
3 lines
12 lines
288 lines
12 lines
12 lines
numerics/
c.math/
3 lines
complex.number/
ccmplx/
3 lines
245 lines
std/
language.support/
support.runtime/
3 lines
numerics/
c.math/
3 lines
complex.number/
ccmplx/
3 lines
utils/
4 lines

Diff 507561

libcxx/include/ccomplex

Show All 14 Lines
#include <complex> #include <complex>
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <complex> #include <complex>
#if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && _LIBCPP_STD_VER >= 17
# warning "`<ccomplex>` is deprecated in C++17 and removed in C++20"
cjdbUnsubmitted
Done
ReplyInline Actions
#if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && _LIBCPP_STD_VER >= 17
- # warning "Header <ccomplex> is deprecated in C++17"
+ # warning "`<ccomplex>` is deprecated in C++17 and removed in C++20"
#endif
  • "removed as of C++20" increases the urgency of the diagnostic.
  • "Header" bit removed since that will be implied by context.
  • Added backticks to support SARIF diagnostics rendering this in Markdown.

Same comment applies below.

cjdb: * "removed as of C++20" increases the urgency of the diagnostic. * "Header" bit removed since…
philnikUnsubmitted
Done
ReplyInline Actions

I don't think we want to say "and removed in C++20" if we don't actually remove the header. We'd have to move these headers into their own directory and teach clang about that, and this seems like quite a bit of work to remove these headers (although it might clean up the code base a bit).

philnik: I don't think we want to say "and removed in C++20" if we don't actually remove the header.
cjdbUnsubmitted
Not Done
ReplyInline Actions

I don't think we want to say "and removed in C++20" if we don't actually remove the header. We'd have to move these headers into their own directory and teach clang about that, and this seems like quite a bit of work to remove these headers (although it might clean up the code base a bit).

It's implementable in library.

#if __cplusplus >= 202003L
#  error `<ccomplex>` removed in C++20.
#elif __cplusplus == 201703L
#  warning `<ccomplex>` deprecated in C++17
#endif

Otherwise it just results in problems. Clang should just remove the quotes if the warning consists only of a string literal.

What problems are those?

cjdb: > I don't think we want to say "and removed in C++20" if we don't actually remove the header.
philnikUnsubmitted
Not Done
ReplyInline Actions

That would break __has_include(<ccomplex>) though. What's the point of that feature if you can't actually rely on it?

The compilers sometimes produce random additional warnings: https://godbolt.org/z/fE7x6E11r

philnik: That would break `__has_include(<ccomplex>)` though. What's the point of that feature if you…
philnikUnsubmitted
Done
ReplyInline Actions
#if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && _LIBCPP_STD_VER >= 17
- # warning `<ccomplex>` is deprecated in C++17 and removed in C++20
+ # warning "`<ccomplex>` is deprecated in C++17 and removed in C++20"
#endif

Otherwise it just results in problems. Clang should just remove the quotes if the warning consists only of a string literal.

philnik: Otherwise it just results in problems. Clang should just remove the quotes if the warning…
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_CCOMPLEX #endif // _LIBCPP_CCOMPLEX

libcxx/include/complex.h

Show All 18 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
# include <ccomplex> # include <__assert>
# include <complex>
philnikUnsubmitted
Done
ReplyInline Actions

Why do we need this include now?

philnik: Why do we need this include now?
ayzhaoUnsubmitted
Done
ReplyInline Actions

Removed. I included it here since <ccomplex> originally included it, but now that I look at it, it seems like it doesn't matter.

ayzhao: Removed. I included it here since `<ccomplex>` originally included it, but now that I look at…
#elif __has_include_next(<complex.h>) #elif __has_include_next(<complex.h>)
# include_next <complex.h> # include_next <complex.h>
#endif #endif
#endif // _LIBCPP_COMPLEX_H #endif // _LIBCPP_COMPLEX_H

libcxx/include/cstdbool

Show All 16 LinesMacros:
__bool_true_false_are_defined __bool_true_false_are_defined
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && _LIBCPP_STD_VER >= 17
# warning "`<cstdbool>` is deprecated in C++17 and removed in C++20"
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#undef __bool_true_false_are_defined #undef __bool_true_false_are_defined
#define __bool_true_false_are_defined 1 #define __bool_true_false_are_defined 1
#endif // _LIBCPP_CSTDBOOL #endif // _LIBCPP_CSTDBOOL

libcxx/include/ctgmath

Show All 16 Lines
#include <cmath> #include <cmath>
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <ccomplex> #include <ccomplex>
#include <cmath> #include <cmath>
#if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && _LIBCPP_STD_VER >= 17
# warning "`<ctgmath>` is deprecated in C++17 and removed in C++20"
#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#endif // _LIBCPP_CTGMATH #endif // _LIBCPP_CTGMATH

libcxx/include/tgmath.h

Show All 18 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
# include <ctgmath> # include <__assert>
# include <complex>
# include <cmath>
philnikUnsubmitted
Not Done
ReplyInline Actions

Also here.

philnik: Also here.
#else #else
# if __has_include_next(<tgmath.h>) # if __has_include_next(<tgmath.h>)
# include_next <tgmath.h> # include_next <tgmath.h>
# endif # endif
#endif #endif
#endif // _LIBCPP_TGMATH_H #endif // _LIBCPP_TGMATH_H

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.sh.cpp

Show All 40 Lines
#include <__config> #include <__config>
// Prevent <ext/hash_map> from generating deprecated warnings for this test. // Prevent <ext/hash_map> from generating deprecated warnings for this test.
#if defined(__DEPRECATED) #if defined(__DEPRECATED)
# undef __DEPRECATED # undef __DEPRECATED
#endif #endif
int main(int, char**) { return 0; } int main(int, char**) { return 0; }
philnikUnsubmitted
Not Done
ReplyInline Actions
#endif
- // Prevent <ccomplex>, <cstdbool>, and <ctgmath from generating deprecated warnings for this test.
+ // Prevent <ccomplex>, <cstdbool>, and <ctgmath> from generating deprecated warnings for this test.
#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS

Also for the comment in the other tests.

philnik: Also for the comment in the other tests.
philnikUnsubmitted
Not Done
ReplyInline Actions
// Prevent <ccomplex>, <cstdbool>, and <ctgmath from generating deprecated warnings for this test.
- #define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+ // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
int main(int, char**) { return 0; }

and move it near the XFAIL above.

philnik: and move it near the `XFAIL` above.
MordanteAuthorUnsubmitted
Not Done
ReplyInline Actions

This will fail when running the tests with _LIBCPP_DISABLE_DEPRECATION_WARNINGS already defined.

I'm not really happy with blanket disabling the deprecation warnings in tests. Basically this changes the behaviour of these tests and they are not tested in the typical libc++ configuration. I really would like to see a more fine-grained approach in the basic generation script instead of this approach.

Mordante: This will fail when running the tests with `_LIBCPP_DISABLE_DEPRECATION_WARNINGS` already…
// DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW // DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW
// GENERATED-MARKER // GENERATED-MARKER
// RUN: %{build} -DTEST_0 // RUN: %{build} -DTEST_0
#if defined(TEST_0) #if defined(TEST_0)
# include <algorithm> # include <algorithm>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
Show All 35 Lines
// RUN: %{build} -DTEST_7 // RUN: %{build} -DTEST_7
#if defined(TEST_7) #if defined(TEST_7)
# include <cassert> # include <cassert>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_8 // RUN: %{build} -DTEST_8
#if defined(TEST_8) #if defined(TEST_8) && __cplusplus < 201703L
# include <ccomplex> # include <ccomplex>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_9 // RUN: %{build} -DTEST_9
#if defined(TEST_9) #if defined(TEST_9)
# include <cctype> # include <cctype>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
// RUN: %{build} -DTEST_29 // RUN: %{build} -DTEST_29
#if defined(TEST_29) #if defined(TEST_29)
# include <cstdarg> # include <cstdarg>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_30 // RUN: %{build} -DTEST_30
#if defined(TEST_30) #if defined(TEST_30) && __cplusplus < 201703L
# include <cstdbool> # include <cstdbool>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_31 // RUN: %{build} -DTEST_31
#if defined(TEST_31) #if defined(TEST_31)
# include <cstddef> # include <cstddef>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
Show All 19 Lines
// RUN: %{build} -DTEST_35 // RUN: %{build} -DTEST_35
#if defined(TEST_35) #if defined(TEST_35)
# include <cstring> # include <cstring>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_36 // RUN: %{build} -DTEST_36
#if defined(TEST_36) #if defined(TEST_36) && __cplusplus < 201703L
# include <ctgmath> # include <ctgmath>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
#endif #endif
// RUN: %{build} -DTEST_37 // RUN: %{build} -DTEST_37
#if defined(TEST_37) #if defined(TEST_37)
# include <ctime> # include <ctime>
using HandlerType = decltype(std::__libcpp_verbose_abort); using HandlerType = decltype(std::__libcpp_verbose_abort);
▲ Show 20 Lines • Show All 495 Lines • Show Last 20 Lines

libcxx/test/libcxx/clang_tidy.sh.cpp

Show All 40 Lines
#include <array> #include <array>
#include <atomic> #include <atomic>
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <barrier> # include <barrier>
#endif #endif
#include <bit> #include <bit>
#include <bitset> #include <bitset>
#include <cassert> #include <cassert>
#if __cplusplus < 201703L
#include <ccomplex> # include <ccomplex>
#endif
#include <cctype> #include <cctype>
#include <cerrno> #include <cerrno>
#include <cfenv> #include <cfenv>
#include <cfloat> #include <cfloat>
#include <charconv> #include <charconv>
#include <chrono> #include <chrono>
#include <cinttypes> #include <cinttypes>
#include <ciso646> #include <ciso646>
Show All 11 Lines
#include <concepts> #include <concepts>
#include <condition_variable> #include <condition_variable>
#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L) #if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
# include <coroutine> # include <coroutine>
#endif #endif
#include <csetjmp> #include <csetjmp>
#include <csignal> #include <csignal>
#include <cstdarg> #include <cstdarg>
#if __cplusplus < 201703L
#include <cstdbool> # include <cstdbool>
#endif
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#if __cplusplus < 201703L
#include <ctgmath> # include <ctgmath>
#endif
#include <ctime> #include <ctime>
#include <ctype.h> #include <ctype.h>
#include <cuchar> #include <cuchar>
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwchar> # include <cwchar>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwctype> # include <cwctype>
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

libcxx/test/libcxx/double_include.sh.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
#include <array> #include <array>
#include <atomic> #include <atomic>
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <barrier> # include <barrier>
#endif #endif
#include <bit> #include <bit>
#include <bitset> #include <bitset>
#include <cassert> #include <cassert>
#if __cplusplus < 201703L
#include <ccomplex> # include <ccomplex>
#endif
#include <cctype> #include <cctype>
#include <cerrno> #include <cerrno>
#include <cfenv> #include <cfenv>
#include <cfloat> #include <cfloat>
#include <charconv> #include <charconv>
#include <chrono> #include <chrono>
#include <cinttypes> #include <cinttypes>
#include <ciso646> #include <ciso646>
Show All 11 Lines
#include <concepts> #include <concepts>
#include <condition_variable> #include <condition_variable>
#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L) #if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
# include <coroutine> # include <coroutine>
#endif #endif
#include <csetjmp> #include <csetjmp>
#include <csignal> #include <csignal>
#include <cstdarg> #include <cstdarg>
#if __cplusplus < 201703L
#include <cstdbool> # include <cstdbool>
#endif
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#if __cplusplus < 201703L
#include <ctgmath> # include <ctgmath>
#endif
#include <ctime> #include <ctime>
#include <ctype.h> #include <ctype.h>
#include <cuchar> #include <cuchar>
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwchar> # include <cwchar>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwctype> # include <cwctype>
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

libcxx/test/libcxx/language.support/support.runtime/version_cstdbool.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <cstdbool> // <cstdbool>
// REQUIRES: c++11 || c++0x || c++14 || c++1y
philnikUnsubmitted
Not Done
ReplyInline Actions

Where did you get c++0x and c++1y from? I can't find anything in the code base.

philnik: Where did you get c++0x and c++1y from? I can't find anything in the code base.
ayzhaoUnsubmitted
Done
ReplyInline Actions

These are mentioned in params.py: https://github.com/llvm/llvm-project/blob/de939c6cd80c1e88913f1ef12be11aea501eb89b/libcxx/utils/libcxx/test/params.py#L60-L61

ayzhao: These are mentioned in `params.py`: https://github.com/llvm/llvm…
philnikUnsubmitted
Not Done
ReplyInline Actions

You've got it the wrong way around :). The code you linked to treats them as equal compiler flags, i.e. -std=c++11 is the same as -std=c++0x and c++11 is the lit feature that's set. So you only have to test c++11 || c++14 || c++17 (and disable the deprecation warning).

philnik: You've got it the wrong way around :). The code you linked to treats them as equal compiler…
// XFAIL: c++17
#include <cstdbool> #include <cstdbool>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
return 0; return 0;
} }

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
TEST_MACROS(); TEST_MACROS();
#endif #endif
#include <bit> #include <bit>
TEST_MACROS(); TEST_MACROS();
#include <bitset> #include <bitset>
TEST_MACROS(); TEST_MACROS();
#include <cassert> #include <cassert>
TEST_MACROS(); TEST_MACROS();
#if __cplusplus < 201703L
#include <ccomplex> # include <ccomplex>
TEST_MACROS(); TEST_MACROS();
#endif
#include <cctype> #include <cctype>
TEST_MACROS(); TEST_MACROS();
#include <cerrno> #include <cerrno>
TEST_MACROS(); TEST_MACROS();
#include <cfenv> #include <cfenv>
TEST_MACROS(); TEST_MACROS();
#include <cfloat> #include <cfloat>
TEST_MACROS(); TEST_MACROS();
Show All 32 Lines
TEST_MACROS(); TEST_MACROS();
#endif #endif
#include <csetjmp> #include <csetjmp>
TEST_MACROS(); TEST_MACROS();
#include <csignal> #include <csignal>
TEST_MACROS(); TEST_MACROS();
#include <cstdarg> #include <cstdarg>
TEST_MACROS(); TEST_MACROS();
#if __cplusplus < 201703L
#include <cstdbool> # include <cstdbool>
TEST_MACROS(); TEST_MACROS();
#endif
#include <cstddef> #include <cstddef>
TEST_MACROS(); TEST_MACROS();
#include <cstdint> #include <cstdint>
TEST_MACROS(); TEST_MACROS();
#include <cstdio> #include <cstdio>
TEST_MACROS(); TEST_MACROS();
#include <cstdlib> #include <cstdlib>
TEST_MACROS(); TEST_MACROS();
#include <cstring> #include <cstring>
TEST_MACROS(); TEST_MACROS();
#if __cplusplus < 201703L
#include <ctgmath> # include <ctgmath>
TEST_MACROS(); TEST_MACROS();
#endif
#include <ctime> #include <ctime>
TEST_MACROS(); TEST_MACROS();
#include <ctype.h> #include <ctype.h>
TEST_MACROS(); TEST_MACROS();
#include <cuchar> #include <cuchar>
TEST_MACROS(); TEST_MACROS();
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwchar> # include <cwchar>
▲ Show 20 Lines • Show All 279 Lines • Show Last 20 Lines

libcxx/test/libcxx/modules_include.sh.cpp

Show All 28 Lines
#endif #endif
#include <__config> #include <__config>
/* /*
BEGIN-SCRIPT BEGIN-SCRIPT
for i, header in enumerate(public_headers): for i, header in enumerate(public_headers):
print("// {}: echo '%{{cxx}} %s %{{flags}} %{{compile_flags}} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_{} &' >> %t.sh".format('RUN', i)) print("// {}: echo '%{{cxx}} %s %{{flags}} %{{compile_flags}} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_{} -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh".format('RUN', i))
print("// {}: echo 'TEST_{}=$!' >> %t.sh".format('RUN', i)) print("// {}: echo 'TEST_{}=$!' >> %t.sh".format('RUN', i))
if i >= 16: if i >= 16:
print("// {}: echo \"wait $TEST_{}\" >> %t.sh".format('RUN', i - 16)) print("// {}: echo \"wait $TEST_{}\" >> %t.sh".format('RUN', i - 16))
if header in header_restrictions: if header in header_restrictions:
print("#if defined(TEST_{}) && {}".format(i, header_restrictions[header])) print("#if defined(TEST_{}) && {}".format(i, header_restrictions[header]))
else: else:
print("#if defined(TEST_{})".format(i)) print("#if defined(TEST_{})".format(i))
print("#include <{}>".format(header)) print("#include <{}>".format(header))
print("#endif") print("#endif")
for i in range(len(public_headers))[-16:]: for i in range(len(public_headers))[-16:]:
print("// {}: echo \"wait $TEST_{}\" >> %t.sh".format('RUN', i)) print("// {}: echo \"wait $TEST_{}\" >> %t.sh".format('RUN', i))
print("// {}: bash %t.sh".format('RUN')) print("// {}: bash %t.sh".format('RUN'))
END-SCRIPT END-SCRIPT
*/ */
// RUN: echo "" > %t.sh // RUN: echo "" > %t.sh
// RUN: rm -rf %t // RUN: rm -rf %t
// RUN: mkdir %t // RUN: mkdir %t
// DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW // DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW
// GENERATED-MARKER // GENERATED-MARKER
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_0 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_0 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_0=$!' >> %t.sh // RUN: echo 'TEST_0=$!' >> %t.sh
#if defined(TEST_0) #if defined(TEST_0)
#include <algorithm> #include <algorithm>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_1 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_1 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_1=$!' >> %t.sh // RUN: echo 'TEST_1=$!' >> %t.sh
#if defined(TEST_1) #if defined(TEST_1)
#include <any> #include <any>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_2 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_2 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_2=$!' >> %t.sh // RUN: echo 'TEST_2=$!' >> %t.sh
#if defined(TEST_2) #if defined(TEST_2)
#include <array> #include <array>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_3 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_3 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_3=$!' >> %t.sh // RUN: echo 'TEST_3=$!' >> %t.sh
#if defined(TEST_3) #if defined(TEST_3)
#include <atomic> #include <atomic>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_4 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_4 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_4=$!' >> %t.sh // RUN: echo 'TEST_4=$!' >> %t.sh
#if defined(TEST_4) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_4) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <barrier> #include <barrier>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_5 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_5 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_5=$!' >> %t.sh // RUN: echo 'TEST_5=$!' >> %t.sh
#if defined(TEST_5) #if defined(TEST_5)
#include <bit> #include <bit>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_6 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_6 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_6=$!' >> %t.sh // RUN: echo 'TEST_6=$!' >> %t.sh
#if defined(TEST_6) #if defined(TEST_6)
#include <bitset> #include <bitset>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_7 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_7 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_7=$!' >> %t.sh // RUN: echo 'TEST_7=$!' >> %t.sh
#if defined(TEST_7) #if defined(TEST_7)
#include <cassert> #include <cassert>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_8 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_8 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_8=$!' >> %t.sh // RUN: echo 'TEST_8=$!' >> %t.sh
#if defined(TEST_8) #if defined(TEST_8) && __cplusplus < 201703L
#include <ccomplex> #include <ccomplex>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_9 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_9 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_9=$!' >> %t.sh // RUN: echo 'TEST_9=$!' >> %t.sh
#if defined(TEST_9) #if defined(TEST_9)
#include <cctype> #include <cctype>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_10 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_10 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_10=$!' >> %t.sh // RUN: echo 'TEST_10=$!' >> %t.sh
#if defined(TEST_10) #if defined(TEST_10)
#include <cerrno> #include <cerrno>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_11 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_11 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_11=$!' >> %t.sh // RUN: echo 'TEST_11=$!' >> %t.sh
#if defined(TEST_11) #if defined(TEST_11)
#include <cfenv> #include <cfenv>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_12 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_12 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_12=$!' >> %t.sh // RUN: echo 'TEST_12=$!' >> %t.sh
#if defined(TEST_12) #if defined(TEST_12)
#include <cfloat> #include <cfloat>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_13 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_13 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_13=$!' >> %t.sh // RUN: echo 'TEST_13=$!' >> %t.sh
#if defined(TEST_13) #if defined(TEST_13)
#include <charconv> #include <charconv>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_14 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_14 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_14=$!' >> %t.sh // RUN: echo 'TEST_14=$!' >> %t.sh
#if defined(TEST_14) #if defined(TEST_14)
#include <chrono> #include <chrono>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_15 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_15 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_15=$!' >> %t.sh // RUN: echo 'TEST_15=$!' >> %t.sh
#if defined(TEST_15) #if defined(TEST_15)
#include <cinttypes> #include <cinttypes>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_16 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_16 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_16=$!' >> %t.sh // RUN: echo 'TEST_16=$!' >> %t.sh
// RUN: echo "wait $TEST_0" >> %t.sh // RUN: echo "wait $TEST_0" >> %t.sh
#if defined(TEST_16) #if defined(TEST_16)
#include <ciso646> #include <ciso646>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_17 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_17 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_17=$!' >> %t.sh // RUN: echo 'TEST_17=$!' >> %t.sh
// RUN: echo "wait $TEST_1" >> %t.sh // RUN: echo "wait $TEST_1" >> %t.sh
#if defined(TEST_17) #if defined(TEST_17)
#include <climits> #include <climits>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_18 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_18 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_18=$!' >> %t.sh // RUN: echo 'TEST_18=$!' >> %t.sh
// RUN: echo "wait $TEST_2" >> %t.sh // RUN: echo "wait $TEST_2" >> %t.sh
#if defined(TEST_18) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_18) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <clocale> #include <clocale>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_19 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_19 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_19=$!' >> %t.sh // RUN: echo 'TEST_19=$!' >> %t.sh
// RUN: echo "wait $TEST_3" >> %t.sh // RUN: echo "wait $TEST_3" >> %t.sh
#if defined(TEST_19) #if defined(TEST_19)
#include <cmath> #include <cmath>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_20 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_20 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_20=$!' >> %t.sh // RUN: echo 'TEST_20=$!' >> %t.sh
// RUN: echo "wait $TEST_4" >> %t.sh // RUN: echo "wait $TEST_4" >> %t.sh
#if defined(TEST_20) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_20) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <codecvt> #include <codecvt>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_21 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_21 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_21=$!' >> %t.sh // RUN: echo 'TEST_21=$!' >> %t.sh
// RUN: echo "wait $TEST_5" >> %t.sh // RUN: echo "wait $TEST_5" >> %t.sh
#if defined(TEST_21) #if defined(TEST_21)
#include <compare> #include <compare>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_22 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_22 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_22=$!' >> %t.sh // RUN: echo 'TEST_22=$!' >> %t.sh
// RUN: echo "wait $TEST_6" >> %t.sh // RUN: echo "wait $TEST_6" >> %t.sh
#if defined(TEST_22) #if defined(TEST_22)
#include <complex> #include <complex>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_23 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_23 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_23=$!' >> %t.sh // RUN: echo 'TEST_23=$!' >> %t.sh
// RUN: echo "wait $TEST_7" >> %t.sh // RUN: echo "wait $TEST_7" >> %t.sh
#if defined(TEST_23) #if defined(TEST_23)
#include <complex.h> #include <complex.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_24 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_24 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_24=$!' >> %t.sh // RUN: echo 'TEST_24=$!' >> %t.sh
// RUN: echo "wait $TEST_8" >> %t.sh // RUN: echo "wait $TEST_8" >> %t.sh
#if defined(TEST_24) #if defined(TEST_24)
#include <concepts> #include <concepts>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_25 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_25 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_25=$!' >> %t.sh // RUN: echo 'TEST_25=$!' >> %t.sh
// RUN: echo "wait $TEST_9" >> %t.sh // RUN: echo "wait $TEST_9" >> %t.sh
#if defined(TEST_25) #if defined(TEST_25)
#include <condition_variable> #include <condition_variable>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_26 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_26 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_26=$!' >> %t.sh // RUN: echo 'TEST_26=$!' >> %t.sh
// RUN: echo "wait $TEST_10" >> %t.sh // RUN: echo "wait $TEST_10" >> %t.sh
#if defined(TEST_26) && (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L) #if defined(TEST_26) && (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
#include <coroutine> #include <coroutine>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_27 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_27 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_27=$!' >> %t.sh // RUN: echo 'TEST_27=$!' >> %t.sh
// RUN: echo "wait $TEST_11" >> %t.sh // RUN: echo "wait $TEST_11" >> %t.sh
#if defined(TEST_27) #if defined(TEST_27)
#include <csetjmp> #include <csetjmp>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_28 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_28 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_28=$!' >> %t.sh // RUN: echo 'TEST_28=$!' >> %t.sh
// RUN: echo "wait $TEST_12" >> %t.sh // RUN: echo "wait $TEST_12" >> %t.sh
#if defined(TEST_28) #if defined(TEST_28)
#include <csignal> #include <csignal>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_29 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_29 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_29=$!' >> %t.sh // RUN: echo 'TEST_29=$!' >> %t.sh
// RUN: echo "wait $TEST_13" >> %t.sh // RUN: echo "wait $TEST_13" >> %t.sh
#if defined(TEST_29) #if defined(TEST_29)
#include <cstdarg> #include <cstdarg>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_30 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_30 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_30=$!' >> %t.sh // RUN: echo 'TEST_30=$!' >> %t.sh
// RUN: echo "wait $TEST_14" >> %t.sh // RUN: echo "wait $TEST_14" >> %t.sh
#if defined(TEST_30) #if defined(TEST_30) && __cplusplus < 201703L
#include <cstdbool> #include <cstdbool>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_31 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_31 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_31=$!' >> %t.sh // RUN: echo 'TEST_31=$!' >> %t.sh
// RUN: echo "wait $TEST_15" >> %t.sh // RUN: echo "wait $TEST_15" >> %t.sh
#if defined(TEST_31) #if defined(TEST_31)
#include <cstddef> #include <cstddef>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_32 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_32 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_32=$!' >> %t.sh // RUN: echo 'TEST_32=$!' >> %t.sh
// RUN: echo "wait $TEST_16" >> %t.sh // RUN: echo "wait $TEST_16" >> %t.sh
#if defined(TEST_32) #if defined(TEST_32)
#include <cstdint> #include <cstdint>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_33 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_33 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_33=$!' >> %t.sh // RUN: echo 'TEST_33=$!' >> %t.sh
// RUN: echo "wait $TEST_17" >> %t.sh // RUN: echo "wait $TEST_17" >> %t.sh
#if defined(TEST_33) #if defined(TEST_33)
#include <cstdio> #include <cstdio>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_34 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_34 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_34=$!' >> %t.sh // RUN: echo 'TEST_34=$!' >> %t.sh
// RUN: echo "wait $TEST_18" >> %t.sh // RUN: echo "wait $TEST_18" >> %t.sh
#if defined(TEST_34) #if defined(TEST_34)
#include <cstdlib> #include <cstdlib>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_35 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_35 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_35=$!' >> %t.sh // RUN: echo 'TEST_35=$!' >> %t.sh
// RUN: echo "wait $TEST_19" >> %t.sh // RUN: echo "wait $TEST_19" >> %t.sh
#if defined(TEST_35) #if defined(TEST_35)
#include <cstring> #include <cstring>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_36 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_36 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_36=$!' >> %t.sh // RUN: echo 'TEST_36=$!' >> %t.sh
// RUN: echo "wait $TEST_20" >> %t.sh // RUN: echo "wait $TEST_20" >> %t.sh
#if defined(TEST_36) #if defined(TEST_36) && __cplusplus < 201703L
#include <ctgmath> #include <ctgmath>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_37 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_37 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_37=$!' >> %t.sh // RUN: echo 'TEST_37=$!' >> %t.sh
// RUN: echo "wait $TEST_21" >> %t.sh // RUN: echo "wait $TEST_21" >> %t.sh
#if defined(TEST_37) #if defined(TEST_37)
#include <ctime> #include <ctime>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_38 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_38 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_38=$!' >> %t.sh // RUN: echo 'TEST_38=$!' >> %t.sh
// RUN: echo "wait $TEST_22" >> %t.sh // RUN: echo "wait $TEST_22" >> %t.sh
#if defined(TEST_38) #if defined(TEST_38)
#include <ctype.h> #include <ctype.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_39 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_39 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_39=$!' >> %t.sh // RUN: echo 'TEST_39=$!' >> %t.sh
// RUN: echo "wait $TEST_23" >> %t.sh // RUN: echo "wait $TEST_23" >> %t.sh
#if defined(TEST_39) #if defined(TEST_39)
#include <cuchar> #include <cuchar>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_40 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_40 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_40=$!' >> %t.sh // RUN: echo 'TEST_40=$!' >> %t.sh
// RUN: echo "wait $TEST_24" >> %t.sh // RUN: echo "wait $TEST_24" >> %t.sh
#if defined(TEST_40) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if defined(TEST_40) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
#include <cwchar> #include <cwchar>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_41 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_41 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_41=$!' >> %t.sh // RUN: echo 'TEST_41=$!' >> %t.sh
// RUN: echo "wait $TEST_25" >> %t.sh // RUN: echo "wait $TEST_25" >> %t.sh
#if defined(TEST_41) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if defined(TEST_41) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
#include <cwctype> #include <cwctype>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_42 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_42 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_42=$!' >> %t.sh // RUN: echo 'TEST_42=$!' >> %t.sh
// RUN: echo "wait $TEST_26" >> %t.sh // RUN: echo "wait $TEST_26" >> %t.sh
#if defined(TEST_42) #if defined(TEST_42)
#include <deque> #include <deque>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_43 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_43 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_43=$!' >> %t.sh // RUN: echo 'TEST_43=$!' >> %t.sh
// RUN: echo "wait $TEST_27" >> %t.sh // RUN: echo "wait $TEST_27" >> %t.sh
#if defined(TEST_43) #if defined(TEST_43)
#include <errno.h> #include <errno.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_44 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_44 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_44=$!' >> %t.sh // RUN: echo 'TEST_44=$!' >> %t.sh
// RUN: echo "wait $TEST_28" >> %t.sh // RUN: echo "wait $TEST_28" >> %t.sh
#if defined(TEST_44) #if defined(TEST_44)
#include <exception> #include <exception>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_45 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_45 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_45=$!' >> %t.sh // RUN: echo 'TEST_45=$!' >> %t.sh
// RUN: echo "wait $TEST_29" >> %t.sh // RUN: echo "wait $TEST_29" >> %t.sh
#if defined(TEST_45) #if defined(TEST_45)
#include <execution> #include <execution>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_46 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_46 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_46=$!' >> %t.sh // RUN: echo 'TEST_46=$!' >> %t.sh
// RUN: echo "wait $TEST_30" >> %t.sh // RUN: echo "wait $TEST_30" >> %t.sh
#if defined(TEST_46) #if defined(TEST_46)
#include <expected> #include <expected>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_47 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_47 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_47=$!' >> %t.sh // RUN: echo 'TEST_47=$!' >> %t.sh
// RUN: echo "wait $TEST_31" >> %t.sh // RUN: echo "wait $TEST_31" >> %t.sh
#if defined(TEST_47) #if defined(TEST_47)
#include <fenv.h> #include <fenv.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_48 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_48 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_48=$!' >> %t.sh // RUN: echo 'TEST_48=$!' >> %t.sh
// RUN: echo "wait $TEST_32" >> %t.sh // RUN: echo "wait $TEST_32" >> %t.sh
#if defined(TEST_48) && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY) #if defined(TEST_48) && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
#include <filesystem> #include <filesystem>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_49 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_49 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_49=$!' >> %t.sh // RUN: echo 'TEST_49=$!' >> %t.sh
// RUN: echo "wait $TEST_33" >> %t.sh // RUN: echo "wait $TEST_33" >> %t.sh
#if defined(TEST_49) #if defined(TEST_49)
#include <float.h> #include <float.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_50 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_50 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_50=$!' >> %t.sh // RUN: echo 'TEST_50=$!' >> %t.sh
// RUN: echo "wait $TEST_34" >> %t.sh // RUN: echo "wait $TEST_34" >> %t.sh
#if defined(TEST_50) #if defined(TEST_50)
#include <format> #include <format>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_51 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_51 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_51=$!' >> %t.sh // RUN: echo 'TEST_51=$!' >> %t.sh
// RUN: echo "wait $TEST_35" >> %t.sh // RUN: echo "wait $TEST_35" >> %t.sh
#if defined(TEST_51) #if defined(TEST_51)
#include <forward_list> #include <forward_list>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_52 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_52 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_52=$!' >> %t.sh // RUN: echo 'TEST_52=$!' >> %t.sh
// RUN: echo "wait $TEST_36" >> %t.sh // RUN: echo "wait $TEST_36" >> %t.sh
#if defined(TEST_52) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM) #if defined(TEST_52) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)
#include <fstream> #include <fstream>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_53 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_53 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_53=$!' >> %t.sh // RUN: echo 'TEST_53=$!' >> %t.sh
// RUN: echo "wait $TEST_37" >> %t.sh // RUN: echo "wait $TEST_37" >> %t.sh
#if defined(TEST_53) #if defined(TEST_53)
#include <functional> #include <functional>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_54 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_54 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_54=$!' >> %t.sh // RUN: echo 'TEST_54=$!' >> %t.sh
// RUN: echo "wait $TEST_38" >> %t.sh // RUN: echo "wait $TEST_38" >> %t.sh
#if defined(TEST_54) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_54) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <future> #include <future>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_55 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_55 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_55=$!' >> %t.sh // RUN: echo 'TEST_55=$!' >> %t.sh
// RUN: echo "wait $TEST_39" >> %t.sh // RUN: echo "wait $TEST_39" >> %t.sh
#if defined(TEST_55) #if defined(TEST_55)
#include <initializer_list> #include <initializer_list>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_56 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_56 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_56=$!' >> %t.sh // RUN: echo 'TEST_56=$!' >> %t.sh
// RUN: echo "wait $TEST_40" >> %t.sh // RUN: echo "wait $TEST_40" >> %t.sh
#if defined(TEST_56) #if defined(TEST_56)
#include <inttypes.h> #include <inttypes.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_57 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_57 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_57=$!' >> %t.sh // RUN: echo 'TEST_57=$!' >> %t.sh
// RUN: echo "wait $TEST_41" >> %t.sh // RUN: echo "wait $TEST_41" >> %t.sh
#if defined(TEST_57) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_57) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <iomanip> #include <iomanip>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_58 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_58 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_58=$!' >> %t.sh // RUN: echo 'TEST_58=$!' >> %t.sh
// RUN: echo "wait $TEST_42" >> %t.sh // RUN: echo "wait $TEST_42" >> %t.sh
#if defined(TEST_58) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_58) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <ios> #include <ios>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_59 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_59 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_59=$!' >> %t.sh // RUN: echo 'TEST_59=$!' >> %t.sh
// RUN: echo "wait $TEST_43" >> %t.sh // RUN: echo "wait $TEST_43" >> %t.sh
#if defined(TEST_59) #if defined(TEST_59)
#include <iosfwd> #include <iosfwd>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_60 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_60 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_60=$!' >> %t.sh // RUN: echo 'TEST_60=$!' >> %t.sh
// RUN: echo "wait $TEST_44" >> %t.sh // RUN: echo "wait $TEST_44" >> %t.sh
#if defined(TEST_60) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_60) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <iostream> #include <iostream>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_61 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_61 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_61=$!' >> %t.sh // RUN: echo 'TEST_61=$!' >> %t.sh
// RUN: echo "wait $TEST_45" >> %t.sh // RUN: echo "wait $TEST_45" >> %t.sh
#if defined(TEST_61) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_61) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <istream> #include <istream>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_62 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_62 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_62=$!' >> %t.sh // RUN: echo 'TEST_62=$!' >> %t.sh
// RUN: echo "wait $TEST_46" >> %t.sh // RUN: echo "wait $TEST_46" >> %t.sh
#if defined(TEST_62) #if defined(TEST_62)
#include <iterator> #include <iterator>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_63 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_63 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_63=$!' >> %t.sh // RUN: echo 'TEST_63=$!' >> %t.sh
// RUN: echo "wait $TEST_47" >> %t.sh // RUN: echo "wait $TEST_47" >> %t.sh
#if defined(TEST_63) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_63) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <latch> #include <latch>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_64 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_64 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_64=$!' >> %t.sh // RUN: echo 'TEST_64=$!' >> %t.sh
// RUN: echo "wait $TEST_48" >> %t.sh // RUN: echo "wait $TEST_48" >> %t.sh
#if defined(TEST_64) #if defined(TEST_64)
#include <limits> #include <limits>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_65 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_65 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_65=$!' >> %t.sh // RUN: echo 'TEST_65=$!' >> %t.sh
// RUN: echo "wait $TEST_49" >> %t.sh // RUN: echo "wait $TEST_49" >> %t.sh
#if defined(TEST_65) #if defined(TEST_65)
#include <limits.h> #include <limits.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_66 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_66 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_66=$!' >> %t.sh // RUN: echo 'TEST_66=$!' >> %t.sh
// RUN: echo "wait $TEST_50" >> %t.sh // RUN: echo "wait $TEST_50" >> %t.sh
#if defined(TEST_66) #if defined(TEST_66)
#include <list> #include <list>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_67 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_67 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_67=$!' >> %t.sh // RUN: echo 'TEST_67=$!' >> %t.sh
// RUN: echo "wait $TEST_51" >> %t.sh // RUN: echo "wait $TEST_51" >> %t.sh
#if defined(TEST_67) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_67) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <locale> #include <locale>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_68 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_68 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_68=$!' >> %t.sh // RUN: echo 'TEST_68=$!' >> %t.sh
// RUN: echo "wait $TEST_52" >> %t.sh // RUN: echo "wait $TEST_52" >> %t.sh
#if defined(TEST_68) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_68) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <locale.h> #include <locale.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_69 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_69 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_69=$!' >> %t.sh // RUN: echo 'TEST_69=$!' >> %t.sh
// RUN: echo "wait $TEST_53" >> %t.sh // RUN: echo "wait $TEST_53" >> %t.sh
#if defined(TEST_69) #if defined(TEST_69)
#include <map> #include <map>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_70 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_70 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_70=$!' >> %t.sh // RUN: echo 'TEST_70=$!' >> %t.sh
// RUN: echo "wait $TEST_54" >> %t.sh // RUN: echo "wait $TEST_54" >> %t.sh
#if defined(TEST_70) #if defined(TEST_70)
#include <math.h> #include <math.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_71 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_71 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_71=$!' >> %t.sh // RUN: echo 'TEST_71=$!' >> %t.sh
// RUN: echo "wait $TEST_55" >> %t.sh // RUN: echo "wait $TEST_55" >> %t.sh
#if defined(TEST_71) #if defined(TEST_71)
#include <memory> #include <memory>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_72 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_72 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_72=$!' >> %t.sh // RUN: echo 'TEST_72=$!' >> %t.sh
// RUN: echo "wait $TEST_56" >> %t.sh // RUN: echo "wait $TEST_56" >> %t.sh
#if defined(TEST_72) #if defined(TEST_72)
#include <memory_resource> #include <memory_resource>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_73 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_73 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_73=$!' >> %t.sh // RUN: echo 'TEST_73=$!' >> %t.sh
// RUN: echo "wait $TEST_57" >> %t.sh // RUN: echo "wait $TEST_57" >> %t.sh
#if defined(TEST_73) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_73) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <mutex> #include <mutex>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_74 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_74 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_74=$!' >> %t.sh // RUN: echo 'TEST_74=$!' >> %t.sh
// RUN: echo "wait $TEST_58" >> %t.sh // RUN: echo "wait $TEST_58" >> %t.sh
#if defined(TEST_74) #if defined(TEST_74)
#include <new> #include <new>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_75 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_75 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_75=$!' >> %t.sh // RUN: echo 'TEST_75=$!' >> %t.sh
// RUN: echo "wait $TEST_59" >> %t.sh // RUN: echo "wait $TEST_59" >> %t.sh
#if defined(TEST_75) #if defined(TEST_75)
#include <numbers> #include <numbers>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_76 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_76 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_76=$!' >> %t.sh // RUN: echo 'TEST_76=$!' >> %t.sh
// RUN: echo "wait $TEST_60" >> %t.sh // RUN: echo "wait $TEST_60" >> %t.sh
#if defined(TEST_76) #if defined(TEST_76)
#include <numeric> #include <numeric>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_77 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_77 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_77=$!' >> %t.sh // RUN: echo 'TEST_77=$!' >> %t.sh
// RUN: echo "wait $TEST_61" >> %t.sh // RUN: echo "wait $TEST_61" >> %t.sh
#if defined(TEST_77) #if defined(TEST_77)
#include <optional> #include <optional>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_78 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_78 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_78=$!' >> %t.sh // RUN: echo 'TEST_78=$!' >> %t.sh
// RUN: echo "wait $TEST_62" >> %t.sh // RUN: echo "wait $TEST_62" >> %t.sh
#if defined(TEST_78) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_78) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <ostream> #include <ostream>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_79 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_79 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_79=$!' >> %t.sh // RUN: echo 'TEST_79=$!' >> %t.sh
// RUN: echo "wait $TEST_63" >> %t.sh // RUN: echo "wait $TEST_63" >> %t.sh
#if defined(TEST_79) #if defined(TEST_79)
#include <queue> #include <queue>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_80 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_80 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_80=$!' >> %t.sh // RUN: echo 'TEST_80=$!' >> %t.sh
// RUN: echo "wait $TEST_64" >> %t.sh // RUN: echo "wait $TEST_64" >> %t.sh
#if defined(TEST_80) #if defined(TEST_80)
#include <random> #include <random>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_81 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_81 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_81=$!' >> %t.sh // RUN: echo 'TEST_81=$!' >> %t.sh
// RUN: echo "wait $TEST_65" >> %t.sh // RUN: echo "wait $TEST_65" >> %t.sh
#if defined(TEST_81) #if defined(TEST_81)
#include <ranges> #include <ranges>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_82 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_82 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_82=$!' >> %t.sh // RUN: echo 'TEST_82=$!' >> %t.sh
// RUN: echo "wait $TEST_66" >> %t.sh // RUN: echo "wait $TEST_66" >> %t.sh
#if defined(TEST_82) #if defined(TEST_82)
#include <ratio> #include <ratio>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_83 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_83 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_83=$!' >> %t.sh // RUN: echo 'TEST_83=$!' >> %t.sh
// RUN: echo "wait $TEST_67" >> %t.sh // RUN: echo "wait $TEST_67" >> %t.sh
#if defined(TEST_83) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_83) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <regex> #include <regex>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_84 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_84 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_84=$!' >> %t.sh // RUN: echo 'TEST_84=$!' >> %t.sh
// RUN: echo "wait $TEST_68" >> %t.sh // RUN: echo "wait $TEST_68" >> %t.sh
#if defined(TEST_84) #if defined(TEST_84)
#include <scoped_allocator> #include <scoped_allocator>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_85 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_85 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_85=$!' >> %t.sh // RUN: echo 'TEST_85=$!' >> %t.sh
// RUN: echo "wait $TEST_69" >> %t.sh // RUN: echo "wait $TEST_69" >> %t.sh
#if defined(TEST_85) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_85) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <semaphore> #include <semaphore>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_86 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_86 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_86=$!' >> %t.sh // RUN: echo 'TEST_86=$!' >> %t.sh
// RUN: echo "wait $TEST_70" >> %t.sh // RUN: echo "wait $TEST_70" >> %t.sh
#if defined(TEST_86) #if defined(TEST_86)
#include <set> #include <set>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_87 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_87 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_87=$!' >> %t.sh // RUN: echo 'TEST_87=$!' >> %t.sh
// RUN: echo "wait $TEST_71" >> %t.sh // RUN: echo "wait $TEST_71" >> %t.sh
#if defined(TEST_87) #if defined(TEST_87)
#include <setjmp.h> #include <setjmp.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_88 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_88 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_88=$!' >> %t.sh // RUN: echo 'TEST_88=$!' >> %t.sh
// RUN: echo "wait $TEST_72" >> %t.sh // RUN: echo "wait $TEST_72" >> %t.sh
#if defined(TEST_88) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_88) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <shared_mutex> #include <shared_mutex>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_89 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_89 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_89=$!' >> %t.sh // RUN: echo 'TEST_89=$!' >> %t.sh
// RUN: echo "wait $TEST_73" >> %t.sh // RUN: echo "wait $TEST_73" >> %t.sh
#if defined(TEST_89) #if defined(TEST_89)
#include <source_location> #include <source_location>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_90 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_90 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_90=$!' >> %t.sh // RUN: echo 'TEST_90=$!' >> %t.sh
// RUN: echo "wait $TEST_74" >> %t.sh // RUN: echo "wait $TEST_74" >> %t.sh
#if defined(TEST_90) #if defined(TEST_90)
#include <span> #include <span>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_91 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_91 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_91=$!' >> %t.sh // RUN: echo 'TEST_91=$!' >> %t.sh
// RUN: echo "wait $TEST_75" >> %t.sh // RUN: echo "wait $TEST_75" >> %t.sh
#if defined(TEST_91) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_91) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <sstream> #include <sstream>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_92 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_92 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_92=$!' >> %t.sh // RUN: echo 'TEST_92=$!' >> %t.sh
// RUN: echo "wait $TEST_76" >> %t.sh // RUN: echo "wait $TEST_76" >> %t.sh
#if defined(TEST_92) #if defined(TEST_92)
#include <stack> #include <stack>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_93 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_93 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_93=$!' >> %t.sh // RUN: echo 'TEST_93=$!' >> %t.sh
// RUN: echo "wait $TEST_77" >> %t.sh // RUN: echo "wait $TEST_77" >> %t.sh
#if defined(TEST_93) && __cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_93) && __cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS)
#include <stdatomic.h> #include <stdatomic.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_94 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_94 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_94=$!' >> %t.sh // RUN: echo 'TEST_94=$!' >> %t.sh
// RUN: echo "wait $TEST_78" >> %t.sh // RUN: echo "wait $TEST_78" >> %t.sh
#if defined(TEST_94) #if defined(TEST_94)
#include <stdbool.h> #include <stdbool.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_95 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_95 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_95=$!' >> %t.sh // RUN: echo 'TEST_95=$!' >> %t.sh
// RUN: echo "wait $TEST_79" >> %t.sh // RUN: echo "wait $TEST_79" >> %t.sh
#if defined(TEST_95) #if defined(TEST_95)
#include <stddef.h> #include <stddef.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_96 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_96 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_96=$!' >> %t.sh // RUN: echo 'TEST_96=$!' >> %t.sh
// RUN: echo "wait $TEST_80" >> %t.sh // RUN: echo "wait $TEST_80" >> %t.sh
#if defined(TEST_96) #if defined(TEST_96)
#include <stdexcept> #include <stdexcept>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_97 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_97 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_97=$!' >> %t.sh // RUN: echo 'TEST_97=$!' >> %t.sh
// RUN: echo "wait $TEST_81" >> %t.sh // RUN: echo "wait $TEST_81" >> %t.sh
#if defined(TEST_97) #if defined(TEST_97)
#include <stdint.h> #include <stdint.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_98 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_98 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_98=$!' >> %t.sh // RUN: echo 'TEST_98=$!' >> %t.sh
// RUN: echo "wait $TEST_82" >> %t.sh // RUN: echo "wait $TEST_82" >> %t.sh
#if defined(TEST_98) #if defined(TEST_98)
#include <stdio.h> #include <stdio.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_99 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_99 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_99=$!' >> %t.sh // RUN: echo 'TEST_99=$!' >> %t.sh
// RUN: echo "wait $TEST_83" >> %t.sh // RUN: echo "wait $TEST_83" >> %t.sh
#if defined(TEST_99) #if defined(TEST_99)
#include <stdlib.h> #include <stdlib.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_100 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_100 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_100=$!' >> %t.sh // RUN: echo 'TEST_100=$!' >> %t.sh
// RUN: echo "wait $TEST_84" >> %t.sh // RUN: echo "wait $TEST_84" >> %t.sh
#if defined(TEST_100) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_100) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <streambuf> #include <streambuf>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_101 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_101 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_101=$!' >> %t.sh // RUN: echo 'TEST_101=$!' >> %t.sh
// RUN: echo "wait $TEST_85" >> %t.sh // RUN: echo "wait $TEST_85" >> %t.sh
#if defined(TEST_101) #if defined(TEST_101)
#include <string> #include <string>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_102 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_102 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_102=$!' >> %t.sh // RUN: echo 'TEST_102=$!' >> %t.sh
// RUN: echo "wait $TEST_86" >> %t.sh // RUN: echo "wait $TEST_86" >> %t.sh
#if defined(TEST_102) #if defined(TEST_102)
#include <string.h> #include <string.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_103 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_103 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_103=$!' >> %t.sh // RUN: echo 'TEST_103=$!' >> %t.sh
// RUN: echo "wait $TEST_87" >> %t.sh // RUN: echo "wait $TEST_87" >> %t.sh
#if defined(TEST_103) #if defined(TEST_103)
#include <string_view> #include <string_view>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_104 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_104 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_104=$!' >> %t.sh // RUN: echo 'TEST_104=$!' >> %t.sh
// RUN: echo "wait $TEST_88" >> %t.sh // RUN: echo "wait $TEST_88" >> %t.sh
#if defined(TEST_104) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(TEST_104) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
#include <strstream> #include <strstream>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_105 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_105 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_105=$!' >> %t.sh // RUN: echo 'TEST_105=$!' >> %t.sh
// RUN: echo "wait $TEST_89" >> %t.sh // RUN: echo "wait $TEST_89" >> %t.sh
#if defined(TEST_105) #if defined(TEST_105)
#include <system_error> #include <system_error>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_106 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_106 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_106=$!' >> %t.sh // RUN: echo 'TEST_106=$!' >> %t.sh
// RUN: echo "wait $TEST_90" >> %t.sh // RUN: echo "wait $TEST_90" >> %t.sh
#if defined(TEST_106) #if defined(TEST_106)
#include <tgmath.h> #include <tgmath.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_107 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_107 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_107=$!' >> %t.sh // RUN: echo 'TEST_107=$!' >> %t.sh
// RUN: echo "wait $TEST_91" >> %t.sh // RUN: echo "wait $TEST_91" >> %t.sh
#if defined(TEST_107) && !defined(_LIBCPP_HAS_NO_THREADS) #if defined(TEST_107) && !defined(_LIBCPP_HAS_NO_THREADS)
#include <thread> #include <thread>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_108 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_108 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_108=$!' >> %t.sh // RUN: echo 'TEST_108=$!' >> %t.sh
// RUN: echo "wait $TEST_92" >> %t.sh // RUN: echo "wait $TEST_92" >> %t.sh
#if defined(TEST_108) #if defined(TEST_108)
#include <tuple> #include <tuple>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_109 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_109 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_109=$!' >> %t.sh // RUN: echo 'TEST_109=$!' >> %t.sh
// RUN: echo "wait $TEST_93" >> %t.sh // RUN: echo "wait $TEST_93" >> %t.sh
#if defined(TEST_109) #if defined(TEST_109)
#include <type_traits> #include <type_traits>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_110 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_110 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_110=$!' >> %t.sh // RUN: echo 'TEST_110=$!' >> %t.sh
// RUN: echo "wait $TEST_94" >> %t.sh // RUN: echo "wait $TEST_94" >> %t.sh
#if defined(TEST_110) #if defined(TEST_110)
#include <typeindex> #include <typeindex>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_111 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_111 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_111=$!' >> %t.sh // RUN: echo 'TEST_111=$!' >> %t.sh
// RUN: echo "wait $TEST_95" >> %t.sh // RUN: echo "wait $TEST_95" >> %t.sh
#if defined(TEST_111) #if defined(TEST_111)
#include <typeinfo> #include <typeinfo>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_112 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_112 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_112=$!' >> %t.sh // RUN: echo 'TEST_112=$!' >> %t.sh
// RUN: echo "wait $TEST_96" >> %t.sh // RUN: echo "wait $TEST_96" >> %t.sh
#if defined(TEST_112) #if defined(TEST_112)
#include <uchar.h> #include <uchar.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_113 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_113 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_113=$!' >> %t.sh // RUN: echo 'TEST_113=$!' >> %t.sh
// RUN: echo "wait $TEST_97" >> %t.sh // RUN: echo "wait $TEST_97" >> %t.sh
#if defined(TEST_113) #if defined(TEST_113)
#include <unordered_map> #include <unordered_map>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_114 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_114 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_114=$!' >> %t.sh // RUN: echo 'TEST_114=$!' >> %t.sh
// RUN: echo "wait $TEST_98" >> %t.sh // RUN: echo "wait $TEST_98" >> %t.sh
#if defined(TEST_114) #if defined(TEST_114)
#include <unordered_set> #include <unordered_set>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_115 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_115 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_115=$!' >> %t.sh // RUN: echo 'TEST_115=$!' >> %t.sh
// RUN: echo "wait $TEST_99" >> %t.sh // RUN: echo "wait $TEST_99" >> %t.sh
#if defined(TEST_115) #if defined(TEST_115)
#include <utility> #include <utility>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_116 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_116 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_116=$!' >> %t.sh // RUN: echo 'TEST_116=$!' >> %t.sh
// RUN: echo "wait $TEST_100" >> %t.sh // RUN: echo "wait $TEST_100" >> %t.sh
#if defined(TEST_116) #if defined(TEST_116)
#include <valarray> #include <valarray>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_117 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_117 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_117=$!' >> %t.sh // RUN: echo 'TEST_117=$!' >> %t.sh
// RUN: echo "wait $TEST_101" >> %t.sh // RUN: echo "wait $TEST_101" >> %t.sh
#if defined(TEST_117) #if defined(TEST_117)
#include <variant> #include <variant>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_118 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_118 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_118=$!' >> %t.sh // RUN: echo 'TEST_118=$!' >> %t.sh
// RUN: echo "wait $TEST_102" >> %t.sh // RUN: echo "wait $TEST_102" >> %t.sh
#if defined(TEST_118) #if defined(TEST_118)
#include <vector> #include <vector>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_119 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_119 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_119=$!' >> %t.sh // RUN: echo 'TEST_119=$!' >> %t.sh
// RUN: echo "wait $TEST_103" >> %t.sh // RUN: echo "wait $TEST_103" >> %t.sh
#if defined(TEST_119) #if defined(TEST_119)
#include <version> #include <version>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_120 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_120 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_120=$!' >> %t.sh // RUN: echo 'TEST_120=$!' >> %t.sh
// RUN: echo "wait $TEST_104" >> %t.sh // RUN: echo "wait $TEST_104" >> %t.sh
#if defined(TEST_120) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if defined(TEST_120) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
#include <wchar.h> #include <wchar.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_121 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_121 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_121=$!' >> %t.sh // RUN: echo 'TEST_121=$!' >> %t.sh
// RUN: echo "wait $TEST_105" >> %t.sh // RUN: echo "wait $TEST_105" >> %t.sh
#if defined(TEST_121) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if defined(TEST_121) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
#include <wctype.h> #include <wctype.h>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_122 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_122 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_122=$!' >> %t.sh // RUN: echo 'TEST_122=$!' >> %t.sh
// RUN: echo "wait $TEST_106" >> %t.sh // RUN: echo "wait $TEST_106" >> %t.sh
#if defined(TEST_122) && __cplusplus >= 201103L #if defined(TEST_122) && __cplusplus >= 201103L
#include <experimental/deque> #include <experimental/deque>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_123 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_123 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_123=$!' >> %t.sh // RUN: echo 'TEST_123=$!' >> %t.sh
// RUN: echo "wait $TEST_107" >> %t.sh // RUN: echo "wait $TEST_107" >> %t.sh
#if defined(TEST_123) && __cplusplus >= 201103L #if defined(TEST_123) && __cplusplus >= 201103L
#include <experimental/forward_list> #include <experimental/forward_list>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_124 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_124 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_124=$!' >> %t.sh // RUN: echo 'TEST_124=$!' >> %t.sh
// RUN: echo "wait $TEST_108" >> %t.sh // RUN: echo "wait $TEST_108" >> %t.sh
#if defined(TEST_124) && __cplusplus >= 201103L #if defined(TEST_124) && __cplusplus >= 201103L
#include <experimental/iterator> #include <experimental/iterator>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_125 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_125 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_125=$!' >> %t.sh // RUN: echo 'TEST_125=$!' >> %t.sh
// RUN: echo "wait $TEST_109" >> %t.sh // RUN: echo "wait $TEST_109" >> %t.sh
#if defined(TEST_125) && __cplusplus >= 201103L #if defined(TEST_125) && __cplusplus >= 201103L
#include <experimental/list> #include <experimental/list>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_126 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_126 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_126=$!' >> %t.sh // RUN: echo 'TEST_126=$!' >> %t.sh
// RUN: echo "wait $TEST_110" >> %t.sh // RUN: echo "wait $TEST_110" >> %t.sh
#if defined(TEST_126) && __cplusplus >= 201103L #if defined(TEST_126) && __cplusplus >= 201103L
#include <experimental/map> #include <experimental/map>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_127 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_127 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_127=$!' >> %t.sh // RUN: echo 'TEST_127=$!' >> %t.sh
// RUN: echo "wait $TEST_111" >> %t.sh // RUN: echo "wait $TEST_111" >> %t.sh
#if defined(TEST_127) && __cplusplus >= 201103L #if defined(TEST_127) && __cplusplus >= 201103L
#include <experimental/memory_resource> #include <experimental/memory_resource>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_128 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_128 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_128=$!' >> %t.sh // RUN: echo 'TEST_128=$!' >> %t.sh
// RUN: echo "wait $TEST_112" >> %t.sh // RUN: echo "wait $TEST_112" >> %t.sh
#if defined(TEST_128) && __cplusplus >= 201103L #if defined(TEST_128) && __cplusplus >= 201103L
#include <experimental/propagate_const> #include <experimental/propagate_const>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_129 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_129 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_129=$!' >> %t.sh // RUN: echo 'TEST_129=$!' >> %t.sh
// RUN: echo "wait $TEST_113" >> %t.sh // RUN: echo "wait $TEST_113" >> %t.sh
#if defined(TEST_129) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L #if defined(TEST_129) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
#include <experimental/regex> #include <experimental/regex>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_130 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_130 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_130=$!' >> %t.sh // RUN: echo 'TEST_130=$!' >> %t.sh
// RUN: echo "wait $TEST_114" >> %t.sh // RUN: echo "wait $TEST_114" >> %t.sh
#if defined(TEST_130) && __cplusplus >= 201103L #if defined(TEST_130) && __cplusplus >= 201103L
#include <experimental/set> #include <experimental/set>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_131 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_131 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_131=$!' >> %t.sh // RUN: echo 'TEST_131=$!' >> %t.sh
// RUN: echo "wait $TEST_115" >> %t.sh // RUN: echo "wait $TEST_115" >> %t.sh
#if defined(TEST_131) && __cplusplus >= 201103L #if defined(TEST_131) && __cplusplus >= 201103L
#include <experimental/simd> #include <experimental/simd>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_132 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_132 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_132=$!' >> %t.sh // RUN: echo 'TEST_132=$!' >> %t.sh
// RUN: echo "wait $TEST_116" >> %t.sh // RUN: echo "wait $TEST_116" >> %t.sh
#if defined(TEST_132) && __cplusplus >= 201103L #if defined(TEST_132) && __cplusplus >= 201103L
#include <experimental/string> #include <experimental/string>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_133 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_133 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_133=$!' >> %t.sh // RUN: echo 'TEST_133=$!' >> %t.sh
// RUN: echo "wait $TEST_117" >> %t.sh // RUN: echo "wait $TEST_117" >> %t.sh
#if defined(TEST_133) && __cplusplus >= 201103L #if defined(TEST_133) && __cplusplus >= 201103L
#include <experimental/type_traits> #include <experimental/type_traits>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_134 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_134 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_134=$!' >> %t.sh // RUN: echo 'TEST_134=$!' >> %t.sh
// RUN: echo "wait $TEST_118" >> %t.sh // RUN: echo "wait $TEST_118" >> %t.sh
#if defined(TEST_134) && __cplusplus >= 201103L #if defined(TEST_134) && __cplusplus >= 201103L
#include <experimental/unordered_map> #include <experimental/unordered_map>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_135 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_135 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_135=$!' >> %t.sh // RUN: echo 'TEST_135=$!' >> %t.sh
// RUN: echo "wait $TEST_119" >> %t.sh // RUN: echo "wait $TEST_119" >> %t.sh
#if defined(TEST_135) && __cplusplus >= 201103L #if defined(TEST_135) && __cplusplus >= 201103L
#include <experimental/unordered_set> #include <experimental/unordered_set>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_136 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_136 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_136=$!' >> %t.sh // RUN: echo 'TEST_136=$!' >> %t.sh
// RUN: echo "wait $TEST_120" >> %t.sh // RUN: echo "wait $TEST_120" >> %t.sh
#if defined(TEST_136) && __cplusplus >= 201103L #if defined(TEST_136) && __cplusplus >= 201103L
#include <experimental/utility> #include <experimental/utility>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_137 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_137 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_137=$!' >> %t.sh // RUN: echo 'TEST_137=$!' >> %t.sh
// RUN: echo "wait $TEST_121" >> %t.sh // RUN: echo "wait $TEST_121" >> %t.sh
#if defined(TEST_137) && __cplusplus >= 201103L #if defined(TEST_137) && __cplusplus >= 201103L
#include <experimental/vector> #include <experimental/vector>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_138 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_138 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_138=$!' >> %t.sh // RUN: echo 'TEST_138=$!' >> %t.sh
// RUN: echo "wait $TEST_122" >> %t.sh // RUN: echo "wait $TEST_122" >> %t.sh
#if defined(TEST_138) #if defined(TEST_138)
#include <ext/hash_map> #include <ext/hash_map>
#endif #endif
// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_139 &' >> %t.sh // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_139 -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS &' >> %t.sh
// RUN: echo 'TEST_139=$!' >> %t.sh // RUN: echo 'TEST_139=$!' >> %t.sh
// RUN: echo "wait $TEST_123" >> %t.sh // RUN: echo "wait $TEST_123" >> %t.sh
#if defined(TEST_139) #if defined(TEST_139)
#include <ext/hash_set> #include <ext/hash_set>
#endif #endif
// RUN: echo "wait $TEST_124" >> %t.sh // RUN: echo "wait $TEST_124" >> %t.sh
// RUN: echo "wait $TEST_125" >> %t.sh // RUN: echo "wait $TEST_125" >> %t.sh
// RUN: echo "wait $TEST_126" >> %t.sh // RUN: echo "wait $TEST_126" >> %t.sh
Show All 15 Lines

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

Show First 20 Lines • Show All 165 Lines • ▼ Show 20 Lines
#include <array> #include <array>
#include <atomic> #include <atomic>
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <barrier> # include <barrier>
#endif #endif
#include <bit> #include <bit>
#include <bitset> #include <bitset>
#include <cassert> #include <cassert>
#if __cplusplus < 201703L
#include <ccomplex> # include <ccomplex>
#endif
#include <cctype> #include <cctype>
#include <cerrno> #include <cerrno>
#include <cfenv> #include <cfenv>
#include <cfloat> #include <cfloat>
#include <charconv> #include <charconv>
#include <chrono> #include <chrono>
#include <cinttypes> #include <cinttypes>
#include <ciso646> #include <ciso646>
Show All 11 Lines
#include <concepts> #include <concepts>
#include <condition_variable> #include <condition_variable>
#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L) #if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
# include <coroutine> # include <coroutine>
#endif #endif
#include <csetjmp> #include <csetjmp>
#include <csignal> #include <csignal>
#include <cstdarg> #include <cstdarg>
#if __cplusplus < 201703L
#include <cstdbool> # include <cstdbool>
#endif
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#if __cplusplus < 201703L
#include <ctgmath> # include <ctgmath>
#endif
#include <ctime> #include <ctime>
#include <ctype.h> #include <ctype.h>
#include <cuchar> #include <cuchar>
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwchar> # include <cwchar>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwctype> # include <cwctype>
▲ Show 20 Lines • Show All 176 Lines • Show Last 20 Lines

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

Show All 38 Lines
#include <any> #include <any>
#include <array> #include <array>
#include <atomic> #include <atomic>
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <barrier> # include <barrier>
#endif #endif
#include <bit> #include <bit>
#include <bitset> #include <bitset>
#if __cplusplus < 201703L
#include <ccomplex> # include <ccomplex>
#endif
#include <cctype> #include <cctype>
#include <cerrno> #include <cerrno>
#include <cfenv> #include <cfenv>
#include <cfloat> #include <cfloat>
#include <charconv> #include <charconv>
#include <chrono> #include <chrono>
#include <cinttypes> #include <cinttypes>
#include <ciso646> #include <ciso646>
Show All 11 Lines
#include <concepts> #include <concepts>
#include <condition_variable> #include <condition_variable>
#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L) #if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
# include <coroutine> # include <coroutine>
#endif #endif
#include <csetjmp> #include <csetjmp>
#include <csignal> #include <csignal>
#include <cstdarg> #include <cstdarg>
#if __cplusplus < 201703L
#include <cstdbool> # include <cstdbool>
#endif
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#if __cplusplus < 201703L
#include <ctgmath> # include <ctgmath>
#endif
#include <ctime> #include <ctime>
#include <ctype.h> #include <ctype.h>
#include <cuchar> #include <cuchar>
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwchar> # include <cwchar>
#endif #endif
#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) #if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
# include <cwctype> # include <cwctype>
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

libcxx/test/libcxx/numerics/c.math/ctgmath.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ctgmath> // <ctgmath>
// REQUIRES: c++11 || c++0x || c++14 || c++1y
// XFAIL: c++17
#include <ctgmath> #include <ctgmath>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
Show All 9 Lines

libcxx/test/libcxx/numerics/complex.number/ccmplx/ccomplex.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ccomplex> // <ccomplex>
// REQUIRES: c++11 || c++0x || c++14 || c++1y
// XFAIL: c++17
#include <ccomplex> #include <ccomplex>
#include "test_macros.h" #include "test_macros.h"
#ifndef _LIBCPP_VERSION #ifndef _LIBCPP_VERSION
#error _LIBCPP_VERSION not defined #error _LIBCPP_VERSION not defined
#endif #endif
int main(int, char**) int main(int, char**)
{ {
std::complex<double> d; std::complex<double> d;
(void)d; (void)d;
return 0; return 0;
} }

libcxx/test/libcxx/transitive_includes.sh.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
BEGIN-SCRIPT BEGIN-SCRIPT
import re import re
# To re-generate the list of expected headers, temporarily set this to True, re-generate # To re-generate the list of expected headers, temporarily set this to True, re-generate
# the file and run this test. # the file and run this test.
# Note that this needs to be done for all supported language versions of libc++: # Note that this needs to be done for all supported language versions of libc++:
# for std in c++03 c++11 c++14 c++17 c++20 c++2b; do <build>/bin/llvm-lit --param std=$std ${path_to_this_file}; done # for std in c++03 c++11 c++14 c++17 c++20 c++2b; do <build>/bin/llvm-lit --param std=$std ${path_to_this_file}; done
regenerate_expected_results = False regenerate_expected_results = True
philnikUnsubmitted
Done
ReplyInline Actions
# for std in c++03 c++11 c++14 c++17 c++20 c++2b; do <build>/bin/llvm-lit --param std=$std ${path_to_this_file}; done
- regenerate_expected_results = True
+ regenerate_expected_results = False
# Used because the sequence of tokens RUN : can't appear anywhere or it'll confuse Lit.
philnik:
# Used because the sequence of tokens RUN : can't appear anywhere or it'll confuse Lit. # Used because the sequence of tokens RUN : can't appear anywhere or it'll confuse Lit.
RUN = "RUN" RUN = "RUN"
print(f"// {RUN}: mkdir %t") print(f"// {RUN}: mkdir %t")
for i, header in enumerate(public_headers): for i, header in enumerate(public_headers):
if header.endswith('.h'): # Skip C compatibility or detail headers if header.endswith('.h'): # Skip C compatibility or detail headers
continue continue
normalized_header = re.sub('/', '_', header) normalized_header = re.sub('/', '_', header)
print(f"// {RUN}: %{{cxx}} %s %{{flags}} %{{compile_flags}} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_{i} 2> %t/header.{normalized_header}") print(f"// {RUN}: %{{cxx}} %s %{{flags}} %{{compile_flags}} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_{i} 2> %t/header.{normalized_header}")
print(f"#if defined(TEST_{i})") print(f"#if defined(TEST_{i})")
print(f"#include <{header}>") print(f"#include <{header}>")
print("#endif") print("#endif")
if regenerate_expected_results: if regenerate_expected_results:
print(f"// {RUN}: %{{python}} %S/transitive_includes_to_csv.py %t > %S/transitive_includes/%{{cxx_std}}.csv") print(f"// {RUN}: %{{python}} %S/transitive_includes_to_csv.py %t > %S/transitive_includes/%{{cxx_std}}.csv")
else: else:
print(f"// {RUN}: %{{python}} %S/transitive_includes_to_csv.py %t > %t/transitive_includes.csv") print(f"// {RUN}: %{{python}} %S/transitive_includes_to_csv.py %t > %t/transitive_includes.csv")
print(f"// {RUN}: diff -w %S/transitive_includes/%{{cxx_std}}.csv %t/transitive_includes.csv") print(f"// {RUN}: diff -w %S/transitive_includes/%{{cxx_std}}.csv %t/transitive_includes.csv")
END-SCRIPT END-SCRIPT
*/ */
// DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW // DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW
// GENERATED-MARKER // GENERATED-MARKER
// RUN: mkdir %t // RUN: mkdir %t
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_0 2> %t/header.algorithm // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_0 2> %t/header.algorithm
#if defined(TEST_0) #if defined(TEST_0)
#include <algorithm> #include <algorithm>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_1 2> %t/header.any // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_1 2> %t/header.any
#if defined(TEST_1) #if defined(TEST_1)
#include <any> #include <any>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_2 2> %t/header.array // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_2 2> %t/header.array
#if defined(TEST_2) #if defined(TEST_2)
#include <array> #include <array>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_3 2> %t/header.atomic // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_3 2> %t/header.atomic
#if defined(TEST_3) #if defined(TEST_3)
#include <atomic> #include <atomic>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_4 2> %t/header.barrier // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_4 2> %t/header.barrier
#if defined(TEST_4) #if defined(TEST_4)
#include <barrier> #include <barrier>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_5 2> %t/header.bit // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_5 2> %t/header.bit
#if defined(TEST_5) #if defined(TEST_5)
#include <bit> #include <bit>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_6 2> %t/header.bitset // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_6 2> %t/header.bitset
#if defined(TEST_6) #if defined(TEST_6)
#include <bitset> #include <bitset>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_7 2> %t/header.cassert // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_7 2> %t/header.cassert
#if defined(TEST_7) #if defined(TEST_7)
#include <cassert> #include <cassert>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_8 2> %t/header.ccomplex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_8 2> %t/header.ccomplex
#if defined(TEST_8) #if defined(TEST_8)
#include <ccomplex> #include <ccomplex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_9 2> %t/header.cctype // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_9 2> %t/header.cctype
#if defined(TEST_9) #if defined(TEST_9)
#include <cctype> #include <cctype>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_10 2> %t/header.cerrno // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_10 2> %t/header.cerrno
#if defined(TEST_10) #if defined(TEST_10)
#include <cerrno> #include <cerrno>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_11 2> %t/header.cfenv // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_11 2> %t/header.cfenv
#if defined(TEST_11) #if defined(TEST_11)
#include <cfenv> #include <cfenv>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_12 2> %t/header.cfloat // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_12 2> %t/header.cfloat
#if defined(TEST_12) #if defined(TEST_12)
#include <cfloat> #include <cfloat>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_13 2> %t/header.charconv // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_13 2> %t/header.charconv
#if defined(TEST_13) #if defined(TEST_13)
#include <charconv> #include <charconv>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_14 2> %t/header.chrono // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_14 2> %t/header.chrono
#if defined(TEST_14) #if defined(TEST_14)
#include <chrono> #include <chrono>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_15 2> %t/header.cinttypes // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_15 2> %t/header.cinttypes
#if defined(TEST_15) #if defined(TEST_15)
#include <cinttypes> #include <cinttypes>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_16 2> %t/header.ciso646 // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_16 2> %t/header.ciso646
#if defined(TEST_16) #if defined(TEST_16)
#include <ciso646> #include <ciso646>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_17 2> %t/header.climits // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_17 2> %t/header.climits
#if defined(TEST_17) #if defined(TEST_17)
#include <climits> #include <climits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_18 2> %t/header.clocale // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_18 2> %t/header.clocale
#if defined(TEST_18) #if defined(TEST_18)
#include <clocale> #include <clocale>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_19 2> %t/header.cmath // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_19 2> %t/header.cmath
#if defined(TEST_19) #if defined(TEST_19)
#include <cmath> #include <cmath>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_20 2> %t/header.codecvt // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_20 2> %t/header.codecvt
#if defined(TEST_20) #if defined(TEST_20)
#include <codecvt> #include <codecvt>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_21 2> %t/header.compare // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_21 2> %t/header.compare
#if defined(TEST_21) #if defined(TEST_21)
#include <compare> #include <compare>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_22 2> %t/header.complex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_22 2> %t/header.complex
#if defined(TEST_22) #if defined(TEST_22)
#include <complex> #include <complex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_24 2> %t/header.concepts // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_24 2> %t/header.concepts
#if defined(TEST_24) #if defined(TEST_24)
#include <concepts> #include <concepts>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_25 2> %t/header.condition_variable // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_25 2> %t/header.condition_variable
#if defined(TEST_25) #if defined(TEST_25)
#include <condition_variable> #include <condition_variable>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_26 2> %t/header.coroutine // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_26 2> %t/header.coroutine
#if defined(TEST_26) #if defined(TEST_26)
#include <coroutine> #include <coroutine>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_27 2> %t/header.csetjmp // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_27 2> %t/header.csetjmp
#if defined(TEST_27) #if defined(TEST_27)
#include <csetjmp> #include <csetjmp>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_28 2> %t/header.csignal // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_28 2> %t/header.csignal
#if defined(TEST_28) #if defined(TEST_28)
#include <csignal> #include <csignal>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_29 2> %t/header.cstdarg // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_29 2> %t/header.cstdarg
#if defined(TEST_29) #if defined(TEST_29)
#include <cstdarg> #include <cstdarg>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_30 2> %t/header.cstdbool // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_30 2> %t/header.cstdbool
#if defined(TEST_30) #if defined(TEST_30)
#include <cstdbool> #include <cstdbool>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_31 2> %t/header.cstddef // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_31 2> %t/header.cstddef
#if defined(TEST_31) #if defined(TEST_31)
#include <cstddef> #include <cstddef>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_32 2> %t/header.cstdint // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_32 2> %t/header.cstdint
#if defined(TEST_32) #if defined(TEST_32)
#include <cstdint> #include <cstdint>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_33 2> %t/header.cstdio // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_33 2> %t/header.cstdio
#if defined(TEST_33) #if defined(TEST_33)
#include <cstdio> #include <cstdio>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_34 2> %t/header.cstdlib // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_34 2> %t/header.cstdlib
#if defined(TEST_34) #if defined(TEST_34)
#include <cstdlib> #include <cstdlib>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_35 2> %t/header.cstring // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_35 2> %t/header.cstring
#if defined(TEST_35) #if defined(TEST_35)
#include <cstring> #include <cstring>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_36 2> %t/header.ctgmath // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_36 2> %t/header.ctgmath
#if defined(TEST_36) #if defined(TEST_36)
#include <ctgmath> #include <ctgmath>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_37 2> %t/header.ctime // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_37 2> %t/header.ctime
#if defined(TEST_37) #if defined(TEST_37)
#include <ctime> #include <ctime>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_39 2> %t/header.cuchar // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_39 2> %t/header.cuchar
#if defined(TEST_39) #if defined(TEST_39)
#include <cuchar> #include <cuchar>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_40 2> %t/header.cwchar // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_40 2> %t/header.cwchar
#if defined(TEST_40) #if defined(TEST_40)
#include <cwchar> #include <cwchar>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_41 2> %t/header.cwctype // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_41 2> %t/header.cwctype
#if defined(TEST_41) #if defined(TEST_41)
#include <cwctype> #include <cwctype>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_42 2> %t/header.deque // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_42 2> %t/header.deque
#if defined(TEST_42) #if defined(TEST_42)
#include <deque> #include <deque>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_44 2> %t/header.exception // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_44 2> %t/header.exception
#if defined(TEST_44) #if defined(TEST_44)
#include <exception> #include <exception>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_45 2> %t/header.execution // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_45 2> %t/header.execution
#if defined(TEST_45) #if defined(TEST_45)
#include <execution> #include <execution>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_46 2> %t/header.expected // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_46 2> %t/header.expected
#if defined(TEST_46) #if defined(TEST_46)
#include <expected> #include <expected>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_48 2> %t/header.filesystem // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_48 2> %t/header.filesystem
#if defined(TEST_48) #if defined(TEST_48)
#include <filesystem> #include <filesystem>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_50 2> %t/header.format // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_50 2> %t/header.format
#if defined(TEST_50) #if defined(TEST_50)
#include <format> #include <format>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_51 2> %t/header.forward_list // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_51 2> %t/header.forward_list
#if defined(TEST_51) #if defined(TEST_51)
#include <forward_list> #include <forward_list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_52 2> %t/header.fstream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_52 2> %t/header.fstream
#if defined(TEST_52) #if defined(TEST_52)
#include <fstream> #include <fstream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_53 2> %t/header.functional // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_53 2> %t/header.functional
#if defined(TEST_53) #if defined(TEST_53)
#include <functional> #include <functional>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_54 2> %t/header.future // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_54 2> %t/header.future
#if defined(TEST_54) #if defined(TEST_54)
#include <future> #include <future>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_55 2> %t/header.initializer_list // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_55 2> %t/header.initializer_list
#if defined(TEST_55) #if defined(TEST_55)
#include <initializer_list> #include <initializer_list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_57 2> %t/header.iomanip // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_57 2> %t/header.iomanip
#if defined(TEST_57) #if defined(TEST_57)
#include <iomanip> #include <iomanip>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_58 2> %t/header.ios // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_58 2> %t/header.ios
#if defined(TEST_58) #if defined(TEST_58)
#include <ios> #include <ios>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_59 2> %t/header.iosfwd // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_59 2> %t/header.iosfwd
#if defined(TEST_59) #if defined(TEST_59)
#include <iosfwd> #include <iosfwd>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_60 2> %t/header.iostream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_60 2> %t/header.iostream
#if defined(TEST_60) #if defined(TEST_60)
#include <iostream> #include <iostream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_61 2> %t/header.istream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_61 2> %t/header.istream
#if defined(TEST_61) #if defined(TEST_61)
#include <istream> #include <istream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_62 2> %t/header.iterator // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_62 2> %t/header.iterator
#if defined(TEST_62) #if defined(TEST_62)
#include <iterator> #include <iterator>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_63 2> %t/header.latch // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_63 2> %t/header.latch
#if defined(TEST_63) #if defined(TEST_63)
#include <latch> #include <latch>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_64 2> %t/header.limits // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_64 2> %t/header.limits
#if defined(TEST_64) #if defined(TEST_64)
#include <limits> #include <limits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_66 2> %t/header.list // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_66 2> %t/header.list
#if defined(TEST_66) #if defined(TEST_66)
#include <list> #include <list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_67 2> %t/header.locale // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_67 2> %t/header.locale
#if defined(TEST_67) #if defined(TEST_67)
#include <locale> #include <locale>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_69 2> %t/header.map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_69 2> %t/header.map
#if defined(TEST_69) #if defined(TEST_69)
#include <map> #include <map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_71 2> %t/header.memory // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_71 2> %t/header.memory
#if defined(TEST_71) #if defined(TEST_71)
#include <memory> #include <memory>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_72 2> %t/header.memory_resource // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_72 2> %t/header.memory_resource
#if defined(TEST_72) #if defined(TEST_72)
#include <memory_resource> #include <memory_resource>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_73 2> %t/header.mutex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_73 2> %t/header.mutex
#if defined(TEST_73) #if defined(TEST_73)
#include <mutex> #include <mutex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_74 2> %t/header.new // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_74 2> %t/header.new
#if defined(TEST_74) #if defined(TEST_74)
#include <new> #include <new>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_75 2> %t/header.numbers // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_75 2> %t/header.numbers
#if defined(TEST_75) #if defined(TEST_75)
#include <numbers> #include <numbers>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_76 2> %t/header.numeric // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_76 2> %t/header.numeric
#if defined(TEST_76) #if defined(TEST_76)
#include <numeric> #include <numeric>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_77 2> %t/header.optional // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_77 2> %t/header.optional
#if defined(TEST_77) #if defined(TEST_77)
#include <optional> #include <optional>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_78 2> %t/header.ostream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_78 2> %t/header.ostream
#if defined(TEST_78) #if defined(TEST_78)
#include <ostream> #include <ostream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_79 2> %t/header.queue // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_79 2> %t/header.queue
#if defined(TEST_79) #if defined(TEST_79)
#include <queue> #include <queue>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_80 2> %t/header.random // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_80 2> %t/header.random
#if defined(TEST_80) #if defined(TEST_80)
#include <random> #include <random>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_81 2> %t/header.ranges // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_81 2> %t/header.ranges
#if defined(TEST_81) #if defined(TEST_81)
#include <ranges> #include <ranges>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_82 2> %t/header.ratio // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_82 2> %t/header.ratio
#if defined(TEST_82) #if defined(TEST_82)
#include <ratio> #include <ratio>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_83 2> %t/header.regex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_83 2> %t/header.regex
#if defined(TEST_83) #if defined(TEST_83)
#include <regex> #include <regex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_84 2> %t/header.scoped_allocator // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_84 2> %t/header.scoped_allocator
#if defined(TEST_84) #if defined(TEST_84)
#include <scoped_allocator> #include <scoped_allocator>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_85 2> %t/header.semaphore // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_85 2> %t/header.semaphore
#if defined(TEST_85) #if defined(TEST_85)
#include <semaphore> #include <semaphore>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_86 2> %t/header.set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_86 2> %t/header.set
#if defined(TEST_86) #if defined(TEST_86)
#include <set> #include <set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_88 2> %t/header.shared_mutex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_88 2> %t/header.shared_mutex
#if defined(TEST_88) #if defined(TEST_88)
#include <shared_mutex> #include <shared_mutex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_89 2> %t/header.source_location // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_89 2> %t/header.source_location
#if defined(TEST_89) #if defined(TEST_89)
#include <source_location> #include <source_location>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_90 2> %t/header.span // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_90 2> %t/header.span
#if defined(TEST_90) #if defined(TEST_90)
#include <span> #include <span>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_91 2> %t/header.sstream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_91 2> %t/header.sstream
#if defined(TEST_91) #if defined(TEST_91)
#include <sstream> #include <sstream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_92 2> %t/header.stack // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_92 2> %t/header.stack
#if defined(TEST_92) #if defined(TEST_92)
#include <stack> #include <stack>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_96 2> %t/header.stdexcept // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_96 2> %t/header.stdexcept
#if defined(TEST_96) #if defined(TEST_96)
#include <stdexcept> #include <stdexcept>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_100 2> %t/header.streambuf // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_100 2> %t/header.streambuf
#if defined(TEST_100) #if defined(TEST_100)
#include <streambuf> #include <streambuf>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_101 2> %t/header.string // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_101 2> %t/header.string
#if defined(TEST_101) #if defined(TEST_101)
#include <string> #include <string>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_103 2> %t/header.string_view // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_103 2> %t/header.string_view
#if defined(TEST_103) #if defined(TEST_103)
#include <string_view> #include <string_view>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_104 2> %t/header.strstream // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_104 2> %t/header.strstream
#if defined(TEST_104) #if defined(TEST_104)
#include <strstream> #include <strstream>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_105 2> %t/header.system_error // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_105 2> %t/header.system_error
#if defined(TEST_105) #if defined(TEST_105)
#include <system_error> #include <system_error>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_107 2> %t/header.thread // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_107 2> %t/header.thread
#if defined(TEST_107) #if defined(TEST_107)
#include <thread> #include <thread>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_108 2> %t/header.tuple // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_108 2> %t/header.tuple
#if defined(TEST_108) #if defined(TEST_108)
#include <tuple> #include <tuple>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_109 2> %t/header.type_traits // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_109 2> %t/header.type_traits
#if defined(TEST_109) #if defined(TEST_109)
#include <type_traits> #include <type_traits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_110 2> %t/header.typeindex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_110 2> %t/header.typeindex
#if defined(TEST_110) #if defined(TEST_110)
#include <typeindex> #include <typeindex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_111 2> %t/header.typeinfo // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_111 2> %t/header.typeinfo
#if defined(TEST_111) #if defined(TEST_111)
#include <typeinfo> #include <typeinfo>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_113 2> %t/header.unordered_map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_113 2> %t/header.unordered_map
#if defined(TEST_113) #if defined(TEST_113)
#include <unordered_map> #include <unordered_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_114 2> %t/header.unordered_set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_114 2> %t/header.unordered_set
#if defined(TEST_114) #if defined(TEST_114)
#include <unordered_set> #include <unordered_set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_115 2> %t/header.utility // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_115 2> %t/header.utility
#if defined(TEST_115) #if defined(TEST_115)
#include <utility> #include <utility>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_116 2> %t/header.valarray // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_116 2> %t/header.valarray
#if defined(TEST_116) #if defined(TEST_116)
#include <valarray> #include <valarray>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_117 2> %t/header.variant // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_117 2> %t/header.variant
#if defined(TEST_117) #if defined(TEST_117)
#include <variant> #include <variant>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_118 2> %t/header.vector // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_118 2> %t/header.vector
#if defined(TEST_118) #if defined(TEST_118)
#include <vector> #include <vector>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_119 2> %t/header.version // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_119 2> %t/header.version
#if defined(TEST_119) #if defined(TEST_119)
#include <version> #include <version>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_122 2> %t/header.experimental_deque // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_122 2> %t/header.experimental_deque
#if defined(TEST_122) #if defined(TEST_122)
#include <experimental/deque> #include <experimental/deque>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_123 2> %t/header.experimental_forward_list // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_123 2> %t/header.experimental_forward_list
#if defined(TEST_123) #if defined(TEST_123)
#include <experimental/forward_list> #include <experimental/forward_list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_124 2> %t/header.experimental_iterator // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_124 2> %t/header.experimental_iterator
#if defined(TEST_124) #if defined(TEST_124)
#include <experimental/iterator> #include <experimental/iterator>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_125 2> %t/header.experimental_list // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_125 2> %t/header.experimental_list
#if defined(TEST_125) #if defined(TEST_125)
#include <experimental/list> #include <experimental/list>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_126 2> %t/header.experimental_map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_126 2> %t/header.experimental_map
#if defined(TEST_126) #if defined(TEST_126)
#include <experimental/map> #include <experimental/map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_127 2> %t/header.experimental_memory_resource // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_127 2> %t/header.experimental_memory_resource
#if defined(TEST_127) #if defined(TEST_127)
#include <experimental/memory_resource> #include <experimental/memory_resource>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_128 2> %t/header.experimental_propagate_const // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_128 2> %t/header.experimental_propagate_const
#if defined(TEST_128) #if defined(TEST_128)
#include <experimental/propagate_const> #include <experimental/propagate_const>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_129 2> %t/header.experimental_regex // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_129 2> %t/header.experimental_regex
#if defined(TEST_129) #if defined(TEST_129)
#include <experimental/regex> #include <experimental/regex>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_130 2> %t/header.experimental_set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_130 2> %t/header.experimental_set
#if defined(TEST_130) #if defined(TEST_130)
#include <experimental/set> #include <experimental/set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_131 2> %t/header.experimental_simd // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_131 2> %t/header.experimental_simd
#if defined(TEST_131) #if defined(TEST_131)
#include <experimental/simd> #include <experimental/simd>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_132 2> %t/header.experimental_string // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_132 2> %t/header.experimental_string
#if defined(TEST_132) #if defined(TEST_132)
#include <experimental/string> #include <experimental/string>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_133 2> %t/header.experimental_type_traits // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_133 2> %t/header.experimental_type_traits
#if defined(TEST_133) #if defined(TEST_133)
#include <experimental/type_traits> #include <experimental/type_traits>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_134 2> %t/header.experimental_unordered_map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_134 2> %t/header.experimental_unordered_map
#if defined(TEST_134) #if defined(TEST_134)
#include <experimental/unordered_map> #include <experimental/unordered_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_135 2> %t/header.experimental_unordered_set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_135 2> %t/header.experimental_unordered_set
#if defined(TEST_135) #if defined(TEST_135)
#include <experimental/unordered_set> #include <experimental/unordered_set>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_136 2> %t/header.experimental_utility // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_136 2> %t/header.experimental_utility
#if defined(TEST_136) #if defined(TEST_136)
#include <experimental/utility> #include <experimental/utility>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_137 2> %t/header.experimental_vector // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_137 2> %t/header.experimental_vector
#if defined(TEST_137) #if defined(TEST_137)
#include <experimental/vector> #include <experimental/vector>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_138 2> %t/header.ext_hash_map // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_138 2> %t/header.ext_hash_map
#if defined(TEST_138) #if defined(TEST_138)
#include <ext/hash_map> #include <ext/hash_map>
#endif #endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -DTEST_139 2> %t/header.ext_hash_set // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes -fsyntax-only -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -DTEST_139 2> %t/header.ext_hash_set
#if defined(TEST_139) #if defined(TEST_139)
#include <ext/hash_set> #include <ext/hash_set>
#endif #endif
// RUN: %{python} %S/transitive_includes_to_csv.py %t > %t/transitive_includes.csv // RUN: %{python} %S/transitive_includes_to_csv.py %t > %S/transitive_includes/%{cxx_std}.csv
// RUN: diff -w %S/transitive_includes/%{cxx_std}.csv %t/transitive_includes.csv
// GENERATED-MARKER // GENERATED-MARKER

libcxx/test/std/language.support/support.runtime/cstdbool.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// test <cstdbool> // test <cstdbool>
// REQUIRES: c++11 || c++0x || c++14 || c++1y
MordanteAuthorUnsubmitted
Not Done
ReplyInline Actions

Why not using the UNSUPPORTED like we usually do?

Mordante: Why not using the UNSUPPORTED like we usually do?
ayzhaoUnsubmitted
Done
ReplyInline Actions

My idea was that by using XFAIL, we can test that the deprecation warning works (since we build with -Werror).

ayzhao: My idea was that by using `XFAIL`, we can test that the deprecation warning works (since we…
philnikUnsubmitted
Not Done
ReplyInline Actions

That should instead be done with a .verify.cpp. You can also run the test suite without warnings enabled, and having an XFAIL from a warning would break this. The .verify.cpp also checks what warnings/errors are generated instead of just XFAILing for any reason.

philnik: That should instead be done with a `.verify.cpp`. You can also run the test suite without…
// XFAIL: c++17
#include <cstdbool> #include <cstdbool>
#include "test_macros.h" #include "test_macros.h"
#ifndef __bool_true_false_are_defined #ifndef __bool_true_false_are_defined
#error __bool_true_false_are_defined not defined #error __bool_true_false_are_defined not defined
#endif #endif
Show All 17 Lines

libcxx/test/std/numerics/c.math/ctgmath.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ctgmath> // <ctgmath>
// REQUIRES: c++11 || c++0x || c++14 || c++1y
// XFAIL: c++17
#include <ctgmath> #include <ctgmath>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::complex<double> cd; std::complex<double> cd;
(void)cd; (void)cd;
double x = std::sin(0); double x = std::sin(0);
((void)x); // Prevent unused warning ((void)x); // Prevent unused warning
return 0; return 0;
} }

libcxx/test/std/numerics/complex.number/ccmplx/ccomplex.pass.cpp

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// <ccomplex> // <ccomplex>
// REQUIRES: c++11 || c++0x || c++14 || c++1y
// XFAIL: c++17
#include <ccomplex> #include <ccomplex>
#include "test_macros.h" #include "test_macros.h"
int main(int, char**) int main(int, char**)
{ {
std::complex<double> d; std::complex<double> d;
(void)d; (void)d;
return 0; return 0;
} }

libcxx/utils/generate_header_tests.py

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Linesheader_restrictions = {
"experimental/simd": "__cplusplus >= 201103L", "experimental/simd": "__cplusplus >= 201103L",
"experimental/span": "__cplusplus >= 201103L", "experimental/span": "__cplusplus >= 201103L",
"experimental/string": "__cplusplus >= 201103L", "experimental/string": "__cplusplus >= 201103L",
"experimental/type_traits": "__cplusplus >= 201103L", "experimental/type_traits": "__cplusplus >= 201103L",
"experimental/unordered_map": "__cplusplus >= 201103L", "experimental/unordered_map": "__cplusplus >= 201103L",
"experimental/unordered_set": "__cplusplus >= 201103L", "experimental/unordered_set": "__cplusplus >= 201103L",
"experimental/utility": "__cplusplus >= 201103L", "experimental/utility": "__cplusplus >= 201103L",
"experimental/vector": "__cplusplus >= 201103L", "experimental/vector": "__cplusplus >= 201103L",
"ccomplex": "__cplusplus < 201703L",
"cstdbool": "__cplusplus < 201703L",
"ctgmath": "__cplusplus < 201703L",
philnikUnsubmitted
Done
ReplyInline Actions

We shouldn't disable the tests just because the headers are deprecated. It's still fine to use them in C++17.

philnik: We shouldn't disable the tests just because the headers are deprecated. It's still fine to use…
} }
private_headers_still_public_in_modules = [ private_headers_still_public_in_modules = [
'__assert', '__bsd_locale_defaults.h', '__bsd_locale_fallbacks.h', '__config', '__assert', '__bsd_locale_defaults.h', '__bsd_locale_fallbacks.h', '__config',
'__config_site.in', '__debug', '__hash_table', '__config_site.in', '__debug', '__hash_table',
'__threading_support', '__tree', '__undef_macros', '__verbose_abort' '__threading_support', '__tree', '__undef_macros', '__verbose_abort'
] ]
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines