This is an archive of the discontinued LLVM Phabricator instance.

Differential D128236

[libc++] Add a test to pin down the set of transitive public includes
ClosedPublic

Authored by ldionne on Jun 20 2022, 5:51 PM.

Details

Reviewers
Mordante
ldionne
Group Reviewers
Restricted Project
Commits
rG23d6cde14de3: [libc++] Add a test to pin down the set of transitive public includes
Summary

A situation that happens fairly often in libc++ is that we remove some
transitive includes in a header (either purposefully or not) and that
ends up breaking users. Of course, we want to be able to remove our
transitive includes, however it's also good to have a grip on that
to know which commit changed what and when. Furthermore, it's good
to accumulate include removals for a couple of releases to avoid
breaking users at every release for this reason.

This commit adds a test that should break whenever we remove an
include. Hence, it should allow us to track which headers include
which other headers transitively, giving us a traceable way to
remove headers.

Diff Detail

Event Timeline

ldionne created this revision.Jun 20 2022, 5:51 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 20 2022, 5:51 PM
Herald added subscribers: miyuki, arphaman, arichardson. · View Herald Transcript
ldionne requested review of this revision.Jun 20 2022, 5:51 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 20 2022, 5:51 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B170945: Diff 438510.Jun 20 2022, 5:52 PM
ldionne updated this revision to Diff 438712.Jun 21 2022, 8:23 AM

Poke CI, which is rather flaky right now.

Harbormaster completed remote builds in B171105: Diff 438712.Jun 21 2022, 8:24 AM
Mordante added a subscriber: Mordante.Jun 21 2022, 9:57 AM

Thanks for working on this! I think this is really useful to have. The makes it easier to remove includes from subheaders and see whether that as a user visible impact.
I'm a bit curious whether it will cause a lot of build failures. (I know it shouldn't.)

libcxx/test/libcxx/transitive_includes.sh.cpp
16

Would it be an idea to add a "schedule" here too? Basically to avoid people working on a cleanup patch and have it rejected just because it's not "the right time". For example only cleanup when the next version number is a multiple of 3. (3 just because 15 is a multiple of 3.)
(But maybe we should discuss the details on Discord.)

libcxx/test/libcxx/transitive_includes/expected.algorithm
2

Should the path include c++/v1? If we want that we probably need to make the test unsupported for the unstable ABI too.

ldionne updated this revision to Diff 439058.Jun 22 2022, 9:30 AM
ldionne marked 2 inline comments as done.

Do not list c++/v1/ explicitly.

libcxx/test/libcxx/transitive_includes.sh.cpp
16

When I first read this comment, I was thinking "this is a great idea". Then I gave it some more thought and I am not so sure. Indeed, I don't think we should be held to a specific (and arbitrary) schedule for breaking transitive header dependencies: instead we should do it in a reasoned fashion when it makes the most sense. For example, we are going to ship large parts of Ranges in LLVM 15, so making the transition to LLVM 15 as seamless as possible is desirable for users to get the benefits of Ranges ASAP. So much so that my plan was actually to go back and re-add some headers we've removed since branching LLVM 14 to avoid breaking folks in this release.

After all, I don't think we would reject any cleanup patch because it's "not the right time". We would simply add some transitive includes for backwards compatibility with a TODO above them, so the cost here is really small.

TLDR: Let's be very intentional about removing these transitive dependencies, and we can even give a heads up in advance for people to get prepared. The amount of breakage that this can cause (and the barrier it adds to adoption of a new libc++) is surprisingly high.

Harbormaster completed remote builds in B171350: Diff 439058.Jun 22 2022, 9:30 AM
Mordante accepted this revision as: Mordante.Jun 22 2022, 10:17 AM

LGTM when the CI is happy.

libcxx/test/libcxx/transitive_includes.sh.cpp
16

I started a discussion on Discord.

jloser added a subscriber: jloser.Jun 22 2022, 11:37 AM

I like this general direction! Thanks for working on this.

ldionne updated this revision to Diff 439136.Jun 22 2022, 12:45 PM

Try to fix CI.

Harbormaster completed remote builds in B171406: Diff 439136.Jun 22 2022, 3:05 PM
ldionne updated this revision to Diff 439173.Jun 22 2022, 3:08 PM

More CI fixes, in particular try to make the test work on Windows and AIX by ditching grep and sed.

Harbormaster completed remote builds in B171434: Diff 439173.Jun 22 2022, 3:34 PM
ldionne updated this revision to Diff 439410.Jun 23 2022, 8:25 AM

Fix CI.

Harbormaster completed remote builds in B171620: Diff 439410.Jun 23 2022, 9:32 AM
ldionne updated this revision to Diff 439485.Jun 23 2022, 11:39 AM
ldionne added subscribers: daltenty, mstorsjo.

XFAIL on Windows and AIX. This should be close to working on Windows and AIX (I tried removing anything obviously non-portable).

@mstorsjo @daltenty When I land this, it would be really good to have someone fix the test on those two platforms.

Harbormaster completed remote builds in B171665: Diff 439485.Jun 23 2022, 12:50 PM
ldionne accepted this revision.Jun 23 2022, 1:23 PM
This revision is now accepted and ready to land.Jun 23 2022, 1:23 PM
Closed by commit rG23d6cde14de3: [libc++] Add a test to pin down the set of transitive public includes (authored by ldionne). · Explain WhyJun 23 2022, 1:24 PM
This revision was automatically updated to reflect the committed changes.
ldionne added a commit: rG23d6cde14de3: [libc++] Add a test to pin down the set of transitive public includes.

Revision Contents

PathSize
libcxx/
include/
5 lines
4 lines
test/
libcxx/
lint/
lint/
selftest/
dsl/
4 lines
33 lines
674 lines
transitive_includes/
24 lines
23 lines
14 lines
11 lines
23 lines
7 lines
29 lines
1 line
41 lines
1 line
1 line
1 line
1 line
11 lines
11 lines
2 lines
1 line
1 line
1 line
6 lines
32 lines
7 lines
40 lines
5 lines
31 lines
9 lines
1 line
1 line
1 line
1 line
2 lines
1 line
1 line
1 line
1 line
42 lines
1 line
1 line
3 lines
2 lines
23 lines
6 lines
2 lines
25 lines
23 lines
27 lines
27 lines
28 lines
18 lines
27 lines
28 lines
25 lines
5 lines
39 lines
28 lines
16 lines
32 lines
6 lines
28 lines
28 lines
11 lines
27 lines
36 lines
36 lines
40 lines
40 lines
23 lines
41 lines
27 lines
33 lines
3 lines
39 lines
32 lines
2 lines
39 lines
38 lines
17 lines
12 lines
5 lines
23 lines
35 lines
24 lines
22 lines
31 lines
7 lines
6 lines
8 lines
15 lines
37 lines
25 lines
32 lines
22 lines
6 lines
34 lines
23 lines
12 lines
24 lines
31 lines
15 lines
39 lines
24 lines
8 lines
33 lines
28 lines
19 lines
39 lines
30 lines
31 lines
8 lines
4 lines
11 lines
7 lines
24 lines
24 lines
10 lines
15 lines
14 lines
23 lines
1 line
utils/
1 line

Diff 439514

libcxx/include/__debug

// -*- C++ -*- // -*- C++ -*-
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// 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
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef _LIBCPP___DEBUG #ifndef _LIBCPP___DEBUG
#define _LIBCPP___DEBUG #define _LIBCPP___DEBUG
#include <__assert> #include <__assert>
#include <__config> #include <__config>
#include <cstddef>
#include <type_traits> #include <type_traits>
#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
// Catch invalid uses of the legacy _LIBCPP_DEBUG toggle. // Catch invalid uses of the legacy _LIBCPP_DEBUG toggle.
#if defined(_LIBCPP_DEBUG) && _LIBCPP_DEBUG != 0 && !defined(_LIBCPP_ENABLE_DEBUG_MODE) #if defined(_LIBCPP_DEBUG) && _LIBCPP_DEBUG != 0 && !defined(_LIBCPP_ENABLE_DEBUG_MODE)
Show All 23 Lines
#ifdef _LIBCPP_ENABLE_DEBUG_MODE #ifdef _LIBCPP_ENABLE_DEBUG_MODE
# define _LIBCPP_DEBUG_ASSERT(x, m) _LIBCPP_ASSERT(::std::__libcpp_is_constant_evaluated() || (x), m) # define _LIBCPP_DEBUG_ASSERT(x, m) _LIBCPP_ASSERT(::std::__libcpp_is_constant_evaluated() || (x), m)
#else #else
# define _LIBCPP_DEBUG_ASSERT(x, m) ((void)0) # define _LIBCPP_DEBUG_ASSERT(x, m) ((void)0)
#endif #endif
#if defined(_LIBCPP_ENABLE_DEBUG_MODE) || defined(_LIBCPP_BUILDING_LIBRARY) #if defined(_LIBCPP_ENABLE_DEBUG_MODE) || defined(_LIBCPP_BUILDING_LIBRARY)
#include <cstddef>
#include <cstdio>
#include <cstdlib>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
struct _LIBCPP_TYPE_VIS __c_node; struct _LIBCPP_TYPE_VIS __c_node;
struct _LIBCPP_TYPE_VIS __i_node struct _LIBCPP_TYPE_VIS __i_node
{ {
void* __i_; void* __i_;
__i_node* __next_; __i_node* __next_;
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

libcxx/include/locale

Show First 20 Lines • Show All 195 Lines • ▼ Show 20 Lines
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__config> #include <__config>
#include <__debug> #include <__debug>
#include <__iterator/access.h> #include <__iterator/access.h>
#include <__iterator/back_insert_iterator.h> #include <__iterator/back_insert_iterator.h>
#include <__iterator/istreambuf_iterator.h> #include <__iterator/istreambuf_iterator.h>
#include <__iterator/ostreambuf_iterator.h> #include <__iterator/ostreambuf_iterator.h>
#include <__locale> #include <__locale>
#ifndef __APPLE__ #include <cstdarg> // TODO: Remove this include
# include <cstdarg>
#endif
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <ctime> #include <ctime>
#include <ios> #include <ios>
#include <limits> #include <limits>
#include <memory> #include <memory>
#include <streambuf> #include <streambuf>
#include <version> #include <version>
▲ Show 20 Lines • Show All 4,139 Lines • Show Last 20 Lines

libcxx/test/libcxx/lint/lit.local.cfg

  • This file was moved to libcxx/test/libcxx/lit.local.cfg.

libcxx/test/libcxx/lit.local.cfg

  • This file was moved from libcxx/test/libcxx/lint/lit.local.cfg.
The contents of this file were not changed.

libcxx/test/libcxx/selftest/dsl/lit.local.cfg

# Since we try to pass substitutions as-is to some tests, we must "escape" # Since we try to pass substitutions as-is to some tests, we must "escape"
# them in case they contain other substitutions. Otherwise, the substitutions # them in case they contain other substitutions. Otherwise, the substitutions
# will be fully expanded when passed to the tests. For example, we want an # will be fully expanded when passed to the tests. For example, we want an
# %{exec} substitution that contains `--execdir %T` to be passed as-is, without # %{exec} substitution that contains `--execdir %T` to be passed as-is, without
# substituting the directory. This way, the test itself can populate %T as it # substituting the directory. This way, the test itself can populate %T as it
# sees fit, and %{exec} will respect it. # sees fit, and %{exec} will respect it.
# #
# To solve this problem, we pickle the substitutions and base64 encode that # To solve this problem, we pickle the substitutions and base64 encode that
# to pass it to the test, and we decode and unpickle the substitutions from # to pass it to the test, and we decode and unpickle the substitutions from
# within the test. # within the test.
import base64, lit.util, pickle import base64, lit.util, pickle
base64Encode = lambda s: lit.util.to_string(base64.b64encode(lit.util.to_bytes(s))) base64Encode = lambda s: lit.util.to_string(base64.b64encode(lit.util.to_bytes(s)))
escapedSubstitutions = base64Encode(pickle.dumps(config.substitutions)) escapedSubstitutions = base64Encode(pickle.dumps(config.substitutions))
config.substitutions.append(('%{substitutions}', escapedSubstitutions)) config.substitutions.append(('%{substitutions}', escapedSubstitutions))
# The tests in this directory need to run Python
import pipes, sys
config.substitutions.append(('%{python}', pipes.quote(sys.executable)))

libcxx/test/libcxx/transitive_includes.sanitize.py

  • This file was added.
PropertyOld ValueNew Value
File Modenull100755
#!/usr/bin/env python
#===----------------------------------------------------------------------===##
#
# 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
#
#===----------------------------------------------------------------------===##
# This script reads lines from standard input and looks for the names of public C++ headers.
# Specifically, it looks for lines of the form 'c++/v1/header' where 'header' is the name
# of a public C++ header, excluding C compatibility headers.
import os
import re
import sys
headers = []
for line in sys.stdin.readlines():
match = re.search('c\+\+/v[0-9]+/(.+)', line)
if not match:
continue
header = match.group(1)
if os.path.basename(header).endswith('.h'): # Skip C headers
continue
if os.path.basename(header).startswith('__'): # Skip internal headers
continue
headers.append(header)
print('\n'.join(sorted(set(headers))))

libcxx/test/libcxx/transitive_includes.sh.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// Test that we don't remove transitive includes of public C++ headers in the library accidentally.
// When we remove a transitive public include, clients tend to break because they don't always
// properly include what they use. Note that we don't check which system (C) headers are
// included transitively, because that is too unstable across platforms, and hence difficult
// to test for.
//
// This is not meant to block libc++ from removing unused transitive includes
// forever, however we do try to group removals for a couple of releases
MordanteUnsubmitted
Done
ReplyInline Actions

Would it be an idea to add a "schedule" here too? Basically to avoid people working on a cleanup patch and have it rejected just because it's not "the right time". For example only cleanup when the next version number is a multiple of 3. (3 just because 15 is a multiple of 3.)
(But maybe we should discuss the details on Discord.)

Mordante: Would it be an idea to add a "schedule" here too? Basically to avoid people working on a…
ldionneAuthorUnsubmitted
Done
ReplyInline Actions

When I first read this comment, I was thinking "this is a great idea". Then I gave it some more thought and I am not so sure. Indeed, I don't think we should be held to a specific (and arbitrary) schedule for breaking transitive header dependencies: instead we should do it in a reasoned fashion when it makes the most sense. For example, we are going to ship large parts of Ranges in LLVM 15, so making the transition to LLVM 15 as seamless as possible is desirable for users to get the benefits of Ranges ASAP. So much so that my plan was actually to go back and re-add some headers we've removed since branching LLVM 14 to avoid breaking folks in this release.

After all, I don't think we would reject any cleanup patch because it's "not the right time". We would simply add some transitive includes for backwards compatibility with a TODO above them, so the cost here is really small.

TLDR: Let's be very intentional about removing these transitive dependencies, and we can even give a heads up in advance for people to get prepared. The amount of breakage that this can cause (and the barrier it adds to adoption of a new libc++) is surprisingly high.

ldionne: When I first read this comment, I was thinking "this is a great idea". Then I gave it some more…
MordanteUnsubmitted
Done
ReplyInline Actions

I started a discussion on Discord.

Mordante: I started a discussion on Discord.
// to avoid breaking users at every release.
// This test doesn't support being run when some headers are not available, since we
// would need to add significant complexity to make that work.
// UNSUPPORTED: no-localization, no-threads, no-wide-characters, no-filesystem, libcpp-has-no-incomplete-format, libcpp-has-no-incomplete-ranges
// This test only supports being run with the latest Standard, otherwise we'd
// have to support various versions of the test.
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
// When built with modules, this test doesn't work because --trace-includes doesn't
// report the stack of includes correctly.
// UNSUPPORTED: modules-build
// This test uses --trace-includes, which is not supported by GCC.
// UNSUPPORTED: gcc
// This test doesn't work on AIX or Windows, but it should. Needs investigation.
// XFAIL: buildhost=aix6, buildhost=windows
// Prevent <ext/hash_map> from generating deprecated warnings for this test.
#if defined(__DEPRECATED)
# undef __DEPRECATED
#endif
/*
BEGIN-SCRIPT
import re
# To re-generate the list of expected headers, temporarily set this to True, re-generate
# the file and run this test.
regenerate_expected_results = False
# Used because the sequence of tokens RUN : can't appear anywhere or it'll confuse Lit.
RUN = "RUN"
if regenerate_expected_results:
print(f"// {RUN}: rm -rf %S/transitive_includes")
print(f"// {RUN}: mkdir %S/transitive_includes")
for i, header in enumerate(public_headers):
if header.endswith('.h'): # Skip C compatibility headers
continue
normalized_header = re.sub('/', '_', header)
trace_includes = "%{{cxx}} %s %{{flags}} %{{compile_flags}} --trace-includes -fsyntax-only -DTEST_{} 2>&1".format(i)
if regenerate_expected_results:
print(f"// {RUN}: {trace_includes} | %{{python}} %S/transitive_includes.sanitize.py > %S/transitive_includes/expected.{normalized_header}")
else:
print(f"// {RUN}: {trace_includes} | %{{python}} %S/transitive_includes.sanitize.py > %t.actual.{normalized_header}")
print(f"// {RUN}: diff %S/transitive_includes/expected.{normalized_header} %t.actual.{normalized_header}")
print("#if defined(TEST_{})".format(i))
print("#include <{}>".format(header))
print("#endif")
END-SCRIPT
*/
// DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW
// GENERATED-MARKER
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_0 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.algorithm
// RUN: diff %S/transitive_includes/expected.algorithm %t.actual.algorithm
#if defined(TEST_0)
#include <algorithm>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_1 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.any
// RUN: diff %S/transitive_includes/expected.any %t.actual.any
#if defined(TEST_1)
#include <any>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_2 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.array
// RUN: diff %S/transitive_includes/expected.array %t.actual.array
#if defined(TEST_2)
#include <array>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_3 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.atomic
// RUN: diff %S/transitive_includes/expected.atomic %t.actual.atomic
#if defined(TEST_3)
#include <atomic>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_4 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.barrier
// RUN: diff %S/transitive_includes/expected.barrier %t.actual.barrier
#if defined(TEST_4)
#include <barrier>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_5 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.bit
// RUN: diff %S/transitive_includes/expected.bit %t.actual.bit
#if defined(TEST_5)
#include <bit>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_6 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.bitset
// RUN: diff %S/transitive_includes/expected.bitset %t.actual.bitset
#if defined(TEST_6)
#include <bitset>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_7 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cassert
// RUN: diff %S/transitive_includes/expected.cassert %t.actual.cassert
#if defined(TEST_7)
#include <cassert>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_8 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ccomplex
// RUN: diff %S/transitive_includes/expected.ccomplex %t.actual.ccomplex
#if defined(TEST_8)
#include <ccomplex>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_9 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cctype
// RUN: diff %S/transitive_includes/expected.cctype %t.actual.cctype
#if defined(TEST_9)
#include <cctype>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_10 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cerrno
// RUN: diff %S/transitive_includes/expected.cerrno %t.actual.cerrno
#if defined(TEST_10)
#include <cerrno>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_11 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cfenv
// RUN: diff %S/transitive_includes/expected.cfenv %t.actual.cfenv
#if defined(TEST_11)
#include <cfenv>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_12 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cfloat
// RUN: diff %S/transitive_includes/expected.cfloat %t.actual.cfloat
#if defined(TEST_12)
#include <cfloat>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_13 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.charconv
// RUN: diff %S/transitive_includes/expected.charconv %t.actual.charconv
#if defined(TEST_13)
#include <charconv>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_14 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.chrono
// RUN: diff %S/transitive_includes/expected.chrono %t.actual.chrono
#if defined(TEST_14)
#include <chrono>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_15 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cinttypes
// RUN: diff %S/transitive_includes/expected.cinttypes %t.actual.cinttypes
#if defined(TEST_15)
#include <cinttypes>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_16 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ciso646
// RUN: diff %S/transitive_includes/expected.ciso646 %t.actual.ciso646
#if defined(TEST_16)
#include <ciso646>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_17 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.climits
// RUN: diff %S/transitive_includes/expected.climits %t.actual.climits
#if defined(TEST_17)
#include <climits>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_18 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.clocale
// RUN: diff %S/transitive_includes/expected.clocale %t.actual.clocale
#if defined(TEST_18)
#include <clocale>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_19 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cmath
// RUN: diff %S/transitive_includes/expected.cmath %t.actual.cmath
#if defined(TEST_19)
#include <cmath>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_20 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.codecvt
// RUN: diff %S/transitive_includes/expected.codecvt %t.actual.codecvt
#if defined(TEST_20)
#include <codecvt>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_21 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.compare
// RUN: diff %S/transitive_includes/expected.compare %t.actual.compare
#if defined(TEST_21)
#include <compare>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_22 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.complex
// RUN: diff %S/transitive_includes/expected.complex %t.actual.complex
#if defined(TEST_22)
#include <complex>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_24 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.concepts
// RUN: diff %S/transitive_includes/expected.concepts %t.actual.concepts
#if defined(TEST_24)
#include <concepts>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_25 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.condition_variable
// RUN: diff %S/transitive_includes/expected.condition_variable %t.actual.condition_variable
#if defined(TEST_25)
#include <condition_variable>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_26 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.coroutine
// RUN: diff %S/transitive_includes/expected.coroutine %t.actual.coroutine
#if defined(TEST_26)
#include <coroutine>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_27 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.csetjmp
// RUN: diff %S/transitive_includes/expected.csetjmp %t.actual.csetjmp
#if defined(TEST_27)
#include <csetjmp>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_28 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.csignal
// RUN: diff %S/transitive_includes/expected.csignal %t.actual.csignal
#if defined(TEST_28)
#include <csignal>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_29 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cstdarg
// RUN: diff %S/transitive_includes/expected.cstdarg %t.actual.cstdarg
#if defined(TEST_29)
#include <cstdarg>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_30 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cstdbool
// RUN: diff %S/transitive_includes/expected.cstdbool %t.actual.cstdbool
#if defined(TEST_30)
#include <cstdbool>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_31 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cstddef
// RUN: diff %S/transitive_includes/expected.cstddef %t.actual.cstddef
#if defined(TEST_31)
#include <cstddef>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_32 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cstdint
// RUN: diff %S/transitive_includes/expected.cstdint %t.actual.cstdint
#if defined(TEST_32)
#include <cstdint>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_33 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cstdio
// RUN: diff %S/transitive_includes/expected.cstdio %t.actual.cstdio
#if defined(TEST_33)
#include <cstdio>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_34 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cstdlib
// RUN: diff %S/transitive_includes/expected.cstdlib %t.actual.cstdlib
#if defined(TEST_34)
#include <cstdlib>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_35 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cstring
// RUN: diff %S/transitive_includes/expected.cstring %t.actual.cstring
#if defined(TEST_35)
#include <cstring>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_36 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ctgmath
// RUN: diff %S/transitive_includes/expected.ctgmath %t.actual.ctgmath
#if defined(TEST_36)
#include <ctgmath>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_37 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ctime
// RUN: diff %S/transitive_includes/expected.ctime %t.actual.ctime
#if defined(TEST_37)
#include <ctime>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_39 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cuchar
// RUN: diff %S/transitive_includes/expected.cuchar %t.actual.cuchar
#if defined(TEST_39)
#include <cuchar>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_40 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cwchar
// RUN: diff %S/transitive_includes/expected.cwchar %t.actual.cwchar
#if defined(TEST_40)
#include <cwchar>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_41 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.cwctype
// RUN: diff %S/transitive_includes/expected.cwctype %t.actual.cwctype
#if defined(TEST_41)
#include <cwctype>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_42 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.deque
// RUN: diff %S/transitive_includes/expected.deque %t.actual.deque
#if defined(TEST_42)
#include <deque>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_44 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.exception
// RUN: diff %S/transitive_includes/expected.exception %t.actual.exception
#if defined(TEST_44)
#include <exception>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_45 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.execution
// RUN: diff %S/transitive_includes/expected.execution %t.actual.execution
#if defined(TEST_45)
#include <execution>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_47 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.filesystem
// RUN: diff %S/transitive_includes/expected.filesystem %t.actual.filesystem
#if defined(TEST_47)
#include <filesystem>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_49 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.format
// RUN: diff %S/transitive_includes/expected.format %t.actual.format
#if defined(TEST_49)
#include <format>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_50 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.forward_list
// RUN: diff %S/transitive_includes/expected.forward_list %t.actual.forward_list
#if defined(TEST_50)
#include <forward_list>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_51 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.fstream
// RUN: diff %S/transitive_includes/expected.fstream %t.actual.fstream
#if defined(TEST_51)
#include <fstream>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_52 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.functional
// RUN: diff %S/transitive_includes/expected.functional %t.actual.functional
#if defined(TEST_52)
#include <functional>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_53 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.future
// RUN: diff %S/transitive_includes/expected.future %t.actual.future
#if defined(TEST_53)
#include <future>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_54 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.initializer_list
// RUN: diff %S/transitive_includes/expected.initializer_list %t.actual.initializer_list
#if defined(TEST_54)
#include <initializer_list>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_56 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.iomanip
// RUN: diff %S/transitive_includes/expected.iomanip %t.actual.iomanip
#if defined(TEST_56)
#include <iomanip>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_57 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ios
// RUN: diff %S/transitive_includes/expected.ios %t.actual.ios
#if defined(TEST_57)
#include <ios>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_58 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.iosfwd
// RUN: diff %S/transitive_includes/expected.iosfwd %t.actual.iosfwd
#if defined(TEST_58)
#include <iosfwd>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_59 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.iostream
// RUN: diff %S/transitive_includes/expected.iostream %t.actual.iostream
#if defined(TEST_59)
#include <iostream>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_60 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.istream
// RUN: diff %S/transitive_includes/expected.istream %t.actual.istream
#if defined(TEST_60)
#include <istream>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_61 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.iterator
// RUN: diff %S/transitive_includes/expected.iterator %t.actual.iterator
#if defined(TEST_61)
#include <iterator>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_62 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.latch
// RUN: diff %S/transitive_includes/expected.latch %t.actual.latch
#if defined(TEST_62)
#include <latch>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_63 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.limits
// RUN: diff %S/transitive_includes/expected.limits %t.actual.limits
#if defined(TEST_63)
#include <limits>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_65 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.list
// RUN: diff %S/transitive_includes/expected.list %t.actual.list
#if defined(TEST_65)
#include <list>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_66 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.locale
// RUN: diff %S/transitive_includes/expected.locale %t.actual.locale
#if defined(TEST_66)
#include <locale>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_68 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.map
// RUN: diff %S/transitive_includes/expected.map %t.actual.map
#if defined(TEST_68)
#include <map>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_70 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.memory
// RUN: diff %S/transitive_includes/expected.memory %t.actual.memory
#if defined(TEST_70)
#include <memory>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_71 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.mutex
// RUN: diff %S/transitive_includes/expected.mutex %t.actual.mutex
#if defined(TEST_71)
#include <mutex>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_72 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.new
// RUN: diff %S/transitive_includes/expected.new %t.actual.new
#if defined(TEST_72)
#include <new>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_73 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.numbers
// RUN: diff %S/transitive_includes/expected.numbers %t.actual.numbers
#if defined(TEST_73)
#include <numbers>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_74 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.numeric
// RUN: diff %S/transitive_includes/expected.numeric %t.actual.numeric
#if defined(TEST_74)
#include <numeric>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_75 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.optional
// RUN: diff %S/transitive_includes/expected.optional %t.actual.optional
#if defined(TEST_75)
#include <optional>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_76 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ostream
// RUN: diff %S/transitive_includes/expected.ostream %t.actual.ostream
#if defined(TEST_76)
#include <ostream>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_77 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.queue
// RUN: diff %S/transitive_includes/expected.queue %t.actual.queue
#if defined(TEST_77)
#include <queue>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_78 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.random
// RUN: diff %S/transitive_includes/expected.random %t.actual.random
#if defined(TEST_78)
#include <random>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_79 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ranges
// RUN: diff %S/transitive_includes/expected.ranges %t.actual.ranges
#if defined(TEST_79)
#include <ranges>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_80 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ratio
// RUN: diff %S/transitive_includes/expected.ratio %t.actual.ratio
#if defined(TEST_80)
#include <ratio>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_81 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.regex
// RUN: diff %S/transitive_includes/expected.regex %t.actual.regex
#if defined(TEST_81)
#include <regex>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_82 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.scoped_allocator
// RUN: diff %S/transitive_includes/expected.scoped_allocator %t.actual.scoped_allocator
#if defined(TEST_82)
#include <scoped_allocator>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_83 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.semaphore
// RUN: diff %S/transitive_includes/expected.semaphore %t.actual.semaphore
#if defined(TEST_83)
#include <semaphore>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_84 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.set
// RUN: diff %S/transitive_includes/expected.set %t.actual.set
#if defined(TEST_84)
#include <set>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_86 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.shared_mutex
// RUN: diff %S/transitive_includes/expected.shared_mutex %t.actual.shared_mutex
#if defined(TEST_86)
#include <shared_mutex>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_87 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.span
// RUN: diff %S/transitive_includes/expected.span %t.actual.span
#if defined(TEST_87)
#include <span>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_88 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.sstream
// RUN: diff %S/transitive_includes/expected.sstream %t.actual.sstream
#if defined(TEST_88)
#include <sstream>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_89 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.stack
// RUN: diff %S/transitive_includes/expected.stack %t.actual.stack
#if defined(TEST_89)
#include <stack>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_93 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.stdexcept
// RUN: diff %S/transitive_includes/expected.stdexcept %t.actual.stdexcept
#if defined(TEST_93)
#include <stdexcept>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_97 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.streambuf
// RUN: diff %S/transitive_includes/expected.streambuf %t.actual.streambuf
#if defined(TEST_97)
#include <streambuf>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_98 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.string
// RUN: diff %S/transitive_includes/expected.string %t.actual.string
#if defined(TEST_98)
#include <string>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_100 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.string_view
// RUN: diff %S/transitive_includes/expected.string_view %t.actual.string_view
#if defined(TEST_100)
#include <string_view>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_101 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.strstream
// RUN: diff %S/transitive_includes/expected.strstream %t.actual.strstream
#if defined(TEST_101)
#include <strstream>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_102 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.system_error
// RUN: diff %S/transitive_includes/expected.system_error %t.actual.system_error
#if defined(TEST_102)
#include <system_error>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_104 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.thread
// RUN: diff %S/transitive_includes/expected.thread %t.actual.thread
#if defined(TEST_104)
#include <thread>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_105 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.tuple
// RUN: diff %S/transitive_includes/expected.tuple %t.actual.tuple
#if defined(TEST_105)
#include <tuple>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_106 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.type_traits
// RUN: diff %S/transitive_includes/expected.type_traits %t.actual.type_traits
#if defined(TEST_106)
#include <type_traits>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_107 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.typeindex
// RUN: diff %S/transitive_includes/expected.typeindex %t.actual.typeindex
#if defined(TEST_107)
#include <typeindex>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_108 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.typeinfo
// RUN: diff %S/transitive_includes/expected.typeinfo %t.actual.typeinfo
#if defined(TEST_108)
#include <typeinfo>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_110 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.unordered_map
// RUN: diff %S/transitive_includes/expected.unordered_map %t.actual.unordered_map
#if defined(TEST_110)
#include <unordered_map>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_111 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.unordered_set
// RUN: diff %S/transitive_includes/expected.unordered_set %t.actual.unordered_set
#if defined(TEST_111)
#include <unordered_set>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_112 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.utility
// RUN: diff %S/transitive_includes/expected.utility %t.actual.utility
#if defined(TEST_112)
#include <utility>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_113 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.valarray
// RUN: diff %S/transitive_includes/expected.valarray %t.actual.valarray
#if defined(TEST_113)
#include <valarray>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_114 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.variant
// RUN: diff %S/transitive_includes/expected.variant %t.actual.variant
#if defined(TEST_114)
#include <variant>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_115 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.vector
// RUN: diff %S/transitive_includes/expected.vector %t.actual.vector
#if defined(TEST_115)
#include <vector>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_116 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.version
// RUN: diff %S/transitive_includes/expected.version %t.actual.version
#if defined(TEST_116)
#include <version>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_119 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_algorithm
// RUN: diff %S/transitive_includes/expected.experimental_algorithm %t.actual.experimental_algorithm
#if defined(TEST_119)
#include <experimental/algorithm>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_120 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_coroutine
// RUN: diff %S/transitive_includes/expected.experimental_coroutine %t.actual.experimental_coroutine
#if defined(TEST_120)
#include <experimental/coroutine>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_121 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_deque
// RUN: diff %S/transitive_includes/expected.experimental_deque %t.actual.experimental_deque
#if defined(TEST_121)
#include <experimental/deque>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_122 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_forward_list
// RUN: diff %S/transitive_includes/expected.experimental_forward_list %t.actual.experimental_forward_list
#if defined(TEST_122)
#include <experimental/forward_list>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_123 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_functional
// RUN: diff %S/transitive_includes/expected.experimental_functional %t.actual.experimental_functional
#if defined(TEST_123)
#include <experimental/functional>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_124 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_iterator
// RUN: diff %S/transitive_includes/expected.experimental_iterator %t.actual.experimental_iterator
#if defined(TEST_124)
#include <experimental/iterator>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_125 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_list
// RUN: diff %S/transitive_includes/expected.experimental_list %t.actual.experimental_list
#if defined(TEST_125)
#include <experimental/list>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_126 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_map
// RUN: diff %S/transitive_includes/expected.experimental_map %t.actual.experimental_map
#if defined(TEST_126)
#include <experimental/map>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_127 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_memory_resource
// RUN: diff %S/transitive_includes/expected.experimental_memory_resource %t.actual.experimental_memory_resource
#if defined(TEST_127)
#include <experimental/memory_resource>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_128 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_propagate_const
// RUN: diff %S/transitive_includes/expected.experimental_propagate_const %t.actual.experimental_propagate_const
#if defined(TEST_128)
#include <experimental/propagate_const>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_129 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_regex
// RUN: diff %S/transitive_includes/expected.experimental_regex %t.actual.experimental_regex
#if defined(TEST_129)
#include <experimental/regex>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_130 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_set
// RUN: diff %S/transitive_includes/expected.experimental_set %t.actual.experimental_set
#if defined(TEST_130)
#include <experimental/set>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_131 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_simd
// RUN: diff %S/transitive_includes/expected.experimental_simd %t.actual.experimental_simd
#if defined(TEST_131)
#include <experimental/simd>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_132 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_string
// RUN: diff %S/transitive_includes/expected.experimental_string %t.actual.experimental_string
#if defined(TEST_132)
#include <experimental/string>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_133 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_type_traits
// RUN: diff %S/transitive_includes/expected.experimental_type_traits %t.actual.experimental_type_traits
#if defined(TEST_133)
#include <experimental/type_traits>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_134 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_unordered_map
// RUN: diff %S/transitive_includes/expected.experimental_unordered_map %t.actual.experimental_unordered_map
#if defined(TEST_134)
#include <experimental/unordered_map>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_135 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_unordered_set
// RUN: diff %S/transitive_includes/expected.experimental_unordered_set %t.actual.experimental_unordered_set
#if defined(TEST_135)
#include <experimental/unordered_set>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_136 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_utility
// RUN: diff %S/transitive_includes/expected.experimental_utility %t.actual.experimental_utility
#if defined(TEST_136)
#include <experimental/utility>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_137 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.experimental_vector
// RUN: diff %S/transitive_includes/expected.experimental_vector %t.actual.experimental_vector
#if defined(TEST_137)
#include <experimental/vector>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_138 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ext_hash_map
// RUN: diff %S/transitive_includes/expected.ext_hash_map %t.actual.ext_hash_map
#if defined(TEST_138)
#include <ext/hash_map>
#endif
// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fsyntax-only -DTEST_139 2>&1 | %{python} %S/transitive_includes.sanitize.py > %t.actual.ext_hash_set
// RUN: diff %S/transitive_includes/expected.ext_hash_set %t.actual.ext_hash_set
#if defined(TEST_139)
#include <ext/hash_set>
#endif
// GENERATED-MARKER

libcxx/test/libcxx/transitive_includes/expected.algorithm

  • This file was added.
algorithm
atomic
MordanteUnsubmitted
Done
ReplyInline Actions

Should the path include c++/v1? If we want that we probably need to make the test unsupported for the unstable ABI too.

Mordante: Should the path include `c++/v1`? If we want that we probably need to make the test unsupported…
bit
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.any

  • This file was added.
any
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.array

  • This file was added.
array
cmath
compare
concepts
cstddef
cstdint
cstdlib
exception
initializer_list
iosfwd
limits
stdexcept
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.atomic

  • This file was added.
atomic
climits
cstddef
cstdint
cstring
ctime
iosfwd
limits
ratio
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.barrier

  • This file was added.
atomic
barrier
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.bit

  • This file was added.
bit
cstddef
cstdint
cstdlib
limits
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.bitset

  • This file was added.
atomic
bitset
cctype
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
string
string_view
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.cassert

  • This file was added.
cassert

libcxx/test/libcxx/transitive_includes/expected.ccomplex

  • This file was added.
atomic
bitset
ccomplex
cctype
cerrno
climits
cmath
compare
complex
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
sstream
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.cctype

  • This file was added.
cctype

libcxx/test/libcxx/transitive_includes/expected.cerrno

  • This file was added.
cerrno

libcxx/test/libcxx/transitive_includes/expected.cfenv

  • This file was added.
cfenv

libcxx/test/libcxx/transitive_includes/expected.cfloat

  • This file was added.
cfloat

libcxx/test/libcxx/transitive_includes/expected.charconv

  • This file was added.
cerrno
charconv
cmath
concepts
cstddef
cstdint
cstdlib
cstring
limits
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.chrono

  • This file was added.
chrono
climits
cmath
compare
cstddef
cstdint
ctime
limits
ratio
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.cinttypes

  • This file was added.
cinttypes
cstdint

libcxx/test/libcxx/transitive_includes/expected.ciso646

  • This file was added.
ciso646

libcxx/test/libcxx/transitive_includes/expected.climits

  • This file was added.
climits

libcxx/test/libcxx/transitive_includes/expected.clocale

  • This file was added.
clocale

libcxx/test/libcxx/transitive_includes/expected.cmath

  • This file was added.
cmath
cstddef
cstdint
limits
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.codecvt

  • This file was added.
atomic
cctype
cerrno
climits
cmath
codecvt
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
mutex
new
ratio
stdexcept
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.compare

  • This file was added.
cmath
compare
cstddef
cstdint
limits
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.complex

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
complex
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
sstream
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.concepts

  • This file was added.
concepts
cstddef
cstdint
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.condition_variable

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
condition_variable
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.coroutine

  • This file was added.
cmath
compare
coroutine
cstddef
cstdint
cstring
limits
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.csetjmp

  • This file was added.
csetjmp

libcxx/test/libcxx/transitive_includes/expected.csignal

  • This file was added.
csignal

libcxx/test/libcxx/transitive_includes/expected.cstdarg

  • This file was added.
cstdarg

libcxx/test/libcxx/transitive_includes/expected.cstdbool

  • This file was added.
cstdbool

libcxx/test/libcxx/transitive_includes/expected.cstddef

  • This file was added.
cstddef
version

libcxx/test/libcxx/transitive_includes/expected.cstdint

  • This file was added.
cstdint

libcxx/test/libcxx/transitive_includes/expected.cstdio

  • This file was added.
cstdio

libcxx/test/libcxx/transitive_includes/expected.cstdlib

  • This file was added.
cstdlib

libcxx/test/libcxx/transitive_includes/expected.cstring

  • This file was added.
cstring

libcxx/test/libcxx/transitive_includes/expected.ctgmath

  • This file was added.
atomic
bitset
ccomplex
cctype
cerrno
climits
cmath
compare
complex
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctgmath
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
sstream
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.ctime

  • This file was added.
ctime

libcxx/test/libcxx/transitive_includes/expected.cuchar

  • This file was added.
cuchar

libcxx/test/libcxx/transitive_includes/expected.cwchar

  • This file was added.
cctype
cwchar
cwctype

libcxx/test/libcxx/transitive_includes/expected.cwctype

  • This file was added.
cctype
cwctype

libcxx/test/libcxx/transitive_includes/expected.deque

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
deque
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.exception

  • This file was added.
cstddef
cstdint
cstdlib
exception
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.execution

  • This file was added.
execution
version

libcxx/test/libcxx/transitive_includes/expected.experimental_algorithm

  • This file was added.
algorithm
atomic
bit
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/algorithm
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.experimental_coroutine

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/coroutine
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.experimental_deque

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
deque
exception
experimental/deque
experimental/memory_resource
experimental/utility
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_forward_list

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/forward_list
experimental/memory_resource
experimental/utility
forward_list
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_functional

  • This file was added.
array
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/functional
functional
initializer_list
iosfwd
limits
memory
new
optional
ratio
stdexcept
tuple
type_traits
typeinfo
unordered_map
vector
version

libcxx/test/libcxx/transitive_includes/expected.experimental_iterator

  • This file was added.
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
exception
experimental/iterator
initializer_list
iosfwd
iterator
limits
new
tuple
type_traits
variant
version

libcxx/test/libcxx/transitive_includes/expected.experimental_list

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/list
experimental/memory_resource
experimental/utility
initializer_list
iosfwd
limits
list
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_map

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/map
experimental/memory_resource
experimental/utility
initializer_list
iosfwd
limits
map
memory
new
optional
ratio
stdexcept
tuple
type_traits
typeinfo
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_memory_resource

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/memory_resource
experimental/utility
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_propagate_const

  • This file was added.
cstddef
cstdint
experimental/propagate_const
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.experimental_regex

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
deque
exception
experimental/memory_resource
experimental/regex
experimental/string
experimental/utility
initializer_list
iosfwd
limits
memory
mutex
new
ratio
regex
stdexcept
string
string_view
system_error
tuple
type_traits
typeinfo
utility
vector
version

libcxx/test/libcxx/transitive_includes/expected.experimental_set

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/memory_resource
experimental/set
experimental/utility
initializer_list
iosfwd
limits
memory
new
optional
ratio
set
stdexcept
tuple
type_traits
typeinfo
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_simd

  • This file was added.
array
cmath
compare
concepts
cstddef
cstdint
cstdlib
exception
experimental/simd
initializer_list
iosfwd
limits
stdexcept
tuple
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.experimental_string

  • This file was added.
atomic
cctype
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
experimental/memory_resource
experimental/string
experimental/utility
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
string
string_view
tuple
type_traits
typeinfo
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_type_traits

  • This file was added.
cstddef
cstdint
experimental/type_traits
initializer_list
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.experimental_unordered_map

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/memory_resource
experimental/unordered_map
experimental/utility
initializer_list
iosfwd
limits
memory
new
optional
ratio
stdexcept
tuple
type_traits
typeinfo
unordered_map
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_unordered_set

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/memory_resource
experimental/unordered_set
experimental/utility
initializer_list
iosfwd
limits
memory
new
optional
ratio
stdexcept
tuple
type_traits
typeinfo
unordered_set
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_utility

  • This file was added.
cmath
compare
cstddef
cstdint
cstdlib
experimental/utility
initializer_list
limits
type_traits
utility
version

libcxx/test/libcxx/transitive_includes/expected.experimental_vector

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
experimental/memory_resource
experimental/utility
experimental/vector
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
utility
vector
version

libcxx/test/libcxx/transitive_includes/expected.ext_hash_map

  • This file was added.
algorithm
array
atomic
bit
cctype
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
ext/hash_map
functional
initializer_list
iosfwd
limits
memory
new
optional
ratio
stdexcept
string
string_view
tuple
type_traits
typeinfo
unordered_map
vector
version

libcxx/test/libcxx/transitive_includes/expected.ext_hash_set

  • This file was added.
algorithm
array
atomic
bit
cctype
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
ext/hash_set
functional
initializer_list
iosfwd
limits
memory
new
optional
ratio
stdexcept
string
string_view
tuple
type_traits
typeinfo
unordered_map
vector
version

libcxx/test/libcxx/transitive_includes/expected.filesystem

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
filesystem
initializer_list
iomanip
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.format

  • This file was added.
array
atomic
bit
cctype
cerrno
charconv
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
format
initializer_list
ios
iosfwd
limits
locale
memory
mutex
new
optional
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.forward_list

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
forward_list
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.fstream

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
filesystem
fstream
initializer_list
iomanip
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.functional

  • This file was added.
array
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
functional
initializer_list
iosfwd
limits
memory
new
optional
ratio
stdexcept
tuple
type_traits
typeinfo
unordered_map
vector
version

libcxx/test/libcxx/transitive_includes/expected.future

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
future
initializer_list
iosfwd
limits
memory
mutex
new
ratio
stdexcept
string
string_view
system_error
thread
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.initializer_list

  • This file was added.
cstddef
initializer_list
version

libcxx/test/libcxx/transitive_includes/expected.iomanip

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iomanip
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.ios

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
limits
memory
mutex
new
ratio
stdexcept
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.iosfwd

  • This file was added.
iosfwd
version

libcxx/test/libcxx/transitive_includes/expected.iostream

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
iostream
istream
limits
locale
memory
mutex
new
ostream
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.istream

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.iterator

  • This file was added.
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
exception
initializer_list
iosfwd
iterator
limits
new
tuple
type_traits
variant
version

libcxx/test/libcxx/transitive_includes/expected.latch

  • This file was added.
atomic
climits
cstddef
cstdint
cstring
ctime
iosfwd
latch
limits
ratio
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.limits

  • This file was added.
cstddef
cstdint
limits
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.list

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
list
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.locale

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
limits
locale
memory
mutex
new
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.map

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
map
memory
new
optional
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.memory

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.mutex

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
mutex
new
ratio
stdexcept
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.new

  • This file was added.
cstddef
cstdint
cstdlib
exception
new
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.numbers

  • This file was added.
concepts
cstddef
cstdint
numbers
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.numeric

  • This file was added.
cmath
concepts
cstddef
cstdint
limits
numeric
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.optional

  • This file was added.
cmath
compare
cstddef
cstdint
cstdlib
cstring
exception
initializer_list
iosfwd
limits
new
optional
stdexcept
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.ostream

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
limits
locale
memory
mutex
new
ostream
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.queue

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
deque
exception
initializer_list
iosfwd
limits
memory
new
queue
ratio
stdexcept
tuple
type_traits
typeinfo
vector
version

libcxx/test/libcxx/transitive_includes/expected.random

  • This file was added.
atomic
bit
cctype
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
new
numeric
random
ratio
stdexcept
string
string_view
tuple
type_traits
typeinfo
vector
version

libcxx/test/libcxx/transitive_includes/expected.ranges

  • This file was added.
array
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
exception
initializer_list
iosfwd
iterator
limits
new
optional
ranges
span
stdexcept
tuple
type_traits
variant
version

libcxx/test/libcxx/transitive_includes/expected.ratio

  • This file was added.
climits
cstddef
cstdint
ratio
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.regex

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
deque
exception
initializer_list
iosfwd
limits
memory
mutex
new
ratio
regex
stdexcept
string
string_view
system_error
tuple
type_traits
typeinfo
vector
version

libcxx/test/libcxx/transitive_includes/expected.scoped_allocator

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
ratio
scoped_allocator
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.semaphore

  • This file was added.
atomic
climits
cstddef
cstdint
cstring
ctime
iosfwd
limits
ratio
semaphore
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.set

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
optional
ratio
set
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.shared_mutex

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
new
ratio
shared_mutex
stdexcept
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.span

  • This file was added.
array
cmath
compare
concepts
cstddef
cstdint
cstdlib
exception
initializer_list
iosfwd
limits
span
stdexcept
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.sstream

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
sstream
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.stack

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
deque
exception
initializer_list
iosfwd
limits
memory
new
ratio
stack
stdexcept
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.stdexcept

  • This file was added.
cstddef
cstdint
cstdlib
exception
iosfwd
stdexcept
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.streambuf

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
limits
memory
mutex
new
ratio
stdexcept
streambuf
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.string

  • This file was added.
atomic
cctype
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
string
string_view
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.string_view

  • This file was added.
cctype
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
cwchar
cwctype
exception
initializer_list
iosfwd
limits
stdexcept
string_view
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.strstream

  • This file was added.
atomic
bitset
cctype
cerrno
climits
cmath
compare
concepts
cstdarg
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
ios
iosfwd
istream
limits
locale
memory
mutex
new
ostream
ratio
stdexcept
streambuf
string
string_view
strstream
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.system_error

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
string
string_view
system_error
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.thread

  • This file was added.
atomic
cctype
cerrno
climits
cmath
compare
concepts
cstddef
cstdint
cstdio
cstdlib
cstring
ctime
cwchar
cwctype
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
string
string_view
system_error
thread
tuple
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.tuple

  • This file was added.
cmath
compare
cstddef
cstdint
limits
tuple
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.type_traits

  • This file was added.
cstddef
cstdint
type_traits
version

libcxx/test/libcxx/transitive_includes/expected.typeindex

  • This file was added.
cmath
compare
cstddef
cstdint
cstdlib
exception
limits
type_traits
typeindex
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.typeinfo

  • This file was added.
cstddef
cstdint
cstdlib
exception
type_traits
typeinfo
version

libcxx/test/libcxx/transitive_includes/expected.unordered_map

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
optional
ratio
stdexcept
tuple
type_traits
typeinfo
unordered_map
version

libcxx/test/libcxx/transitive_includes/expected.unordered_set

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
optional
ratio
stdexcept
tuple
type_traits
typeinfo
unordered_set
version

libcxx/test/libcxx/transitive_includes/expected.utility

  • This file was added.
cmath
compare
cstddef
cstdint
cstdlib
initializer_list
limits
type_traits
utility
version

libcxx/test/libcxx/transitive_includes/expected.valarray

  • This file was added.
cmath
concepts
cstddef
cstdint
cstdlib
cstring
exception
initializer_list
iosfwd
limits
new
stdexcept
type_traits
valarray
version

libcxx/test/libcxx/transitive_includes/expected.variant

  • This file was added.
cmath
compare
cstddef
cstdint
cstdlib
cstring
exception
initializer_list
limits
new
tuple
type_traits
variant
version

libcxx/test/libcxx/transitive_includes/expected.vector

  • This file was added.
atomic
climits
cmath
compare
concepts
cstddef
cstdint
cstdlib
cstring
ctime
exception
initializer_list
iosfwd
limits
memory
new
ratio
stdexcept
tuple
type_traits
typeinfo
vector
version

libcxx/test/libcxx/transitive_includes/expected.version

  • This file was added.
version

libcxx/utils/generate_header_tests.py

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Linesdef main():
produce(test.joinpath('libcxx/assertions/headers_declare_assertion_handler.sh.cpp'), variables) produce(test.joinpath('libcxx/assertions/headers_declare_assertion_handler.sh.cpp'), variables)
produce(test.joinpath('libcxx/clang_tidy.sh.cpp'), variables) produce(test.joinpath('libcxx/clang_tidy.sh.cpp'), variables)
produce(test.joinpath('libcxx/double_include.sh.cpp'), variables) produce(test.joinpath('libcxx/double_include.sh.cpp'), variables)
produce(test.joinpath('libcxx/min_max_macros.compile.pass.cpp'), variables) produce(test.joinpath('libcxx/min_max_macros.compile.pass.cpp'), variables)
produce(test.joinpath('libcxx/modules_include.sh.cpp'), variables) produce(test.joinpath('libcxx/modules_include.sh.cpp'), variables)
produce(test.joinpath('libcxx/nasty_macros.compile.pass.cpp'), variables) produce(test.joinpath('libcxx/nasty_macros.compile.pass.cpp'), variables)
produce(test.joinpath('libcxx/no_assert_include.compile.pass.cpp'), variables) produce(test.joinpath('libcxx/no_assert_include.compile.pass.cpp'), variables)
produce(test.joinpath('libcxx/private_headers.verify.cpp'), variables) produce(test.joinpath('libcxx/private_headers.verify.cpp'), variables)
produce(test.joinpath('libcxx/transitive_includes.sh.cpp'), variables)
if __name__ == '__main__': if __name__ == '__main__':
main() main()