This is an archive of the discontinued LLVM Phabricator instance.

Differential D119460

[libc++][nfc] Add TEST_HAS_NO_CHAR8_T.
ClosedPublic

Authored by Mordante on Feb 10 2022, 10:44 AM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rG9027887e230d: [libc++][nfc] Add TEST_HAS_NO_CHAR8_T.
Summary

This avoids using an libc++ internal macro in our tests. This version
doesn't depend on the internal macro but redefines it.

Diff Detail

Event Timeline

Mordante requested review of this revision.Feb 10 2022, 10:44 AM
Mordante created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptFeb 10 2022, 10:44 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
ldionne accepted this revision.Feb 10 2022, 2:06 PM
This revision is now accepted and ready to land.Feb 10 2022, 2:06 PM
Harbormaster completed remote builds in B148792: Diff 407604.Feb 10 2022, 3:58 PM
This revision was landed with ongoing or failed builds.Feb 11 2022, 8:37 AM
Closed by commit rG9027887e230d: [libc++][nfc] Add TEST_HAS_NO_CHAR8_T. (authored by Mordante). · Explain Why
This revision was automatically updated to reflect the committed changes.
Mordante added a commit: rG9027887e230d: [libc++][nfc] Add TEST_HAS_NO_CHAR8_T..

Revision Contents

PathSize
libcxx/
test/
std/
language.support/
cmp/
cmp.concept/
2 lines
numerics/
bit/
bit.pow.two/
2 lines
2 lines
2 lines
2 lines
bitops.count/
2 lines
2 lines
2 lines
2 lines
2 lines
bitops.rot/
2 lines
2 lines
strings/
string.view/
2 lines
utilities/
format/
format.arguments/
format.arg/
2 lines
format.formatter/
format.context/
format.context/
2 lines
2 lines
2 lines
2 lines
2 lines
format.parse.ctx/
2 lines
2 lines
2 lines
2 lines
2 lines
utility/
utility.intcmp/
8 lines
support/
4 lines

Diff 407892

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

Show All 21 Lines
static_assert(std::three_way_comparable<int>); static_assert(std::three_way_comparable<int>);
static_assert(std::three_way_comparable<double>); static_assert(std::three_way_comparable<double>);
static_assert(std::three_way_comparable<void*>); static_assert(std::three_way_comparable<void*>);
static_assert(std::three_way_comparable<char*>); static_assert(std::three_way_comparable<char*>);
static_assert(std::three_way_comparable<char const*>); static_assert(std::three_way_comparable<char const*>);
static_assert(std::three_way_comparable<char volatile*>); static_assert(std::three_way_comparable<char volatile*>);
static_assert(std::three_way_comparable<char const volatile*>); static_assert(std::three_way_comparable<char const volatile*>);
static_assert(std::three_way_comparable<wchar_t&>); static_assert(std::three_way_comparable<wchar_t&>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(std::three_way_comparable<char8_t const&>); static_assert(std::three_way_comparable<char8_t const&>);
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
static_assert(std::three_way_comparable<char16_t volatile&>); static_assert(std::three_way_comparable<char16_t volatile&>);
static_assert(std::three_way_comparable<char32_t const volatile&>); static_assert(std::three_way_comparable<char32_t const volatile&>);
#endif #endif
#ifndef TEST_HAS_NO_INT128 #ifndef TEST_HAS_NO_INT128
static_assert(std::three_way_comparable<__int128_t const&>); static_assert(std::three_way_comparable<__int128_t const&>);
▲ Show 20 Lines • Show All 189 Lines • Show Last 20 Lines

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 37 Lines

libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 39 Lines

libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 37 Lines

libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 37 Lines

libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 38 Lines

libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 37 Lines

libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 37 Lines

libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 37 Lines

libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 37 Lines

libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 39 Lines

libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines#endif
static_assert(!std::is_invocable_v<L, int64_t>); static_assert(!std::is_invocable_v<L, int64_t>);
static_assert(!std::is_invocable_v<L, intmax_t>); static_assert(!std::is_invocable_v<L, intmax_t>);
static_assert(!std::is_invocable_v<L, intptr_t>); static_assert(!std::is_invocable_v<L, intptr_t>);
static_assert(!std::is_invocable_v<L, ptrdiff_t>); static_assert(!std::is_invocable_v<L, ptrdiff_t>);
static_assert(!std::is_invocable_v<L, bool>); static_assert(!std::is_invocable_v<L, bool>);
static_assert(!std::is_invocable_v<L, char>); static_assert(!std::is_invocable_v<L, char>);
static_assert(!std::is_invocable_v<L, wchar_t>); static_assert(!std::is_invocable_v<L, wchar_t>);
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(!std::is_invocable_v<L, char8_t>); static_assert(!std::is_invocable_v<L, char8_t>);
#endif #endif
static_assert(!std::is_invocable_v<L, char16_t>); static_assert(!std::is_invocable_v<L, char16_t>);
static_assert(!std::is_invocable_v<L, char32_t>); static_assert(!std::is_invocable_v<L, char32_t>);
static_assert(!std::is_invocable_v<L, A>); static_assert(!std::is_invocable_v<L, A>);
static_assert(!std::is_invocable_v<L, A*>); static_assert(!std::is_invocable_v<L, A*>);
static_assert(!std::is_invocable_v<L, E1>); static_assert(!std::is_invocable_v<L, E1>);
Show All 39 Lines

libcxx/test/std/strings/string.view/trivially_copyable.compile.pass.cpp

Show All 13 Lines
#include <type_traits> #include <type_traits>
#include "test_macros.h" #include "test_macros.h"
static_assert(std::is_trivially_copyable<std::basic_string_view<char> >::value, ""); static_assert(std::is_trivially_copyable<std::basic_string_view<char> >::value, "");
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
static_assert(std::is_trivially_copyable<std::basic_string_view<wchar_t> >::value, ""); static_assert(std::is_trivially_copyable<std::basic_string_view<wchar_t> >::value, "");
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
static_assert(std::is_trivially_copyable<std::basic_string_view<char8_t> >::value, ""); static_assert(std::is_trivially_copyable<std::basic_string_view<char8_t> >::value, "");
#endif #endif
static_assert(std::is_trivially_copyable<std::basic_string_view<char16_t> >::value, ""); static_assert(std::is_trivially_copyable<std::basic_string_view<char16_t> >::value, "");
static_assert(std::is_trivially_copyable<std::basic_string_view<char32_t> >::value, ""); static_assert(std::is_trivially_copyable<std::basic_string_view<char32_t> >::value, "");

libcxx/test/std/utilities/format/format.arguments/format.arg/ctor.pass.cpp

Show All 28 Linesvoid test() {
std::basic_format_arg<Context> format_arg{}; std::basic_format_arg<Context> format_arg{};
assert(!format_arg); assert(!format_arg);
} }
void test() { void test() {
test<char>(); test<char>();
test<wchar_t>(); test<wchar_t>();
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test<char8_t>(); test<char8_t>();
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test<char16_t>(); test<char16_t>();
test<char32_t>(); test<char32_t>();
#endif #endif
} }
int main(int, char**) { int main(int, char**) {
test(); test();
return 0; return 0;
} }

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/advance_to.pass.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines test(std::basic_format_args(
std::make_format_args<std::basic_format_context< std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<char>>, char>>())); std::back_insert_iterator<std::basic_string<char>>, char>>()));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test(std::basic_format_args( test(std::basic_format_args(
std::make_format_args<std::basic_format_context< std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>())); std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>()));
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test(std::basic_format_args( test(std::basic_format_args(
std::make_format_args<std::basic_format_context< std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>>())); std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>>()));
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test(std::basic_format_args( test(std::basic_format_args(
std::make_format_args<std::basic_format_context< std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<char16_t>>, std::back_insert_iterator<std::basic_string<char16_t>>,
Show All 13 Lines

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/arg.pass.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines assert(test_basic_format_arg(context.arg(3),
std::basic_string_view<CharT>(string))); std::basic_string_view<CharT>(string)));
} }
int main(int, char**) { int main(int, char**) {
test<std::back_insert_iterator<std::basic_string<char>>, char>(); test<std::back_insert_iterator<std::basic_string<char>>, char>();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>(); test<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>();
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test<std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>(); test<std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>();
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test<std::back_insert_iterator<std::basic_string<char16_t>>, char16_t>(); test<std::back_insert_iterator<std::basic_string<char16_t>>, char16_t>();
test<std::back_insert_iterator<std::basic_string<char32_t>>, char32_t>(); test<std::back_insert_iterator<std::basic_string<char32_t>>, char32_t>();
#endif #endif
return 0; return 0;
} }

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/ctor.pass.cpp

Show First 20 Lines • Show All 123 Lines • ▼ Show 20 Lines
#endif #endif
} }
void test() { void test() {
test<std::back_insert_iterator<std::basic_string<char>>, char>(); test<std::back_insert_iterator<std::basic_string<char>>, char>();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>(); test<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>();
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test<std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>(); test<std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>();
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test<std::back_insert_iterator<std::basic_string<char16_t>>, char16_t>(); test<std::back_insert_iterator<std::basic_string<char16_t>>, char16_t>();
test<std::back_insert_iterator<std::basic_string<char32_t>>, char32_t>(); test<std::back_insert_iterator<std::basic_string<char32_t>>, char32_t>();
#endif #endif
} }
int main(int, char**) { int main(int, char**) {
test(); test();
return 0; return 0;
} }

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/locale.pass.cpp

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Linesvoid test() {
} }
} }
void test() { void test() {
test<std::back_insert_iterator<std::basic_string<char>>, char>(); test<std::back_insert_iterator<std::basic_string<char>>, char>();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>(); test<std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>();
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test<std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>(); test<std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>();
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test<std::back_insert_iterator<std::basic_string<char16_t>>, char16_t>(); test<std::back_insert_iterator<std::basic_string<char16_t>>, char16_t>();
test<std::back_insert_iterator<std::basic_string<char32_t>>, char32_t>(); test<std::back_insert_iterator<std::basic_string<char32_t>>, char32_t>();
#endif #endif
} }
int main(int, char**) { int main(int, char**) {
test(); test();
return 0; return 0;
} }

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/out.pass.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesvoid test() {
test(std::basic_format_args( test(std::basic_format_args(
std::make_format_args<std::basic_format_context< std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<char>>, char>>())); std::back_insert_iterator<std::basic_string<char>>, char>>()));
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test(std::basic_format_args( test(std::basic_format_args(
std::make_format_args<std::basic_format_context< std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>())); std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>()));
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test(std::basic_format_args( test(std::basic_format_args(
std::make_format_args<std::basic_format_context< std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>>())); std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>>()));
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test(std::basic_format_args( test(std::basic_format_args(
std::make_format_args<std::basic_format_context< std::make_format_args<std::basic_format_context<
std::back_insert_iterator<std::basic_string<char16_t>>, std::back_insert_iterator<std::basic_string<char16_t>>,
Show All 13 Lines

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linesconstexpr void test(const CharT* fmt) {
context.advance_to(context.begin() + 1); context.advance_to(context.begin() + 1);
assert(context.begin() == context.end()); assert(context.begin() == context.end());
} }
} }
constexpr bool test() { constexpr bool test() {
test("abc"); test("abc");
test(L"abc"); test(L"abc");
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test(u8"abc"); test(u8"abc");
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test(u"abc"); test(u"abc");
test(U"abc"); test(U"abc");
#endif #endif
return true; return true;
} }
int main(int, char**) { int main(int, char**) {
test(); test();
static_assert(test()); static_assert(test());
return 0; return 0;
} }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp

Show All 32 Linesconstexpr void test(const CharT* fmt) {
assert(context.begin() == view.begin()); assert(context.begin() == view.begin());
ASSERT_NOEXCEPT(context.begin()); ASSERT_NOEXCEPT(context.begin());
} }
} }
constexpr bool test() { constexpr bool test() {
test("abc"); test("abc");
test(L"abc"); test(L"abc");
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test(u8"abc"); test(u8"abc");
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test(u"abc"); test(u"abc");
test(U"abc"); test(U"abc");
#endif #endif
return true; return true;
} }
int main(int, char**) { int main(int, char**) {
test(); test();
static_assert(test()); static_assert(test());
return 0; return 0;
} }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines ASSERT_NOEXCEPT(
assert(context.begin() == view.begin()); assert(context.begin() == view.begin());
assert(context.end() == view.end()); assert(context.end() == view.end());
} }
} }
constexpr bool test() { constexpr bool test() {
test("abc"); test("abc");
test(L"abc"); test(L"abc");
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test(u8"abc"); test(u8"abc");
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test(u"abc"); test(u"abc");
test(U"abc"); test(U"abc");
#endif #endif
return true; return true;
} }
int main(int, char**) { int main(int, char**) {
test(); test();
static_assert(test()); static_assert(test());
return 0; return 0;
} }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

Show All 32 Linesconstexpr void test(const CharT* fmt) {
assert(context.end() == view.end()); assert(context.end() == view.end());
ASSERT_NOEXCEPT(context.end()); ASSERT_NOEXCEPT(context.end());
} }
} }
constexpr bool test() { constexpr bool test() {
test("abc"); test("abc");
test(L"abc"); test(L"abc");
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test(u8"abc"); test(u8"abc");
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test(u"abc"); test(u"abc");
test(U"abc"); test(U"abc");
#endif #endif
return true; return true;
} }
int main(int, char**) { int main(int, char**) {
test(); test();
static_assert(test()); static_assert(test());
return 0; return 0;
} }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/types.compile.pass.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines static_assert(
typename std::basic_format_parse_context<CharT>::const_iterator>); typename std::basic_format_parse_context<CharT>::const_iterator>);
} }
constexpr void test() { constexpr void test() {
test<char>(); test<char>();
#ifndef TEST_HAS_NO_WIDE_CHARACTERS #ifndef TEST_HAS_NO_WIDE_CHARACTERS
test<wchar_t>(); test<wchar_t>();
#endif #endif
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test<char8_t>(); test<char8_t>();
#endif #endif
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test<char16_t>(); test<char16_t>();
test<char32_t>(); test<char32_t>();
#endif #endif
} }
Show All 9 Lines

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesconstexpr void test() {
std::cmp_greater(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_greater'}} std::cmp_greater(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_greater'}}
std::cmp_greater(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater'}} std::cmp_greater(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater'}}
std::cmp_greater_equal(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}} std::cmp_greater_equal(T(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}}
std::cmp_greater_equal(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}} std::cmp_greater_equal(T(), int()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}}
std::cmp_greater_equal(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}} std::cmp_greater_equal(int(), T()); // expected-error 10-11 {{no matching function for call to 'cmp_greater_equal'}}
std::in_range<T>(int()); // expected-error 10-11 {{no matching function for call to 'in_range'}} std::in_range<T>(int()); // expected-error 10-11 {{no matching function for call to 'in_range'}}
std::in_range<int>(T()); // expected-error 10-11 {{no matching function for call to 'in_range'}} std::in_range<int>(T()); // expected-error 10-11 {{no matching function for call to 'in_range'}}
} }
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
template <class T> template <class T>
constexpr void test_char8t() { constexpr void test_char8t() {
std::cmp_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_equal'}} std::cmp_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_equal'}}
std::cmp_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_equal'}} std::cmp_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_equal'}}
std::cmp_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_equal'}} std::cmp_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_equal'}}
std::cmp_not_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}} std::cmp_not_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}}
std::cmp_not_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}} std::cmp_not_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}}
std::cmp_not_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}} std::cmp_not_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_not_equal'}}
std::cmp_less(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_less'}} std::cmp_less(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_less'}}
std::cmp_less(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_less'}} std::cmp_less(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_less'}}
std::cmp_less(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_less'}} std::cmp_less(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_less'}}
std::cmp_less_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}} std::cmp_less_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}}
std::cmp_less_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}} std::cmp_less_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}}
std::cmp_less_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}} std::cmp_less_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_less_equal'}}
std::cmp_greater(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater'}} std::cmp_greater(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater'}}
std::cmp_greater(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_greater'}} std::cmp_greater(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_greater'}}
std::cmp_greater(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater'}} std::cmp_greater(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater'}}
std::cmp_greater_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}} std::cmp_greater_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
std::cmp_greater_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}} std::cmp_greater_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
std::cmp_greater_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}} std::cmp_greater_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
std::in_range<T>(int()); // expected-error 1 {{no matching function for call to 'in_range'}} std::in_range<T>(int()); // expected-error 1 {{no matching function for call to 'in_range'}}
std::in_range<int>(T()); // expected-error 1 {{no matching function for call to 'in_range'}} std::in_range<int>(T()); // expected-error 1 {{no matching function for call to 'in_range'}}
} }
#endif // _LIBCPP_HAS_NO_CHAR8_T #endif // TEST_HAS_NO_CHAR8_T
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
template <class T> template <class T>
constexpr void test_uchars() { constexpr void test_uchars() {
std::cmp_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}} std::cmp_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
std::cmp_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_equal'}} std::cmp_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
std::cmp_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}} std::cmp_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
std::cmp_not_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_not_equal'}} std::cmp_not_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_not_equal'}}
Show All 26 Lines#endif
test<double>(); test<double>();
test<long double>(); test<long double>();
test<std::byte>(); test<std::byte>();
test<NonEmptyT>(); test<NonEmptyT>();
test<ColorT>(); test<ColorT>();
test<std::nullptr_t>(); test<std::nullptr_t>();
test<EmptyT>(); test<EmptyT>();
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef TEST_HAS_NO_CHAR8_T
test_char8t<char8_t>(); test_char8t<char8_t>();
#endif // _LIBCPP_HAS_NO_CHAR8_T #endif // TEST_HAS_NO_CHAR8_T
#ifndef TEST_HAS_NO_UNICODE_CHARS #ifndef TEST_HAS_NO_UNICODE_CHARS
test_uchars<char16_t>(); test_uchars<char16_t>();
test_uchars<char32_t>(); test_uchars<char32_t>();
#endif #endif
return 0; return 0;
} }

libcxx/test/support/test_macros.h

Show First 20 Lines • Show All 374 Lines • ▼ Show 20 Lines
#if defined(_LIBCPP_HAS_NO_UNICODE_CHARS) #if defined(_LIBCPP_HAS_NO_UNICODE_CHARS)
# define TEST_HAS_NO_UNICODE_CHARS # define TEST_HAS_NO_UNICODE_CHARS
#endif #endif
#if defined(_LIBCPP_HAS_NO_LOCALIZATION) #if defined(_LIBCPP_HAS_NO_LOCALIZATION)
# define TEST_HAS_NO_LOCALIZATION # define TEST_HAS_NO_LOCALIZATION
#endif #endif
#if TEST_STD_VER <= 17 || !defined(__cpp_char8_t)
# define TEST_HAS_NO_CHAR8_T
#endif
#if defined(__GNUC__) #if defined(__GNUC__)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
#endif #endif
#endif // SUPPORT_TEST_MACROS_HPP #endif // SUPPORT_TEST_MACROS_HPP